Linux驱动的软件架构

基本思想：将驱动与设备分离，具体来说，驱动只管驱动，设备只管设备，总线负责匹配设备和驱动，而驱动以标准途径拿到板级信息。

设备指与项目有关的板级信息，项目用到的板级资源；驱动指对芯片、对硬件的操作。

Linux字符设备驱动需要编写file_operations成员函数，并负责处理阻塞、非阻塞、多路复用、SIGIO等。但我们面对一个真实硬件驱动时，并不像干所有事情，只需要实现我们关注的事情。这样就需要一个分层思想，因为所有输入设备都是一样的，可以提炼一个中间层，将软件进行分层：提炼一个input的核心层，把跟Linux接口以及整个一套input事件的汇报机制都在这里实现。

驱动与设备分离示意图：

Linux驱动分层：

在单片机中，我们可能有多个 SPI控制器，如YYY1，YYY2。如果对每个SPI控制器都单独设一个驱动API，那么会有：

spi_client_yyy1_work1()
spi_client_yyy2_work2()

如果有数个spi控制器，那么就会多个驱动API。类似地，其他主机控制器可能也有多个，这样驱动API数量就会爆炸性增长，而它们的操作是类似的，有没有什么办法解决这个问题？
可以将Linux设备驱动的主机控制器与外设驱动分离，主机控制器不用关心外设，而外设也不用关心主机，外设只是访问核心层的通用API进行数据传输，主机和外设间可以进行任意组合。

Linux设备驱动的主机与外设驱动分离：

platform_device 总线设备

Linux2.6后，驱动模型只用关心3个实体：总线、设备、驱动。

• 总线
  总线将设备和驱动绑定。系统每注册一个设备时，会寻找与之匹配的驱动；相反，系统中每注册一个驱动时，会寻找与之匹配的设备。
  Linux并没有实体的总线，而是发明了虚拟总线，也称为platform总线。一个设备、驱动都挂接在一种总线上。

• 设备
  一个platform_device对象代表一个总线设备。platform_device并不是与字符设备、块设备、网络设备并列概念，而是Linux系统提供的一种附加手段，如SoC内部集成的I2C，RTC、LCD，Watchdog等控制器都归纳为platform_device，而这些本身就是字符设备。

• 驱动
  一个platform_driver对象代表一个总线驱动。

引入platform概念的好处：
1）使得设备被挂接在一个总线上，符合Linux2.6以后内核的设备模型。使配套的sysfs节点、设备电源管理都成为可能。
2）隔离BSP和驱动。BSP中调用platform设备和设备使用的资源、具体配置，而驱动中只需要通过通用API获取资源和数据。如此，板相关代码和驱动代码分离，驱动具有更好的可扩展性和跨平台性。
3）让一个驱动支持多个设备实例。

总线设备、驱动相关结构体

platform_device结构体：

struct platform_device {
    const char    *name; // 设备名称
    int         id; // 设备号
    bool        id_auto;
    struct device    dev;
    u32        num_resources;
    struct resource    *resource;

    const struct platform_device_id    *id_entry;
    char *driver_override; /* Driver name to force a match */

    /* MFD cell pointer */
    struct mfd_cell *mfd_cell;

    /* arch specific additions */
    struct pdev_archdata    archdata;
};

platform_driver 结构体：

struct platform_driver {
    int (*probe)(struct platform_device *);
    int (*remove)(struct platform_device *);
    void (*shutdown)(struct platform_device *);
    int (*suspend)(struct platform_device *, pm_message_t state); // 挂起 用于电源管理, 过时
    int (*resume)(struct platform_device *); // 恢复 用于电源管理, 过时
    struct device_driver driver;
    const struct platform_device_id *id_table;
    bool prevent_deferred_probe;
};

platform_driver 包含probe、remove、一个device_driver实例、电源管理函数suspend、resume。

电源管理可以用suspend, resume，但已经过时，更好的办法是实现device_driver中的dev_pm_ops结构体成员。

device_driver定义

struct device_driver {
    const char        *name;
    struct bus_type        *bus;

    struct module        *owner;
    const char        *mod_name;    /* used for built-in modules */

    bool suppress_bind_attrs;    /* disables bind/unbind via sysfs */
    enum probe_type probe_type;

    const struct of_device_id    *of_match_table;
    const struct acpi_device_id    *acpi_match_table;

