Linux 驱动 | 重新理解一波设备驱动

多年来，我接触到的 Linux 驱动教程大多都是从 0 编写，这样对初学者而言最大的好处，就是可以接触到比较多的底层原理。

但是在真正的工作场景里，其实是应该尽量避免从 0 构建自己的设备驱动的。

更好的做法是在高度模块化的驱动框架里添加自己的设备驱动。

这样做的好处是最大程度地复用内核现有的代码，同时获得极大的弹性和可维护性，并且为应用程序提供出统一的访问接口。

下面详细地说说。

设备驱动程序 (device driver) 是对硬件的抽象:

提供基础框架来编写和运行设备驱动程序是操作系统内核责任的一部分。

尽管可以在用户空间中运行设备驱动程序（通过一些内核接口，如 UIO 或 I2CDEV），更常见的情况是让它们在内核空间中运行。

字符设备 (char device) 是一种最常见的硬件抽象。

/dev 目录下的设备节点文件就是内核导出给用户空间的访问设备驱动的接口。

设备节点文件中有三个基本信息：

• Type，用于标识是 block 还是 char device;
• Major number，用于标志是那一类 char deivce;
• Minor number，用于标志是哪一个 char device;

1、分配设备号，这通过 register_chrdev_region() 或 alloc_chrdev_region() 来完成;

2、实现文件操作（open、read、write、ioctl）等。

3、使用 cdev_init() 和 cdev_add() 向内核中注册字符设备。

如果按照从 0 构建的思路编写驱动的话，伪代码如下：

硬件访问相关：

static struct {
 dev_t devnum;
 struct cdev cdev;
 unsigned int led_status;
 void __iomem *regbase;
} drvled_data;
static void drvled_setled(unsigned int status)
{
 u32 val;
 /* set value */
 val = readl(drvled_data.regbase + GPIO1_REG_DATA);
 if (status == LED_ON)
 val |= GPIO_BIT;
 else if (status == LED_OFF)
 val &= ~GPIO_BIT;
 writel(val, drvled_data.regbase + GPIO1_REG_DATA);
 /* update status */
 drvled_data.led_status = status;
}
static void drvled_setdirection(void)
{
 ...
}

文件操作相关：

static ssize_t drvled_read(struct file *file, char __user *buf,
 size_t count, loff_t *ppos)
{
 ...
}
static ssize_t drvled_write(struct file *file, const char __user *buf,
 size_t count, loff_t *ppos)
{
 char kbuf = 0;
 if (copy_from_user(&kbuf, buf, 1))
 return -EFAULT;
 if (kbuf == '1') {
 drvled_setled(LED_ON);
 pr_info("LED ON!\n");
 } else if (kbuf == '0') {
 drvled_setled(LED_OFF);
 pr_info("LED OFF!\n");
 }
 return count;
}
static const struct file_operations drvled_fops = {
 .owner = THIS_MODULE,
 .write = drvled_write,
 .read = drvled_read,
};

注册和卸载字符设备相关：

static int __init drvled_init(void)
{
 int result = 0;
 if (!request_mem_region(GPIO1_BASE, GPIO1_SIZE, DRIVER_NAME)) {
 pr_err("%s: Error requesting I/O!\n", DRIVER_NAME);
 result = -EBUSY;
 goto ret_err_request_mem_region;
 }
 drvled_data.regbase = ioremap(GPIO1_BASE, GPIO1_SIZE);
 if (!drvled_data.regbase) {
 pr_err("%s: Error mapping I/O!\n", DRIVER_NAME);
 result = -ENOMEM;
 goto err_ioremap;
 }
 result = alloc_chrdev_region(&drvled_data.devnum, 0, 1, DRIVER_NAME);
 if (result) {

 pr_err("%s: Failed to allocate device number!\n", DRIVER_NAME);
 goto ret_err_alloc_chrdev_region;
 }
 cdev_init(&drvled_data.cdev, &drvled_fops);
 result = cdev_add(&drvled_data.cdev, drvled_data.devnum, 1);
 if (result) {
 pr_err("%s: Char device registration failed!\n", DRIVER_NAME);
 goto ret_err_cdev_add;
 }
 drvled_setdirection();
 drvled_setled(LED_OFF);
 pr_info("%s: initialized.\n", DRIVER_NAME);
 goto ret_ok;
ret_err_cdev_add:
 unregister_chrdev_region(drvled_data.devnum, 1);
ret_err_alloc_chrdev_region:
 iounmap(drvled_data.regbase);
err_ioremap:
 release_mem_region(GPIO1_BASE, GPIO1_SIZE);
ret_err_request_mem_region:
ret_ok:
 return result;
}
static void __exit drvled_exit(void)
{
 ...
}
module_init(drvled_init);
module_exit(drvled_exit);

运行效果：

$ install ledrv.ko
$ ls /dev/led
# 灯亮
$ echo 1 >/dev/led
# 灯灭
$ echo 1 >/dev/led

单从功能的角度看，上面的程序完全满足控制一个 LED 的需求。

但是，它不是一个好的驱动，这里有 3 个问题。

它创建的接口是 /dev/led，这不是一个通用接口，会增加上层开发人员的学习成本。

解决这个问题需要在 LED char driver 上再添加一层 LED framework，LED framework 负责给用户空间提供标准化的访问接口，同时用于添加可复用的逻辑功能。

基本上各种设备驱动都有自己的 framework，例如 input, IIO, ALSA, V2L2, RTC, watchdog 等。

