Linux 驱动—— platform 虚拟总线

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

一、Linux 驱动的分离与分层

1、驱动的分隔与分离

        对于 Linux 这样一个成熟、庞大、复杂的操作系统，代码的重用性非常重要，否则的话就会在 Linux 内核中存在大量无意义的重复代码。尤其是驱动程序，因为驱动程序占用了 Linux内核代码量的大头，如果不对驱动程序加以管理，任由重复的代码肆意增加，那么用不了多久Linux 内核的文件数量就庞大到无法接受的地步。

        假如现在有三个平台 A、B 和 C，这三个平台(这里的平台说的是 SOC)上都有 MPU6050 这 个 I2C 接口的六轴传感器，按照我们写裸机 I2C 驱动的时候的思路，每个平台都有一个 MPU6050的驱动，因此编写出来的最简单的驱动框架如图：

        可以看出，每种平台下都有一个主机驱动和设备驱动，主机驱动肯定是必须要的，毕竟不同的平台其 I2C 控制器不同。但是右侧的设备驱动就没必要每个平台都写一个，因为不管对于那个 SOC 来说， MPU6050 都是一样，通过 I2C 接口读写数据就行了，只需要一个 MPU6050 的驱动程序即可。

        如果再来几个 I2C 设备，比如 AT24C02、FT5206(电容触摸屏) 等，如果按照上图 中的写法，那么 设备端的驱动 将会重复的编写好几次。显然在 Linux 驱动程序中这种写法是不推荐的，最好的做法就是每个平台的 I2C 控制器都提供一个统一的接口(也叫做主机驱动)，每个设备的话也只提供一个驱动程序(设备驱动) ，每个设备通过统一的 I2C 接口驱动来访问，这样就可以大大简化驱动文件。三种平台下的 MPU6050 驱动框架就可以简化为下图：

        实际的 I2C 驱动设备肯定有很多种，不止 MPU6050 这一个，那么实际的驱动架构如下图：

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

        当我们向系统注册一个驱动的时候，总线就会在右侧的设备中查找，看看有没有与之匹配的设备，如果有的话就将两者联系起来。同样的，当向系统中注册一个设备的时候，总线就会在左侧的驱动中查找看有没有与之匹配的设备，有的话也联系起来。Linux 内核中大量的驱动程序都采用总线、驱动和设备模式。

二、platform 平台驱动模型简介

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

1、platform 总线

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

        第 10 行， 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 中，函数内容如下所示：

        第 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 字段，毕竟这种方式最简单了。

2、platform 驱动

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

        第 2 行， probe 函数，当驱动与设备匹配成功以后 probe 函数就会执行，非常重要的函数！！一般驱动的提供者会编写，如果自己要编写一个全新的驱动，那么 probe 就需要自行实现。

        第 7 行， driver 成员，为 device_driver 结构体变量， Linux 内核里面大量使用到了面向对象的思维，device_driver 相当于基类，提供了最基础的驱动框架。 plaform_driver 继承了这个基类，然后在此基础上又添加了一些特有的成员变量。

        第 8 行， id_table 表，也就是前面讲解 platform 总线匹配驱动和设备的时候采用的第三种方法，id_table 是个表 ( 也就是数组 ) ，每个元素的类型为 platform_device_id， platform_device_id 结构体内容如下：

        device_driver 结构体定义在 include/linux/device.h ， device_driver 结构体内容如下：

        第 10 行， of_match_table 就是采用设备树的时候驱动使用的匹配表，同样是数组，每个匹配项都为 of_device_id 结构体类型，此结构体定义在文件 include/linux/mod_devicetable.h 中，内容如下：

        第 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 驱动框架如下所示：

/*--------------------------第一部分-------------------------------*/
/* 设备结构体 */
struct xxx_dev {
    struct cdev cdev;
    /* 设备结构体其他具体内容 */
        
};

struct xxx_dev xxxdev; /* 定义个设备结构体变量 */

static int xxx_open(struct inode* inode, struct file* filp)
{
    /* 函数具体内容 */
    return 0;
}

