Linux驱动——总线模型

目录

 一.平台总线

二、driver 驱动

三、device设备

---

        我们在前面接触的设备驱动都非常的简单，都是对IO进行最简单的读写操作。回忆一下字符驱动编写的流程

1.设备驱动模型
2.实现加载入口函数xxx_init()和卸载入口函数xxx_exit()
3.申请设备号 register_chrdev()(与内核相关)
4. 利用udev和mdev机制创建设备文件(节点)class_create、device_create
5.硬件部分初始化
        1）io资源映射--ioremap
        2） 注册中断
6.构建file_operation结构
7.实现具体的硬件操作方法：xxx_read、xxx_open

        像I2C、SPI、LCD 等这些复杂外设的驱动就不能这么去写了，Linux 系统要考虑到驱动的可重用性，因此提出了驱动的分离与分层这样的软件思路，在这个思路下诞生了我们将来最常打交道的platform 设备驱动，也叫做平台设备驱动。

平台总线三要素：bus、driver、device

  一.平台总线

         platform 总线是 bus_type 的一个具体实例，定义在文件 drivers/base/platform.c，platform 总线定义如下：

1 struct bus_type platform_bus_type = {
2     .name = "platform",
3     .dev_groups = platform_dev_groups,
4     .match = platform_match,
5     .uevent = platform_uevent,
6     .pm = &platform_dev_pm_ops,
7 };

        platform_bus_type 就是 platform 平台总线，其中 platform_match 就是匹配函数。我们来看
一下驱动和设备是如何匹配的，platform_match 函数定义在文件 drivers/base/platform.c 中，函
数内容如下所示：

1 static int platform_match(struct device *dev,struct device_driver *drv)
2 {
3     struct platform_device *pdev = to_platform_device(dev);
4     struct platform_driver *pdrv = to_platform_driver(drv);
5
6     /*When driver_override is set,only bind to the matching driver*/
7     if (pdev->driver_override)
8     return !strcmp(pdev->driver_override, drv->name);
9
10     /* Attempt an OF style match first */
11     if (of_driver_match_device(dev, drv))
12         return 1;
13
14     /* Then try ACPI style match */
15     if (acpi_driver_match_device(dev, drv))
16         return 1;
17
18     /* Then try to match against the id table */
19     if (pdrv->id_table)
20         return platform_match_id(pdrv->id_table, pdev) != NULL;
21
22     /* fall-back to driver name match */
23       return (strcmp(pdev->name, drv->name) == 0);
24 }

驱动和设备的匹配有四种方法，我们依次来看一下：

1.第一种匹配方式，第 11~12 行， OF 类型的匹配，也就是设备树采用的匹配方式，
        of_driver_match_device 函数定义在文件 include/linux/of_device.h 中。device_driver 结构体(表示设备驱动)中有个名为of_match_table的成员变量，此成员变量保存着驱动的compatible匹配表，设备树中的每个设备节点的 compatible 属性会和 of_match_table 表中的所有成员比较，查看是否有相同的条目，如果有的话就表示设备和此驱动匹配，设备和驱动匹配成功以后 probe 函数就会执行。

2.第二种匹配方式，第 15~16 行，ACPI 匹配方式。

3.第三种匹配方式，第 19~20 行，id_table 匹配。

        每个 platform_driver 结构体有一个id_table成员变量，顾名思义，保存了很多 id 信息。这些 id 信息存放着这个 platformd 驱动所支持的驱动类型。

4.第四种匹配方式，第 23 行，如果第三种匹配方式的 id_table 不存在的话就直接比较驱动和
设备的 name 字段，看看是不是相等，如果相等的话就匹配成功。

        对于支持设备树的 Linux 版本号，一般设备驱动为了兼容性都支持设备树和无设备树两种匹配方式。也就是第一种匹配方式一般都会存在，第三种和第四种只要存在一种就可以，一般用的最多的还是第四种，也就是直接比较驱动和设备的 name 字段，毕竟这种方式最简单了。

 二、driver 驱动

platform_driver 结 构 体 表 示 platform 驱 动 

