999、platform设备驱动实验

港控/mmm° 2023-01-12 04:15 108阅读 0赞

#### 一、驱动的分离和分隔 ####

驱动的分隔，也就是将主机驱动和设备驱动分隔开来，比如 I2C、 SPI 等等都会采用驱动分隔的方式来简化驱动的开发。在实际的驱动开发中，一般 I2C 主机控制器驱动已经由半导体厂家编写好了，而设备驱动一般也由设备器件的厂家编写好了，我们只需要提供设备信息即可，比如 I2C 设备的话提供设备连接到了哪个 I2C 接口上， I2C 的速度是多少等等。相当于将设备信息从设备驱动中剥离开来，驱动使用标准方法去获取到设备信息(比如从设备树中获取到设备信息)，然后根据获取到的设备信息来初始化设备。 这样就相当于驱动只负责驱动，设备只负责设备，想办法将两者进行匹配即可。这个就是 Linux 中的总线(bus)、驱动(driver)和设备(device)模型，也就是常说的驱动分离。总线就是驱动和设备信息的月老，负责给两者牵线搭桥

#### 二、驱动的分层 ####

上一小节讲了驱动的分隔与分离，本节我们来简单看一下驱动的分层，大家应该听说过网络的 7 层模型，不同的层负责不同的内容。同样的， Linux 下的驱动往往也是分层的，分层的目的也是为了在不同的层处理不同的内容。

#### 三、platform 平台驱动模型简介 ####

前面我们讲了设备驱动的分离，并且引出了总线(bus)、驱动(driver)和设备(device)模型，比如 I2C、 SPI、 USB 等总线。但是在 SOC 中有些外设是没有总线这个概念的，但是又要使用总线、驱动和设备模型该怎么办呢？为了解决此问题， Linux 提出了 platform 这个虚拟总线，相应的就有 platform\_driver 和 platform\_device

##### 3.1 platform 总线 #####

Linux系统内核使用 bus\_type结构体表示总线，此结构体定义在文件 include/linux/device.h，  
bus\_type 结构体内容如下：

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 };

match 函数，此函数很重要，单词 match 的意思就是“匹配、相配”，因此此函数就是完成设备和驱动之间匹配的，总线就是使用 match 函数来根据注册的设备来查找对应的驱，或者根据注册的驱动来查找相应的设备，因此每一条总线都必须实现此函数。 match 函数有两个参数： dev 和 drv，这两个参数分别为 device 和 device\_driver 类型，也就是设备和驱动。  
platform 总线是 bus\_type 的一个具体实例，定义在文件 drivers/base/platform.c， platform 总  
线定义如下：

platform\_bus\_type 就是 platform 平台总线，其中 platform\_match 就是匹配函数。我们来看一下驱动和设备是如何匹配的， platform\_match 函数定义在文件 drivers/base/platform.c 中

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)
    		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))
    		return 1;
    
    	/* Then try to match against the id table */
    	if (pdrv->id_table)
    		return platform_match_id(pdrv->id_table, pdev) != NULL;
    
    	/* fall-back to driver name match */
    	return (strcmp(pdev->name, drv->name) == 0);
    }

第 11~12 行，第一种匹配方式， OF 类型的匹配，也就是设备树采用的匹配方式，  
of\_driver\_match\_device 函数定义在文件 include/linux/of\_device.h 中。 device\_driver 结构体(表示设备驱动)中有个名为 of\_match\_table的成员变量，此成员变量保存着驱动的 compatible匹配表，设备树中的每个设备节点的 compatible 属性会和 of\_match\_table 表中的所有成员比较，查看是否有相同的条目，如果有的话就表示设备和此驱动匹配，设备和驱动匹配成功以后 probe 函数就会执行。  
第 15~16 行，第二种匹配方式， ACPI 匹配方式。  
第 19~20 行，第三种匹配方式， id\_table 匹配，每个 platform\_driver 结构体有一个 id\_table成员变量，顾名思义，保存了很多 id 信息。这些 id 信息存放着这个 platformd 驱动所支持的驱动类型。  
第 23 行，第四种匹配方式，如果第三种匹配方式的 id\_table 不存在的话就直接比较驱动和设备的 name 字段，看看是不是相等，如果相等的话就匹配成功。  
对于支持设备树的 Linux 版本号，一般设备驱动为了兼容性都支持设备树和无设备树两种匹配方式。也就是第一种匹配方式一般都会存在，第三种和第四种只要存在一种就可以，一般用的最多的还是第四种，也就是直接比较驱动和设备的 name 字段，毕竟这种方式最简单了。