static ssize_t xxx_write(struct file* filp, const char __user * buf,size_t cnt, loff_t * offt)
{
    /* 函数具体内容 */
    return 0;
}

/* * 字符设备驱动操作集*/
static struct file_operations xxx_fops = {
    .owner = THIS_MODULE,
    .open = xxx_open,
    .write = xxx_write,
};
/*--------------------------第二部分-------------------------------*/

/*
* platform 驱动的 probe 函数
* 驱动与设备匹配成功以后此函数就会执行
*/
static int xxx_probe(struct platform_device* dev)
{
    //......
    cdev_init(&xxxdev.cdev, &xxx_fops); /* 注册字符设备驱动 */
    /* 函数具体内容 */
    return 0;
}

/*--------------------------第三部分-------------------------------*/

static int xxx_remove(struct platform_device* dev)
{
    // ......
    cdev_del(&xxxdev.cdev);/* 删除 cdev */
    /* 函数具体内容 */
    return 0;
}

/*--------------------------第四部分-------------------------------*/

/* 匹配列表 */
static const struct of_device_id xxx_of_match[] = {
{
    .compatible = "xxx-gpio" },
    { /* Sentinel */ }
};

/*--------------------------第五部分-------------------------------*/

/*platform 平台驱动结构体*/
static struct platform_driver xxx_driver = {
    .driver = {
        .name = "xxx",
        .of_match_table = xxx_of_match,
    },
    .probe = xxx_probe,
    .remove = xxx_remove,
};

/*--------------------------第六部分-------------------------------*/

/* 驱动模块加载 */
static int __init xxxdriver_init(void)
{
    return platform_driver_register(&xxx_driver);
}

/* 驱动模块卸载 */
static void __exit xxxdriver_exit(void)
{
    platform_driver_unregister(&xxx_driver);
}