1 struct device_driver {
2     const char *name;
3     struct bus_type *bus;
4
5     struct module *owner;
6     const char *mod_name; /* used for built-in modules */
7
8     bool suppress_bind_attrs; /* disables bind/unbind via sysfs */
9
10     const struct of_device_id *of_match_table;
11     const struct acpi_device_id *acpi_match_table;
12
13     int (*probe) (struct device *dev);
14     int (*remove) (struct device *dev);
15     void (*shutdown) (struct device *dev);
16     int (*suspend) (struct device *dev, pm_message_t state);
17     int (*resume) (struct device *dev);
18     const struct attribute_group **groups;
19
20     const struct dev_pm_ops *pm;
21
22     struct driver_private *p;
23 };

        第 10 行，of_match_table 就是采用设备树的时候驱动使用的匹配表，同样是数组，每个匹
配项都为 of_device_id 结构体类型

1 struct of_device_id {
2     char name[32];
3     char type[32];
4     char compatible[128];
5     const void *data;
6 };

 第 4 行的 compatible 非常重要，因为对于设备树而言，就是通过设备节点的 compatible 属
性值和 of_match_table 中每个项目的 compatible 成员变量进行比较，如果有相等的就表示设备
和此驱动匹配成功。

在编写 platform 驱动的时候，首先定义一个 platform_driver 结构体变量，然后实现结构体中的各个成员变量，重点是实现匹配方法以及 probe 函数。当驱动和设备匹配成功以后 probe函数就会执行，具体的驱动程序在 probe 函数里面编写，比如字符设备驱动等等。当我们定义并初始化好 platform_driver 结构体变量以后，需要在驱动入口函数里面调用platform_driver_register 函数向 Linux 内核注册一个 platform 驱动，platform_driver_register 函数

原型如下所示：
int platform_driver_register (struct platform_driver *driver)
函数参数和返回值含义如下：
        driver：要注册的 platform 驱动。
        返回值：负数，失败；0，成功。

还需要在驱动卸载函数中通过 platform_driver_unregister 函数卸载 platform 驱动，
platform_driver_unregister

函数原型如下：
void platform_driver_unregister(struct platform_driver *drv)
函数参数和返回值含义如下：
        drv：要卸载的 platform 驱动。
        返回值：无。

 platform 驱动框架如下所示：

/* 设备结构体 */
1 struct xxx_dev{
2     struct cdev cdev;
3     /* 设备结构体其他具体内容 */
4 };
5
6 struct xxx_dev xxxdev; /* 定义个设备结构体变量 */
7
8 static int xxx_open(struct inode *inode, struct file *filp)
9 {
10     /* 函数具体内容 */
11     return 0;
12 }
13
14 static ssize_t xxx_write(struct file *filp, const char __user *buf,size_t cnt, loff_t *offt)
15 {
16     /* 函数具体内容 */
17     return 0;
18 }
19
20
21 * 字符设备驱动操作集
22 */
23 static struct file_operations xxx_fops = {
24     .owner = THIS_MODULE,
25     .open = xxx_open,
26     .write = xxx_write,
27 };
28
29 /*
30 * platform 驱动的 probe 函数
31 * 驱动与设备匹配成功以后此函数就会执行
32 */
33 static int xxx_probe(struct platform_device *dev)
34 {
35     ......
36     cdev_init(&xxxdev.cdev, &xxx_fops); /* 注册字符设备驱动 */
37     /* 函数具体内容 */
38     return 0;
39 }
40
41 static int xxx_remove(struct platform_device *dev)
42 {
43     ......
44     cdev_del(&xxxdev.cdev);/* 删除 cdev */
45     /* 函数具体内容 */
46     return 0;
47 }
48
49 /* 匹配列表 */
50 static const struct of_device_id xxx_of_match[] = {
51     { .compatible = "xxx-gpio" },
52     { /* Sentinel */ }
53 };
54
55 /*
56 * platform 平台驱动结构体
57 */
58 static struct platform_driver xxx_driver = {
59     .driver = {
60     .name = "xxx",
61     .of_match_table = xxx_of_match,
62             },
63     .probe = xxx_probe,
64     .remove = xxx_remove,
65 };
66
67 /* 驱动模块加载 */
68 static int __init xxxdriver_init(void)
69 {
70     return platform_driver_register(&xxx_driver);
71 }
72
73 /* 驱动模块卸载 */
74 static void __exit xxxdriver_exit(void)
75 {
76     platform_driver_unregister(&xxx_driver);
77 }
78
79 module_init(xxxdriver_init);
80 module_exit(xxxdriver_exit);
81 MODULE_LICENSE("GPL");