    int (*probe) (struct device *dev);
    int (*remove) (struct device *dev);
    void (*shutdown) (struct device *dev);
    int (*suspend) (struct device *dev, pm_message_t state);
    int (*resume) (struct device *dev);
    const struct attribute_group **groups;

    const struct dev_pm_ops *pm;

    struct driver_private *p;
};

跟platform_driver 地位对等的i2c_driver、spi_driver、usb_driver、pci_driver中都包含了device_driver实例成员。描述了各种xxx_driver（xxx代表总线名）在驱动意义上的一些共性。

系统为platform总线定义了一个bus_type 实例platform_bus_type，位于drivers/base/platform.c。

struct bus_type platform_bus_type = {
    .name          = "platform",
    .dev_groups    = platform_dev_groups,
    .match         = platform_match,
    .uevent        = platform_uevent,
    .pm            = &platform_dev_pm_ops,
};
EXPORT_SYMBOL_GPL(platform_bus_type);

重点是match()，该函数确定了platform_device和platform_driver之间如何匹配。

static int platform_match(struct device *dev, struct device_driver *drv)
{
    struct platform_device *pdev = to_platform_device(dev);
    struct platform_driver *pdrv = to_platform_driver(drv);

    /* When driver_override is set, only bind to the matching driver */
    if (pdev->driver_override) // 匹配platform_device的driver_override和驱动名
        return !strcmp(pdev->driver_override, drv->name);

    /* Attempt an OF style match first */
    if (of_driver_match_device(dev, drv)) // 基于设备树风格的匹配
        return 1;

    /* Then try ACPI style match */
    if (acpi_driver_match_device(dev, drv)) // 基于ACPI风格匹配
        return 1;

    /* Then try to match against the id table */
    if (pdrv->id_table) // 匹配ID表
        return platform_match_id(pdrv->id_table, pdev) != NULL;

    /* fall-back to driver name match */
    return (strcmp(pdev->name, drv->name) == 0); // 匹配platform_device设备名和驱动名
}

platform_device（总线设备）和platform_driver（总线驱动）匹配有5种方式，按顺序排列：
1）匹配platform_device的driver_override和驱动名；（不推荐）
2）基于设备树风格的匹配；（推荐）
3）基于ACPI风格匹配；
4）匹配ID表，即platform_device设备名是否出现在platform_driver的ID表内；（推荐）
5）匹配platform_device设备名和驱动名；（推荐）

如何添加一个platform_device？
Linux 2.6 ARM，platform_device定义为一个数组，通过platform_add_devices()注册总线设备。它内部调用platform_device_register() 注册单个设备。

int platform_add_devices(struct platform_device **devs, int num);

Linux 3.x后，根据设备树内容自动展开platform_device，而不再推荐通过手动编码填写platform_device和注册。

platform 设备资源和数据

platform 设备资源

platform_device 定义中，由resource结构体描述资源。resource定义如下：

struct resource {
    resource_size_t start; // 资源开始值
    resource_size_t end;   // 资源结束值
    const char *name;
    unsigned long flags;   // 资源类型, 值可为 IORESOURCE_IO/IORESOURCE_MEM/IORESOURCE_IRQ/IORESOURCE_DMA
    unsigned long desc;
    struct resource *parent, *sibling, *child;
};

通常关注start、end、flags 这3个字段，分别表示资源开始值、资源结束值、资源类型。start、end含义随flags不同而不同，例如：

• flags为IORESOURCE_MEM，start、end表示该设备占据的内存起始地址、结束地址；
• flags为IORESOURCE_IRQ，start、end表示该设备使用的中断号开始值和结束值（左闭右闭）；

多份同类型资源，可停用多个start、end、flags。

如何获取设备资源？可通过platform_get_resource()，获得该dev中某种类型（type）的第num个资源。num从0开始计数。

#include <linux/platform_device.h>

struct resource *platform_get_resource(struct platform_device *dev, unsigned int type, unsigned int num);

对于IRQ类型资源，还有一个变体platform_get_irq()。

#include <linux/platform_device.h>

int platform_get_irq(struct platform_device *dev, unsigned int num);

例，在arch/arm/mach-at91/board-sam9261ek.c板文件中，为DM9000网卡定义了如下resource：