module_init(xxxdriver_init);
module_exit(xxxdriver_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("#ifndef _strive_h");

        第一部分： 传统的字符设备驱动，所谓的 platform 驱动并不是独立于字符设备驱动、块设备驱动和网络设备驱动之外的其他种类的驱动。platform 只是为了驱动的分离与分层而提出来的一种框架，其驱动的具体实现还是需要字符设备驱动、块设备驱动或网络设备驱动。

        第二部分： xxx_probe 函数，当驱动和设备匹配成功以后此函数就会执行，以前在驱动入口 init 函数里面编写的字符设备驱动程序就全部放到此 probe 函数里面。比如注册字符设备驱动、添加 cdev 、创建类等等。

        第三部分：xxx_remove 函数， platform_driver 结构体中的 remove 成员变量，当关闭 platform 设备驱动的时候此函数就会执行，以前在驱动卸载 exit 函数里面要做的事情就放到此函数中来。比如，使用 iounmap 释放内存、删除 cdev ，注销设备号等等。

        第四部分： xxx_of_match 匹配表，如果使用设备树的话将通过此匹配表进行驱动和设备的匹配。其中 设置了一个匹配项，此匹配项的 compatible 值为“ xxx-gpio ”，因此当设备树中设备节点的 compatible 属性值为“ xxx-gpio”的时候此设备就会与此驱动匹配。第匹配项下有一个标记，of_device_id 表最后一个匹配项必须是空的。

        第五部分：定义一个 platform_driver 结构体变量 xxx_driver，表示 platform 驱动， 设置 paltform_driver 中的 device_driver 成员变量的 name 和 of_match_table 这两个属性。其中 name 属性用于传统的驱动与设备匹配，也就是检查驱动和设备的 name 字段是不是相同。of_match_table 属性就是用于设备树下的驱动与设备检查。对于一个完整的驱动程序，必须提供有设备树和无设备树两种匹配方法。最后 设置 probe 和 remove 这两成员变量。

        第六部分：驱动入口函数，调用platform_driver_register 函数向 Linux 内核注册一个 platform

驱动，也就是上面定义的 xxx_driver 结构体变量。 驱动出口函数，调用 platform_driver_unregister 函数卸载前面注册的 platform 驱动。

        总体来说，platform 驱动还是传统的字符设备驱动、块设备驱动或网络设备驱动，只是套上了一张“platform ”的皮，目的是为了使用总线、驱动和设备这个驱动模型来实现驱动的分离与分层。

3、platform 设备

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

        第 23 行， name 表示设备名字，要和所使用的 platform 驱动的 name 字段相同，否则的话设备就无法匹配到对应的驱动。比如对应的 platform 驱动的 name 字段为“ xxx-gpio ”，那么此 name 字段也要设置为“xxx-gpio ”。

        第 27 行， num_resources 表示资源数量，一般为第 28 行 resource 资源的大小。

        第 28 行， resource 表示资源，也就是设备信息，比如外设寄存器等。 Linux 内核使用 resource 结构体表示资源，resource 结构体内容如下：

        start 和 end 分别表示资源的起始和终止信息，对于内存类的资源，就表示内存起始和终止地址，name 表示资源名字， flags 表示资源类型，可选的资源类型都定义在了文件 include/linux/ioport.h 里面，如下所示：

        在以前不支持设备树的Linux 版本中，用户需要编写 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 设备信息框架如下所示：

/* 寄存器地址定义*/
#define PERIPH1_REGISTER_BASE(0X20000000) /* 外设 1 寄存器首地址 */
#define PERIPH2_REGISTER_BASE(0X020E0068) /* 外设 2 寄存器首地址 */
#define REGISTER_LENGTH 4

/*--------------------------第一部分-------------------------------*/

/* 资源 */
static struct resource xxx_resources[] = {
    [0] = {
    .start = PERIPH1_REGISTER_BASE,
    .end = (PERIPH1_REGISTER_BASE + REGISTER_LENGTH - 1),
    .flags = IORESOURCE_MEM,
    },
    [1] = {
    .start = PERIPH2_REGISTER_BASE,
    .end = (PERIPH2_REGISTER_BASE + REGISTER_LENGTH - 1),
    .flags = IORESOURCE_MEM,
    },
};

/*--------------------------第二部分-------------------------------*/

/* platform 设备结构体 */
static struct platform_device xxxdevice = {
    .name = "xxx-gpio",
    .id = -1,
    .num_resources = ARRAY_SIZE(xxx_resources),
    .resource = xxx_resources,
};

/*--------------------------第三部分-------------------------------*/

/* 设备模块加载 */
static int __init xxxdevice_init(void)
{
    return platform_device_register(&xxxdevice);
}

/* 设备模块注销 */
static void __exit xxx_resourcesdevice_exit(void)
{
    platform_device_unregister(&xxxdevice);
}

module_init(xxxdevice_init);
module_exit(xxxdevice_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("#ifndef _strive_h");

        第一部分：数组 xxx_resources 表示设备资源，一共有两个资源，分别为设备外设 1 和外设 2 的寄存器信息。因此 flags 都为 IORESOURCE_MEM ，表示资源为内存类型的。

        第二部分：platform 设备结构体变量，注意 name 字段要和所使用的驱动中的 name 字段

一致，否则驱动和设备无法匹配成功。 num_resources 表示资源大小，其实就是数组 xxx_resources 的元素数量，这里用 ARRAY_SIZE 来测量一个数组的元素个数。

        第三部分：设备模块加载函数，在此函数中调用 platform_device_register 向 Linux 内核注 册platform 设备。 设备模块卸载函数，在此函数中调用 platform_device_unregister 从 Linux 内核中卸载 platform 设备。

        platform 设备主要用于不支持设备树的 Linux 版本中使用的，当 Linux 内核支持了设 备树以后就不需要用户手动去注册 platform 设备了。因为设备信息都放到了设备树中去描述，Linux 内核启动的时候会从设备树中读取设备信息，然后将其组织成 platform_device 形式，至于设备树到 platform_device 的具体过程就不去详细的追究了，感兴趣的可以去看一下，网上也有很多博客详细的讲解了整个过程。