##### 3.2、platform 驱动 #####

platform\_driver 结 构 体 表 示 platform 驱 动 ， 此 结 构 体 定 义 在 文 件  
include/linux/platform\_device.h 中，内容如下：

1 struct platform_driver { 
    2 int (*probe)(struct platform_device *);
    3 int (*remove)(struct platform_device *);
    4 void (*shutdown)(struct platform_device *);
    5 int (*suspend)(struct platform_device *, pm_message_t state);
    6 int (*resume)(struct platform_device *);
    7 struct device_driver driver;
    8 const struct platform_device_id *id_table;
    9 bool prevent_deferred_probe;
    10 };

第 2 行， probe 函数，当驱动与设备匹配成功以后 probe 函数就会执行，非常重要的函数！！  
一般驱动的提供者会编写，如果自己要编写一个全新的驱动，那么 probe 就需要自行实现。  
第 7 行， driver 成员，为 device\_driver 结构体变量， Linux 内核里面大量使用到了面向对象的思维， device\_driver 相当于基类，提供了最基础的驱动框架。 plaform\_driver 继承了这个基类，然后在此基础上又添加了一些特有的成员变量。  
device\_driver 结构体定义在 include/linux/device.h， device\_driver 结构体内容如下：

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 结构体类型，此结构体定义在文件 include/linux/mod\_devicetable.h 中，内  
容如下：

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)

还需要在驱动卸载函数中通过 platform\_driver\_unregister 函数卸载 platform 驱动，  
platform\_driver\_unregister 函数原型如下：

void platform_driver_unregister(struct platform_driver *drv)

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");
    82 MODULE_AUTHOR("zuozhongkai");

第 52 行是一个标记， of\_device\_id 表最后一个匹配项必须是空的。  
总体来说， platform 驱动还是传统的字符设备驱动、块设备驱动或网络设备驱动，只是套上了一张“platform” 的皮，目的是为了使用总线、驱动和设备这个驱动模型来实现驱动的分  
离与分层。

##### 3.2、platform 驱动设备 #####

platform 驱动已经准备好了，我们还需要 platform 设备，否则的话单单一个驱动也做不了什么。 platform\_device 这个结构体表示 platform 设备，这里我们要注意，如果内核支持设备树的话就不要再使用 platform\_device 来描述设备了，因为改用设备树去描述了。当然了，你如果一定要用 platform\_device 来描述设备信息的话也是可以的。 platform\_device 结构体定义在文件include/linux/platform\_device.h 中，结构体内容如下：

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 结构体内容如下：

18 struct resource { 
    19 resource_size_t start;
    20 resource_size_t end;
    21 const char *name;
    22 unsigned long flags;
    23 struct resource *parent, *sibling, *child;
    24 };

可选的资源类型都定义在了文件include/linux/ioport.h 里面  
在以前不支持设备树的 Linux版本中，用户需要编写 platform\_device变量来描述设备信息，然后使用 platform\_device\_register 函数将设备信息注册到 Linux 内核中，此函数原型如下所示：

int platform_device_register(struct platform_device *pdev)

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

void platform_device_unregister(struct platform_device *pdev)

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 
    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");
    43 MODULE_AUTHOR("zuozhongkai");

上面示例代码要是在不支持设备树的 Linux 版本中使用的，当 Linux 内核支持了设备树以后就不需要用户手动去注册 platform 设备了。因为设备信息都放到了设备树中去描述，Linux 内核启动的时候会从设备树中读取设备信息，然后将其组织成 platform\_device 形式