三、device设备

platform 驱动已经准备好了，我们还需要 platform 设备。platform_device 结构体内容如下：

22 struct platform_device {
23     const char *name;
24     int id;
25     bool id_auto;
26     struct device dev;
27     u32 num_resources;
28     struct resource *resource;
29
30     const struct platform_device_id *id_entry;
31     char *driver_override; /* Driver name to force a match */
32
33     /* MFD cell pointer */
34     struct mfd_cell *mfd_cell;
35
36     /* arch specific additions */
37     struct pdev_archdata archdata;
38 };

第 23 行，name 表示设备名字，要和所使用的 platform 驱动的 name 字段相同，否则的话设
备就无法匹配到对应的驱动。比如对应的 platform 驱动的 name 字段为“xxx-gpio”，那么此 name
字段也要设置为“xxx-gpio”。
第 27 行，num_resources 表示资源数量，一般为第 28 行 resource 资源的大小。
第 28 行，resource 表示资源，也就是设备信息，比如外设寄存器等。Linux 内核使用 resource
结构体表示资源，resource 结构体内容如下：

 struct resource {
     resource_size_t start;
     resource_size_t end;
     const char *name;
     unsigned long flags;
     struct resource *parent, *sibling, *child;
 };

start 和 end 分别表示资源的起始和终止信息，对于内存类的资源，就表示内存起始和终止
地址，name 表示资源名字，flags 表示资源类型。

        用户需要编写platform_device变量来描述设备信息，然后使用 platform_device_register 函数将设备信息注册到 Linux 内核中，此函数原型如下所示：

int platform_device_register(struct platform_device *pdev)
函数参数和返回值含义如下：
        pdev：要注册的 platform 设备。
        返回值：负数，失败；0，成功。

如果不再使用 platform 的话可以通过 platform_device_unregister 函数注销掉相应的 platform设备，platform_device_unregister 函数原型如下：

void platform_device_unregister(struct platform_device *pdev)
函数参数和返回值含义如下：
pdev：要注销的 platform 设备。
返回值：无。

platform 设备信息框架如下所示：

1 /* 寄存器地址定义*/
2 #define PERIPH1_REGISTER_BASE (0X20000000) /* 外设 1 寄存器首地址 */
3 #define PERIPH2_REGISTER_BASE (0X020E0068) /* 外设 2 寄存器首地址 */
4 #define REGISTER_LENGTH 4
5
6 /* 资源 */
7 static struct resource xxx_resources[] = {
8     [0] = {
9     .start = PERIPH1_REGISTER_BASE,
10     .end = (PERIPH1_REGISTER_BASE + REGISTER_LENGTH - 1),
11     .flags = IORESOURCE_MEM,
12 },
13     [1] = {
14     .start = PERIPH2_REGISTER_BASE,
15     .end = (PERIPH2_REGISTER_BASE + REGISTER_LENGTH - 1),
16     .flags = IORESOURCE_MEM,
17     },
18 };
19
20 /* platform 设备结构体 */
21 static struct platform_device xxxdevice = {
22     .name = "xxx-gpio",
23     .id = -1,
24     .num_resources = ARRAY_SIZE(xxx_resources),
25     .resource = xxx_resources,
26 };
27
28 /* 设备模块加载 */
29 static int __init xxxdevice_init(void)
30 {
31     return platform_device_register(&xxxdevice);
32 }
33
34 /* 设备模块注销 */
35 static void __exit xxx_resourcesdevice_exit(void)
36 {
37     platform_device_unregister(&xxxdevice);
38 }
39
40 module_init(xxxdevice_init);
41 module_exit(xxxdevice_exit);
42 MODULE_LICENSE("GPL");