树莓派3B点灯（2） - 北京网站建设

这篇是上接第一篇的设备树部分，主要是分析目前树莓派的驱动以及设备树的匹配机制。

树莓派3B点灯（1）-CSDN博客

这次看的内核来自：https://github.com/raspberrypi/linux/tree/rpi-6.1.y/

最后成功的设备树内容如下：

/dts-v1/;
/plugin/;/ {compatible = "brcm,bcm2837";fragment@0 {target = <&leds>;__overlay__ {my_led: myled {label = "pwrbtnled";gpios = <&gpio 26 0>;linux,default-trigger = "heartbeat";};};};
};

之前的贴文说过，设备树就是驱动的配置文件。设备树学习-CSDN博客

现在看看上面的DTS是怎么对应的驱动。

compatible = "brcm,bcm2837"; 这个字段用于声明与硬件设备（即树莓派 3B 的 SoC，Broadcom BCM2837 芯片）兼容。内核使用 compatible 属性来匹配合适的驱动程序，并知道如何处理该设备树配置。brcm 代表 Broadcom，而 bcm2837 是树莓派 3B 的处理器型号。

fragment@0：设备树覆盖文件中，可以包含多个片段（fragments），每个片段用于修改特定的硬件功能或节点。@0 表示这是第一个片段。不知道这个是树莓派独有还有整个Linux内核都这样。

target = <&leds>;：target 用来指定要修改或扩展的现有设备树节点。&leds 是一个在设备树中已定义的别名，通常指向树莓派上与 LED 相关的部分。这个片段的目标是修改与 LED 控制相关的设备树节点。

overlay__：定义一个覆盖节点，该节点将添加或修改现有设备树结构。不知道这个是树莓派独有还有整个Linux内核都这样。很多地方都说这个和fragment必须要加上。

my_led: myled { ... }：定义了一个新的 LED 节点，名称为 my_led，其别名为 myled。这个节点表示一个新的 LED 设备，里面具体的属性就不多说了。

现在看看具体的leds节点：

来自arch\arm\boot\dts\broadcom\bcm2837-rpi-3-b-plus.dts

arch\arm\boot\dts\broadcom\bcm283x-rpi-led-deprecated.dtsi

/ {/** This file provides the now deprecated ACT LED to the* Raspberry Pi boards. Please don't include this file* for new boards!*/leds: leds {compatible = "gpio-leds";led_act: led-act {label = "ACT";default-state = "keep";linux,default-trigger = "heartbeat";};};
};

这里定义了leds这个节点，以及里面的act这个灯。当然，我们最关心的还是compatible = "gpio-leds";这个对应了驱动程序。

很快就可以找到源代码，drivers\leds\leds-gpio.c