static struct resource dm9000_resource[] = {
    [0] = {
        .start = AT91_CHIPSELECT_2,
        .end   = AT91_CHIPSELECT_2 + 3,
        .flags = IORESOURCE_MEM
    },
    [1] = {
        .start = AT91_CHIPSELECT_2 + 0x44,
        .end   = AT91_CHIPSELECT_2 + 0xFF,
        .flags = IORESOURCE_MEM
    },
    [2] = {
        .flags = IORESOURCE_IRQ | IORESOURCE_IRQLOWEDGE | IORESOURCE_IRQ_HIGHEDGE,
    },
};

在DM9000网卡驱动中，通过下面办法获得这3份资源：

db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
db->addr_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);

platform_data 设备数据

设备除了在BSP中定义资源（resource）外，还能附加一些数据信息，因为对设备的硬件描述除了中断、内存等标准资源外，可能还有一些配置信息，而这些配置信息依赖于板，不适宜放在设备驱动上。因此，platform提供platform_data支持。

platform_data 由每个驱动自定义。定义时，可以只存放一个结构体指针；解析时，根据结构体类型来解析。
例如，对于DM9000网卡，为platform_data定义一个dm9000_plat_data结构体，定义完后，可以将MAC地址、总线宽度、板上有无EEPROM信息等放入platform_data中。

static struct dm9000_plat_data dm9000_platdata = {
    .flags = DM9000_PLATF_16BITONLY | DM9000_PLATF_NO_EEPROM,
};

static struct platform_device dm9000_device = {
    .name = "dm9000",
    .id = 0,
    .num_resources = ARRAY_SIZE(dm9000_resource),
    .resource = dm9000_resource,
    .dev = {
        .platform_data = &dm9000_platdata, // 自定义设备数据
    }
};

如何获取设备数据？
可使用dev_get_platdata()。例如，在DM9000网卡驱动的probe()中，可这样拿到platform_data：

struct dm9000_plat_data *pdata = dev_get_platdata(&pdev->dev);

如何基于总线设备、驱动写程序？

以100ask使用2个GPIO驱动2个led灯的简单例子进行说明。主要分为两类工作：定义设备和驱动。

总线设备

总线设备指定项目用到的板级资源，因此放到与板配置相关目录board_A_led.c中，主要任务是定义并注册platform_device对象。

注意：现在通常不手动定义总线设备，而是通过设备树（dts）文件来定义设备使用的资源，因此实际项目中可能看不到这部分代码。

1）定义资源对象（resource）
定义2个GPIO口，为IORESOURCE_IRQ类资源。

/* 定义资源 */
static struct resource resources[] = {
    {
        .start = GROUP_PIN(3, 1), /* GPIO3_1 */
        .flags = IORESOURCE_IRQ,  /* flags 表示哪一类资源 */
    },
    {
        .start = GROUP_PIN(5, 8), /* GPIO5_8 */
        .flags = IORESOURCE_IRQ,
    },
};

2）定义设备对象（platform_device）

/* 把定义的资源添加到总线设备中
*
* 还需要定义一个与platform_device匹配的platform_dirver
*/
static struct platform_device board_A_led_dev = {
    .name = "100ask_led",                   /*总线设备名称  */
    .num_resources = ARRAY_SIZE(resources), /* 资源个数 */
    .resource = resources,
};

3）注册设备
通过board_A_led模块加载函数，注册总线设备（platform_device对象）。

static int led_dev_init(void)
{
    int err;
    /* register device */
    err = platform_device_register(&board_A_led_dev);
    return 0;
}

4）反注册设备
利用board_A_led模块卸载函数，反注册总线设备（platform_device对象）。

static void led_dev_exit(void)
{
    int err;
    /* unregister device */
    err = platform_device_unregister(&board_A_led_dev);
}

5）其他工作：指定入口函数、出口函数

module_init(led_dev_init);
module_exit(led_dev_exit);

MODULE_LICENSE("GPL");

其中，pdev为platform_device指针。

总线驱动

与板子无关，与具体的芯片和用到的外设相关，因此放到与芯片相关的chip_demo_gpio.c。主要任务是定义并注册platform_driver对象。

1）定义总线驱动结对象
需要与总线设备配对，即名称相同。

/*
* 总线驱动
* 需要与platform_device(总线设备)配对
*/
static struct platform_driver chip_demo_gpio_drv = {
    .driver = {
        .name = "100ask_led", /* 总线驱动名字, 要与总线设备名字配对 */
    },
    .probe    = chip_demo_gpio_led_probe,  /* 当发现配对的platform_device时, 就会调用probe函数 */
    .remove    = chip_demo_gpio_led_remove, /* 当把platform device去掉时, 就会掉调用remove函数 */
};