使用这些 framework 驱动工程师不用考虑提供给用户空间的接口，应用开发人员也只需要学习一次标准的硬件访问接口接口。

它只是控制 1 个 gpio，但是却申请使用了 2 个寄存器，这 2 个寄存器负责控制芯片的 8 个 gpio。这意味着其他 7 个 gpio 再也没法被其他驱动申请使用。

解决这个问题需要引入一个 gpio 的管理者：gpiolib。gpiolib 负责统一管理和分配 gpio 资源。

它包含了硬件信息。如果我们想控制另外一个 gpio或者多个 gpio，就得改动源码，代码维护的工作量极大。

解决这个问题我们需要将硬件信息从代码中抽取出来，具体的就是引入总线、设备、驱动模型。

我们用上面的思路，写一个更合理的 LED 驱动。

1、初始化 led_classdev 结构体。

2、提供一个回调函数来改变状态 LED 的。

3、使用 led_classdev_register() 在想 LED framework 注册驱动程序。

内核管理 gpio 的思路是典型的 producer/consumer 模型。

GPIO controller driver 是 producer，LED driver 是 consumer。

下面是几个常用的 gpiolib api，它们的作用一目了然:

#include <linux/gpio.h>
#include <linux/gpio/consumer.h>
struct gpio_desc *gpiod_get(struct device *dev, const char *con_id,enum gpiod_flags flags);
void gpiod_put(struct gpio_desc *desc);
int gpiod_direction_input(struct gpio_desc *desc);
int gpiod_direction_output(struct gpio_desc *desc, int value);
void gpiod_set_value(struct gpio_desc *desc, int value);
int gpiod_get_value(const struct gpio_desc *desc);

该模型包含 4 部分。

Bus core： 对硬件总线的抽象，不同总线有不同的 Bus core，例如 USB core, SPI core, I2C core, PCI core ，在内核中由 bus_type 结构表示。

Bus adapters： 总线控制器驱动程序，在内核中由 device_driver 结构体表示。

Bus drivers： 负责管理连接到总线的设备的驱动程序，在内核中由 device_driver 结构体表示。

Bus devices： 连接到总线的设备，在内核中由结构 device 表示。

内核虚拟了一条叫 Platform 的总线，用于适配 LED 这种不属于任何总线的设备。

看下改造后的代码：

LED {
<&gpio1 9>
}

硬件控制：

tatic struct drvled_data_st *drvled_data;
static void drvled_setled(unsigned int status)
{
 // 控制 gpio
 if (status == LED_ON)
 gpiod_set_value(drvled_data->desc, 1);
 else
 gpiod_set_value(drvled_data->desc, 0);
}
static void drvled_change_state(struct led_classdev *led_cdev,
 enum led_brightness brightness)
{
 if (brightness)
 drvled_setled(LED_ON);
 else
 drvled_setled(LED_OFF);
}

向 LED framework 注册：

static int drvled_probe(struct platform_device *pdev)
{
 struct device_node *np = pdev->dev.of_node;
 struct device_node *child = NULL;
 int result, gpio;
 child = of_get_next_child(np, NULL);
 drvled_data = devm_kzalloc(&pdev->dev, sizeof(*drvled_data),
 GFP_KERNEL);
 if (!drvled_data)
 return -ENOMEM;
 // 从设备数中获得硬件信息
 gpio = of_get_gpio(child, 0);
 result = devm_gpio_request(&pdev->dev, gpio, pdev->name);
 if (result) {
 dev_err(&pdev->dev, "Error requesting GPIO\n");
 return result;
 }
 drvled_data->desc = gpio_to_desc(gpio);
 drvled_data->led_cdev.name = of_get_property(child, "label", NULL);
 drvled_data->led_cdev.brightness_set = drvled_change_state;
 // 注册进 LED framework
 result = devm_led_classdev_register(&pdev->dev, &drvled_data->led_cdev);
 if (result) {
 dev_err(&pdev->dev, "Error registering led\n");
 return result;
 }
 gpiod_direction_output(drvled_data->desc, 0);
 dev_info(&pdev->dev, "initialized.\n");
 return 0;
}
static int drvled_remove(struct platform_device *pdev)
{
 dev_info(&pdev->dev, "exiting.\n");
 return 0;
}
static const struct of_device_id of_drvled_match[] = {
 { .compatible = "labworks,drvled" },
 {},
};
static struct platform_driver drvled_driver = {
 .driver = {
 .name = "drvleds",
 .owner = THIS_MODULE,
 .of_match_table = of_drvled_match,
 },
 .probe = drvled_probe,
 .remove = drvled_remove,
};
module_platform_driver(drvled_driver);

改造后，应用总是通过下面这种标准的接口访问 LED：

# 灯亮
$ echo 1 > /sys/class/leds/<LED driver name>/brightness
# 灯灭
$ echo 0 > /sys/class/leds/<LED driver name>/brightness

并且有大量的 trigger 可供使用，例如让 LED 呈心跳状态的 heartbeat trigger：

$ echo heartbeat > /sys/class/leds/<LED driver name>/trigger

假设这时你想改用 gpio expander 芯片来控制 LED：

只需要添加这个 gpio expander 的驱动代码，并且修改设备树即可，其他部分完全不需要改动：

gpioexp {
I2C0, 0x10
}
LED {
<&gpioexp 3>
}

到此，你是否更清楚如何为 Linux 添加设备驱动了呢？