// SPDX-License-Identifier: GPL-2.0-only
/** LEDs driver for GPIOs** Copyright (C) 2007 8D Technologies inc.* Raphael Assenat <raph@8d.com>* Copyright (C) 2008 Freescale Semiconductor, Inc.*/
#include <linux/err.h>
#include <linux/gpio.h>
#include <linux/gpio/consumer.h>
#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/property.h>
#include <linux/slab.h>
#include "leds.h"struct gpio_led_data {struct led_classdev cdev;struct gpio_desc *gpiod;u8 can_sleep;u8 blinking;gpio_blink_set_t platform_gpio_blink_set;
};static inline struct gpio_led_data *cdev_to_gpio_led_data(struct led_classdev *led_cdev)
{return container_of(led_cdev, struct gpio_led_data, cdev);
}static void gpio_led_set(struct led_classdev *led_cdev,enum led_brightness value)
{struct gpio_led_data *led_dat = cdev_to_gpio_led_data(led_cdev);int level;if (value == LED_OFF)level = 0;elselevel = 1;if (led_dat->blinking) {led_dat->platform_gpio_blink_set(led_dat->gpiod, level,NULL, NULL);led_dat->blinking = 0;} else if (led_dat->cdev.flags & SET_GPIO_INPUT) {gpiod_direction_input(led_dat->gpiod);led_dat->cdev.flags &= ~SET_GPIO_INPUT;} else if (led_dat->cdev.flags & SET_GPIO_OUTPUT) {gpiod_direction_output(led_dat->gpiod, level);led_dat->cdev.flags &= ~SET_GPIO_OUTPUT;} else {if (led_dat->can_sleep ||(led_dat->cdev.flags & (SET_GPIO_INPUT | SET_GPIO_OUTPUT) ))gpiod_set_value_cansleep(led_dat->gpiod, level);elsegpiod_set_value(led_dat->gpiod, level);}
}static int gpio_led_set_blocking(struct led_classdev *led_cdev,enum led_brightness value)
{gpio_led_set(led_cdev, value);return 0;
}static enum led_brightness gpio_led_get(struct led_classdev *led_cdev)
{struct gpio_led_data *led_dat =container_of(led_cdev, struct gpio_led_data, cdev);return gpiod_get_value_cansleep(led_dat->gpiod) ? LED_FULL : LED_OFF;
}static int gpio_blink_set(struct led_classdev *led_cdev,unsigned long *delay_on, unsigned long *delay_off)
{struct gpio_led_data *led_dat = cdev_to_gpio_led_data(led_cdev);led_dat->blinking = 1;return led_dat->platform_gpio_blink_set(led_dat->gpiod, GPIO_LED_BLINK,delay_on, delay_off);
}static int create_gpio_led(const struct gpio_led *template,struct gpio_led_data *led_dat, struct device *parent,struct fwnode_handle *fwnode, gpio_blink_set_t blink_set)
{struct led_init_data init_data = {};struct pinctrl *pinctrl;int ret, state;led_dat->cdev.default_trigger = template->default_trigger;led_dat->can_sleep = gpiod_cansleep(led_dat->gpiod);if (!led_dat->can_sleep)led_dat->cdev.brightness_set = gpio_led_set;elseled_dat->cdev.brightness_set_blocking = gpio_led_set_blocking;led_dat->blinking = 0;if (blink_set) {led_dat->platform_gpio_blink_set = blink_set;led_dat->cdev.blink_set = gpio_blink_set;}led_dat->cdev.brightness_get = gpio_led_get;if (template->default_state == LEDS_GPIO_DEFSTATE_KEEP) {state = gpiod_get_value_cansleep(led_dat->gpiod);if (state < 0)return state;} else {state = (template->default_state == LEDS_GPIO_DEFSTATE_ON);}led_dat->cdev.brightness = state;led_dat->cdev.max_brightness = 1;if (!template->retain_state_suspended)led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;if (template->panic_indicator)led_dat->cdev.flags |= LED_PANIC_INDICATOR;if (template->retain_state_shutdown)led_dat->cdev.flags |= LED_RETAIN_AT_SHUTDOWN;ret = gpiod_direction_output(led_dat->gpiod, state);if (ret < 0)return ret;if (template->name) {led_dat->cdev.name = template->name;ret = devm_led_classdev_register(parent, &led_dat->cdev);} else {init_data.fwnode = fwnode;ret = devm_led_classdev_register_ext(parent, &led_dat->cdev,&init_data);}if (ret)return ret;pinctrl = devm_pinctrl_get_select_default(led_dat->cdev.dev);if (IS_ERR(pinctrl)) {ret = PTR_ERR(pinctrl);if (ret != -ENODEV) {dev_warn(led_dat->cdev.dev,"Failed to select %pOF pinctrl: %d\n",to_of_node(fwnode), ret);} else {/* pinctrl-%d not present, not an error */ret = 0;}}return ret;
}struct gpio_leds_priv {int num_leds;struct gpio_led_data leds[];
};static struct gpio_leds_priv *gpio_leds_create(struct platform_device *pdev)
{struct device *dev = &pdev->dev;struct fwnode_handle *child;struct gpio_leds_priv *priv;int count, ret;count = device_get_child_node_count(dev);if (!count)return ERR_PTR(-ENODEV);priv = devm_kzalloc(dev, struct_size(priv, leds, count), GFP_KERNEL);if (!priv)return ERR_PTR(-ENOMEM);device_for_each_child_node(dev, child) {struct gpio_led_data *led_dat = &priv->leds[priv->num_leds];struct gpio_led led = {};/** Acquire gpiod from DT with uninitialized label, which* will be updated after LED class device is registered,* Only then the final LED name is known.*/led.gpiod = devm_fwnode_gpiod_get(dev, child, NULL, GPIOD_ASIS,NULL);if (IS_ERR(led.gpiod)) {fwnode_handle_put(child);return ERR_CAST(led.gpiod);}led_dat->gpiod = led.gpiod;led.default_state = led_init_default_state_get(child);if (fwnode_property_present(child, "retain-state-suspended"))led.retain_state_suspended = 1;if (fwnode_property_present(child, "retain-state-shutdown"))led.retain_state_shutdown = 1;if (fwnode_property_present(child, "panic-indicator"))led.panic_indicator = 1;ret = create_gpio_led(&led, led_dat, dev, child, NULL);if (ret < 0) {fwnode_handle_put(child);return ERR_PTR(ret);}/* Set gpiod label to match the corresponding LED name. */gpiod_set_consumer_name(led_dat->gpiod,led_dat->cdev.dev->kobj.name);priv->num_leds++;}return priv;
}static const struct of_device_id of_gpio_leds_match[] = {{ .compatible = "gpio-leds", },{},
};MODULE_DEVICE_TABLE(of, of_gpio_leds_match);static struct gpio_desc *gpio_led_get_gpiod(struct device *dev, int idx,const struct gpio_led *template)
{struct gpio_desc *gpiod;unsigned long flags = GPIOF_OUT_INIT_LOW;int ret;/** This means the LED does not come from the device tree* or ACPI, so let's try just getting it by index from the* device, this will hit the board file, if any and get* the GPIO from there.*/gpiod = devm_gpiod_get_index(dev, NULL, idx, GPIOD_OUT_LOW);if (!IS_ERR(gpiod)) {gpiod_set_consumer_name(gpiod, template->name);return gpiod;}if (PTR_ERR(gpiod) != -ENOENT)return gpiod;/** This is the legacy code path for platform code that* still uses GPIO numbers. Ultimately we would like to get* rid of this block completely.*//* skip leds that aren't available */if (!gpio_is_valid(template->gpio))return ERR_PTR(-ENOENT);if (template->active_low)flags |= GPIOF_ACTIVE_LOW;ret = devm_gpio_request_one(dev, template->gpio, flags,template->name);if (ret < 0)return ERR_PTR(ret);gpiod = gpio_to_desc(template->gpio);if (!gpiod)return ERR_PTR(-EINVAL);return gpiod;
}static int gpio_led_probe(struct platform_device *pdev)
{struct gpio_led_platform_data *pdata = dev_get_platdata(&pdev->dev);struct gpio_leds_priv *priv;int i, ret = 0;if (pdata && pdata->num_leds) {priv = devm_kzalloc(&pdev->dev, struct_size(priv, leds, pdata->num_leds),GFP_KERNEL);if (!priv)return -ENOMEM;priv->num_leds = pdata->num_leds;for (i = 0; i < priv->num_leds; i++) {const struct gpio_led *template = &pdata->leds[i];struct gpio_led_data *led_dat = &priv->leds[i];if (template->gpiod)led_dat->gpiod = template->gpiod;elseled_dat->gpiod =gpio_led_get_gpiod(&pdev->dev,i, template);if (IS_ERR(led_dat->gpiod)) {dev_info(&pdev->dev, "Skipping unavailable LED gpio %d (%s)\n",template->gpio, template->name);continue;}ret = create_gpio_led(template, led_dat,&pdev->dev, NULL,pdata->gpio_blink_set);if (ret < 0)return ret;}} else {priv = gpio_leds_create(pdev);if (IS_ERR(priv))return PTR_ERR(priv);}platform_set_drvdata(pdev, priv);return 0;
}static void gpio_led_shutdown(struct platform_device *pdev)
{struct gpio_leds_priv *priv = platform_get_drvdata(pdev);int i;for (i = 0; i < priv->num_leds; i++) {struct gpio_led_data *led = &priv->leds[i];if (!(led->cdev.flags & LED_RETAIN_AT_SHUTDOWN))gpio_led_set(&led->cdev, LED_OFF);}
}static struct platform_driver gpio_led_driver = {.probe		= gpio_led_probe,.shutdown	= gpio_led_shutdown,.driver		= {.name	= "leds-gpio",.of_match_table = of_gpio_leds_match,},
};module_platform_driver(gpio_led_driver);MODULE_AUTHOR("Raphael Assenat <raph@8d.com>, Trent Piepho <tpiepho@freescale.com>");
MODULE_DESCRIPTION("GPIO LED driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:leds-gpio");