2）在probe函数中，获取资源，并创建逻辑设备（device_create）

static int chip_demo_gpio_led_probe(struct platform_device *dev)
{
    int i = 0;
    struct resource *res;

    while (1) { /* 因为用到了多个引脚资源, 所有用while循环获取 */
        res = platform_get_resource(dev, IORESOURCE_IRQ, i++);
        if (!res)
            break;
        /* save pin */
        g_ledpins[g_ledcnt] = res->start;

        /* device_create */
        led_device_create(g_ledcnt);
        g_ledcnt++
    }

    return 0;
}

led_device_create和led_device_destroy是上层leddrv.c中定义的，分别用于创建和销毁逻辑设备的函数。

为什么要在上层leddrv.c中定义？
因为调用device_create需要led_class（设备逻辑类 class_create创建），是static类型，只在leddrv.c中可见。

void led_device_create(int minor)
{
    device_create(led_class, NULL, MKDEV(major, minor), NULL, "100ask_led%d", minor);
}

void led_device_destroy(int minor)
{
    device_destroy(led_class, MKDEV(major, minor));
}
EXOPRT_SYMBOL(led_device_create);
EXOPRT_SYMBOL(led_device_destroy);

3）在remove函数中，销毁逻辑设备（device_destroy）

static int chip_demo_gpio_led_remove(struct platform_device *pdev)
{
    int i = 0;
    /* device_destroy */
    for (i = 0; i < g_ledcnt; i++) {
        led_device_destroy(i);
    }
    g_ledcnt = 0;

    return 0;
}

4）注册总线驱动
利用chip_demo_gpio模块的加载函数chip_demo_gpio_drv_init，来注册总线驱动。

static int chip_demo_gpio_drv_init(void)
{
    int err;
    err = platform_driver_register(&chip_demo_gpio_drv);   /* 注册总线驱动 */
    register_led_operation(&board_demo_led_opr);
    return 0;
}

5）反注册总线驱动
利用chip_demo_gpio模块的卸载函数chip_demo_gpio_drv_exit，来反注册总线驱动。

static void chip_demo_gpio_drv_exit(void)
{
    int err;
    err = platform_driver_unregister(&chip_demo_gpio_drv); /* 反注册总线驱动 */
}

6）登记chip_demo_gpio模块的入口函数、出口函数

module_init(chip_demo_gpio_drv_init);
module_exit(chip_demo_gpio_drv_exit);
MODULE_LICENSE("GPL");

完整源码示例参见：04_led_drv_template_bus_dev_drv | gitee

附：与总线设备、驱动有关的常用函数

注册/反注册platform_device

platform_device_register 注册总线设备；
platform_device_unregister 反注册总线设备；

#include <linux/platform_device.h>

int platform_device_register(struct platform_device *);
void platform_device_unregister(struct platform_device *);

注册/反注册platform_driver

platform_driver_register 注册总线驱动；
platform_driver_unregister 反注册总线驱动。

#include <linux/platform_device.h>

#define platform_driver_register(drv) 
    __platform_driver_register(drv, THIS_MODULE)

int __platform_driver_register(struct platform_driver *,
                    struct module *);
void platform_driver_unregister(struct platform_driver *);

注册多个device

platform_add_devices 一次注册多个device

int platform_add_devices(struct platform_device **, int);

获得设备资源

platform_get_resource 获得该dev中某类型（type）的第num个资源。num从0开始计数。

#include <linux/platform_device.h>

struct resource *platform_get_resource(struct platform_device *dev, unsigned int type, unsigned int num);

platform_get_irq 获得该dev中某类型（type）的第num个中断。num从0开始计数。

#include <linux/platform_device.h>

int platform_get_irq(struct platform_device *dev, unsigned int num);

platform_get_resource_byname 通过名字获得该dev的某类型（type）资源。

#include <linux/platform_device.h>

struct resource *platform_get_resource_byname(struct platform_device *dev,
                          unsigned int type,
                          const char *name)

通过名字（name）返回该dev的中断号。

#include <linux/platform_device.h>

int platform_get_irq_byname(struct platform_device *dev, const char *name);

参考

[1]宋宝华. Linux设备驱动开发详解[M]. 人民邮电出版社, 2010.