这个就是一个标准的内核的模块，还好吧，也不算太长，毕竟也不是很复杂的功能。不过看看整个文件夹，内容还是不错（下面还有很多，因为长度关系没显示完）。

看看GPT怎么说：

Linux 内核的 **LED 驱动** 主要用于控制和管理系统中连接的各种 LED 设备，特别是通过 GPIO 引脚控制的 LED。该驱动提供了一种标准化的方法，允许用户和内核子系统控制 LED 的状态（例如开关、闪烁等），并且支持各种触发器（trigger）来自动控制 LED 的行为。

### 1. LED 驱动的概述
LED 驱动程序位于内核代码的 `drivers/leds/` 目录下，主要管理系统中各种类型的 LED。它允许用户通过 `/sys/class/leds/` 接口控制 LED 的行为，也支持内核自动控制 LED，常用于指示系统状态、硬件活动、CPU 负载等。

Linux 内核中的 LED 驱动支持以下功能：
- **GPIO LED**：通过 GPIO 引脚控制的 LED。
- **LED 触发器（trigger）**：通过触发器自动控制 LED（如心跳模式、硬盘活动指示等）。
- **可编程**：通过用户空间接口，可以动态配置 LED 的状态（开/关、闪烁频率等）。

### 2. LED 驱动的主要组件

#### 2.1 **LED 类设备**
LED 在 Linux 系统中被视为一个类设备（class device），每个 LED 设备会在 `/sys/class/leds/` 目录下生成一个相应的节点。例如，一个命名为 `status_led` 的 LED 设备会出现在 `/sys/class/leds/status_led/` 目录中，用户可以通过这个目录下的文件对 LED 进行控制。

常见的文件包括：
- **brightness**：控制 LED 的亮度（常用于简单的开关控制，`0` 表示关闭，`1` 表示打开）。
- **trigger**：指定 LED 的触发器模式，控制 LED 根据系统事件（如 CPU 负载、网络活动等）自动变化。
- **max_brightness**：表示 LED 支持的最大亮度值，通常是 1 或 255，表示最大亮度。

#### 2.2 **LED 触发器（Triggers）**
LED 驱动支持触发器（trigger）机制，它允许 LED 自动响应系统事件，而不需要手动控制。常见的 LED 触发器包括：
- **none**：没有触发器，手动控制 LED 的开关。
- **timer**：让 LED 以指定的时间间隔闪烁。
- **heartbeat**：LED 以类似“心跳”的方式闪烁，常用于指示系统正常运行。
- **cpuN**：LED 根据 CPU 核心 N 的使用状态闪烁。
- **activity**：表示某些硬件设备的活动状态（如网络、硬盘活动）。

可以通过 `/sys/class/leds/<led_name>/trigger` 来查看和设置当前 LED 支持的触发器。例如：

```bash
cat /sys/class/leds/status_led/trigger
```

显示的可能结果：

```
none [heartbeat] cpu0 cpu1 timer default-on
```

当前选中的触发器会用 `[]` 包裹，表示当前 LED 正在以“heartbeat”模式工作。

#### 2.3 **GPIO LED 驱动**
`leds-gpio` 驱动是最常用的 LED 驱动之一，用于通过 GPIO 控制 LED。它可以通过设备树 (`DTS`) 或平台代码定义与 GPIO 引脚绑定的 LED 设备。

设备树中通常这样配置 GPIO LED：

```dts
leds {
compatible = "gpio-leds";
pinctrl-names = "default";
pinctrl-0 = <&pinctrl_gpio>;

led0 {
label = "status_led";
gpios = <&gpio 26 GPIO_ACTIVE_HIGH>; // GPIO26 控制的LED，活动高电平
default-state = "off"; // 默认关闭
linux,default-trigger = "heartbeat"; // 触发器为“heartbeat”
};
};
```

- `compatible = "gpio-leds";`：使用 GPIO LED 驱动。
- `label`：定义 LED 的名称，用户可以在 `/sys/class/leds/` 看到相应的节点。
- `gpios`：定义控制 LED 的 GPIO 引脚及其活动状态（高/低电平）。
- `default-state`：启动时 LED 的初始状态（`on`, `off`, `keep`）。
- `linux,default-trigger`：定义默认的触发器。

### 3. 内核中的 LED 驱动文件

#### 3.1 **leds-class.c**
这个文件定义了 LED 子系统的通用接口，负责处理所有 LED 设备的注册、控制和触发器的管理。它实现了 `/sys/class/leds/` 中的文件接口。

路径：
```
drivers/leds/leds-class.c
```

#### 3.2 **leds-gpio.c**
`leds-gpio.c` 是 GPIO LED 的驱动，负责通过 GPIO 控制 LED。它主要通过设备树或平台代码定义 GPIO 与 LED 的关系，并且允许用户通过 `/sys/class/leds/` 控制 LED 的状态。

路径：
```
drivers/leds/leds-gpio.c
```

#### 3.3 **led-triggers.c**
这个文件实现了 LED 触发器的逻辑，定义了系统中各种自动控制 LED 的机制，比如 `heartbeat`，`cpu` 活动等。

路径：
```
drivers/leds/led-triggers.c
```

### 4. 使用 LED 驱动

#### 4.1 控制 LED
用户可以通过以下命令直接控制 LED：
- 打开 LED：
```bash
echo 1 > /sys/class/leds/<led_name>/brightness
```
- 关闭 LED：
```bash
echo 0 > /sys/class/leds/<led_name>/brightness
```

#### 4.2 设置触发器
设置 LED 的触发器为 `heartbeat`：

```bash
echo heartbeat > /sys/class/leds/<led_name>/trigger
```

设置为 `none` 以手动控制 LED：

```bash
echo none > /sys/class/leds/<led_name>/trigger
```

### 5. LED 驱动的应用场景
- **状态指示灯**：系统的电源、硬盘、网络等状态可以通过 LED 直观指示。
- **诊断工具**：通过 `heartbeat` 或 CPU 活动触发器，可以指示系统的运行健康状况。
- **用户可控的反馈**：某些用户设备上的 LED 可以用作反馈工具，例如在键盘上设置不同的 LED 指示不同的功能状态。

### 总结

Linux 内核的 LED 驱动为控制系统中通过 GPIO 引脚连接的 LED 提供了标准化的接口和灵活的触发器机制。通过 `/sys/class/leds/` 接口，用户和系统可以方便地管理和自动控制 LED 的状态，在嵌入式系统、物联网设备和服务器中有广泛应用。

待续。。。