【linux】驱动-6-总线-设备-驱动

目录

• 前言
• 6. 总线-设备-驱动
  • 6.1 概念
  • 6.2 工作原理
  • 6.3 总线
    • 6.3.1 总线介绍
    • 6.3.2 注册总线
  • 6.4 设备
    • 6.4.1 设备介绍
    • 6.4.2 设备注册、注销
  • 6.5 驱动
    • 6.5.1 驱动介绍
    • 6.4.2 驱动注册、注销
  • 6.5 便解图文
  • 6.6 attribute属性文件
    • 6.6.1 attribute 介绍
    • 6.6.2 设备属性文件
    • 6.6.3 驱动属性文件
    • 6.6.4 总线属性文件
  • 6.7 匹配规则 **
    • 6.7.1 最先比较
    • 6.7.2 其次比较
    • 6.7.3 最后比较
    • 6.7.4 函数调用关系
  • 6.8 实现设备模型的简要步骤 *
    • 6.8.1 总线
    • 6.8.2 设备
    • 6.8.3 驱动
• 链接

---

前言

6. 总线-设备-驱动

总线-设备-驱动 又称为 设备驱动模型。

6.1 概念

• 

总线（bus)：负责管理挂载对应总线的设备以及驱动；
设备(device)：挂载在某个总线的物理设备；
驱动(driver)：与特定设备相关的软件，负责初始化该设备以及提供一些操作该设备的操作方式；
类(class)：对于具有相同功能的设备，归结到一种类别，进行分类管理；

6.2 工作原理

以下只说 总线-设备-驱动 模式下的操作
总线：

• 总线管理着两个链表：设备链表 和 驱动链表。
• 当我们向内核注册一个驱动时，便插入到总线的驱动链表。
• 当我们向内核注册一个设备时，便插入到总线的设备链表。
• 在插入的同时，总线会执行一个 bus_type 结构体中的 match 方法对新插入的 设备/驱动 进行匹配。（例如以名字的方式匹配。方式有很多总，下面再详细分析。）
• 匹配成功后，会调用 驱动 device_driver 结构体中的 probe 方法。（通常在 probe 中获取设备资源。具体有开发人员决定。）
• 在移除设备或驱动时，会调用 device_driver 结构体中的 remove 方法。

6.3 总线

6.3.1 总线介绍

总线：

• 总线是连接处理器和设备之间的桥梁
• 代表着同类设备需要共同遵循的工作时序。

总线驱动：

• 负责实现总线行为，管理两个链表。

总线结构体：

struct bus_type {
    const char              *name;
    const struct attribute_group **bus_groups;
    const struct attribute_group **dev_groups;
    const struct attribute_group **drv_groups;

    int (*match)(struct device *dev, struct device_driver *drv);
    int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
    int (*probe)(struct device *dev);
    int (*remove)(struct device *dev);

    int (*suspend)(struct device *dev, pm_message_t state);
    int (*resume)(struct device *dev);

    const struct dev_pm_ops *pm;

    struct subsys_private *p;
};

• name：指定总线的名称，当新注册一种总线类型时，会在 /sys/bus 目录创建一个新的目录，目录名就是该参数的值；
• bus_groups、dev_groups、drv_groups：分别表示 总线、设备、驱动的属性。
  • 通常会在对应的 /sys 目录下在以文件的形式存在，对于驱动而言，在目录 /sys/bus//driver/ 存放了驱动的默认属性；设备则在目录 /sys/bus//devices/ 中。这些文件一般是可读写的，用户可以通过读写操作来获取和设置这些 attribute 的值。
• match：当向总线注册一个新的设备或者是新的驱动时，会调用该回调函数。该设备主要负责匹配工作。
• uevent：总线上的设备发生添加、移除或者其它动作时，就会调用该函数，来通知驱动做出相应的对策。
• probe：当总线将设备以及驱动相匹配之后，执行该回调函数，最终会调用驱动提供的probe 函数。
• remove：当设备从总线移除时，调用该回调函数。
• suspend、resume：电源管理的相关函数，当总线进入睡眠模式时，会调用suspend回调函数；而resume回调函数则是在唤醒总线的状态下执行。
• pm：电源管理的结构体，存放了一系列跟总线电源管理有关的函数，与 device_driver 结构体中的 pm_ops 有关。
• p：该结构体用于存放特定的私有数据，其成员 klist_devices 和 klist_drivers 记录了挂载在该总线的设备和驱动。

6.3.2 注册总线

在实际的驱动开发中，Linux 已经为我们编写好了大部分的总线驱动。
但是内核也提供了注册总线的 API。

bus_register()：

• bus_register() 函数用于注册总线。
• 内核源码路径：内核源码/drivers/base/bus.c。
• 函数原型：int bus_register(struct bus_type *bus);。
  • bus：bus_type 类型的结构体指针。
  • 返回值：
    • 成功：0；
    • 失败：负数。

bus_unregister()：

• bus_unregister() 用于注销总线。
• 内核源码路径：内核源码/drivers/base/bus.c。
• 函数原型：int bus_unregister(struct bus_type *bus);。
  • bus：bus_type 类型的结构体指针。
  • 返回值：无。

当我们成功注册总线时，会在 /sys/bus/ 目录下创建一个新目录，目录名为我们新注册的总线名。

6.4 设备

6.4.1 设备介绍

在 /sys/devices 目录记录了系统中所有的设备。
/sys 下的所有设备文件和 /sys/dev 下的所有设备节点都是链接文件，实际上都指向了对应的设备文件。

device 结构体：

struct device 
{
        const char *init_name;
        struct device           *parent;
        struct bus_type *bus;
        struct device_driver *driver;
        void            *platform_data;
        void            *driver_data;
        struct device_node      *of_node;
        dev_t                   devt;
        struct class            *class;
        void (*release)(struct device *dev);
        const struct attribute_group **groups;  /* optional groups */
        struct device_private   *p;
};

• 内核源码路径：内核源码/include/linux/device.h。
• init_name：指定该设备的名称，总线匹配时，一般会根据比较名字来进行配对。
• parent：表示该设备的父对象，旧版本的设备之间没有任何联系，引入 Linux 设备驱动模块后，设备之间呈现树状结构，便于管理各种设备。
• bus：归属与哪个总线。当我们注册设备时，内核便会将该设备注册到对应的总线。（相爱）
• of_node：存放设备树中匹配的设备节点。当内核使能设备树，总线负责将驱动的 of_match_table 以及设备树的 compatible 属性进行比较之后，将匹配的节点保存到该变量。
• platform_data：特定设备的私有数据，通常定义在板级文件中。
• driver_data：驱动层可以通过 dev_set/get_drvdata 函数来获取该成员变量。
• class：指向该设备对应类。
• dev：设备号。dev_t 类型。
• release：回调函数。当设备被注销时，该函数被调用。
• group：指向 struct attribute_group 类型指针指定该设备属性。

6.4.2 设备注册、注销

在前面的字符设备驱动编写中，我们使用到了 device_create() 函数和 device_destroy() 函数来创建和删除设备。

现在介绍向总线注册和注销设备。
向总线注册设备：

• 函数原型：int device_register(struct device *dev);。
  • 内核源码路径：内核源码/driver/base/core.c。
  • dev：struct device 结构体类型指针。
  • 返回：
    • 成功：0；
    • 失败：负数。

向总线注销设备：

• 函数原型：int device_unregister(struct device *dev);。
  • 内核源码路径：内核源码/driver/base/core.c。
  • dev：struct device 结构体类型指针。
  • 返回：无。

6.5 驱动

6.5.1 驱动介绍

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 */

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

        const struct attribute_group **groups;
        struct driver_private *p;
};

• 内核源码路径：内核源码/include/linux/device.h
• name：指定驱动名称，总线进行匹配时，利用该成员与设备名进行比较。
• bus：归属与哪个总线。内核需要保证在驱动执行之前，对应的总线能够正常工作。
• suppress_bind_attrs：布尔量，用于指定是否通过 sysfs 导出 bind 与 unbind文件，bind 与 unbind 文件是驱动用于绑定/解绑关联的设备。
• owner：表示该驱动的拥有者，一般设置为 THIS_MODULE。
• of_match_table：指定该驱动支持的设备类型。当内核使能设备树时，会利用该成员与设备树中的 compatible 属性进行比较。
• remove：当设备从操作系统中拔出或者是系统重启时，会调用该回调函数。
• probe：当驱动以及设备匹配后，会执行该回调函数，对设备进行初始化。通常的代码，都是以main函数开始执行的，但是在内核的驱动代码，都是从 probe 函数开始的。
• group：指向 struct attribute_group 类型的指针，指定该驱动的属性。

6.4.2 驱动注册、注销

向总线注册驱动：

• 函数原型：int driver_register(struct device_driver *drv);。
  • 内核源码路径：内核源码/include/linux/device.h。
  • drv：struct device_driver 结构体类型指针。
  • 返回：
    • 成功：0；
    • 失败：负数。

向总线注销驱动：

• 函数原型：int driver_unregister(struct device_driver *drv);。
  • 内核源码路径：内核源码/include/linux/device.h。
  • drv：struct device_driver 结构体类型指针。
  • 返回：无。

6.5 便解图文

数据结构该系统：

• 

注册流程图：

• 

• 系统启动之后会调用buses_init函数创建/sys/bus文件目录，这部分系统在开机时已经帮我们准备好了， 接下去就是通过总线注册函数bus_register进行总线注册，注册完总线后在总线的目录下生成devices文件夹和drivers文件夹， 最后分别通过device_register以及driver_register函数注册相对应的设备和驱动。

6.6 attribute属性文件

6.6.1 attribute 介绍

attribute 结构体：

struct attribute {
    const char              *name;
    umode_t                 mode;
};

• 内核源码路径：内核源码/include/linux/sysfs.h
• name：指定文件的文件名。
• mode：指定文件的权限。

bus_type、device、device_driver 结构体中都包含了一种数据类型 struct attribute_group，它是多个 attribute 文件的集合， 利用它进行初始化，可以避免一个个注册 attribute。

struct attribute_group 结构体：

struct attribute_group 
{
    const char              *name;
    umode_t                 (*is_visible)(struct kobject *, struct attribute *, int);
    struct attribute        **attrs;
    struct bin_attribute   **bin_attrs;
};

• 内核源码路径：内核源码/include/linux/sysfs.h

6.6.2 设备属性文件

Linux 提供注册和注销设备属性文件的 API。我们可以通过这些 API 直接在用户层进行查询和修改。

struct device_attribute 结构体：

struct device_attribute 
{
    struct attribute        attr;
    ssize_t (*show)(struct device *dev, struct device_attribute *attr, char *buf);
    ssize_t (*store)(struct device *dev, struct device_attribute *attr, const char *buf, size_t count);
};

#define DEVICE_ATTR(_name, _mode, _show, _store) 
           struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
extern int device_create_file(struct device *device, const struct device_attribute *entry);
extern void device_remove_file(struct device *dev, const struct device_attribute *attr);

• 内核源码路径：内核源码/include/linux/device.h。
• DEVICE_ATTR 宏：用于定义一个device_attribute类型的变量。
  • 参数 _name，_mode，_show，_store，分别代表了文件名， 文件权限，show 回调函数，store 回调函数。
  • show 回调函数以及 store 回调函数分别对应着用户层的 cat 和 echo 命令，当我们使用 cat 命令，来获取 /sys 目录下某个文件时，最终会执行 show 回调函数；使用 echo 命令，则会执行 store 回调函数。 参数 _mode 的值，可以使用S_IRUSR、S_IWUSR、S_IXUSR 等宏定义，更多选项可以查看读写文件章节关于文件权限的内容。
• device_create_file：该函数用于创建文件。
  • device：表示设备。也是归属总线下的 device 目录下的目录名称。
  • entry：自定义的 device_attribute 类型变量。
• device_remove_file：该函数用于删除文件。当注销驱动时，对应目录以及文件都被移除。
  • device：表示设备。也是归属总线下的 device 目录下的目录名称。
  • entry：自定义的 device_attribute 类型变量。

6.6.3 驱动属性文件

Linux 提供注册和注销驱动属性文件的 API。我们可以通过这些 API 直接在用户层进行查询和修改。

struct driver_attribute 结构体：

struct driver_attribute
{
    struct attribute attr;
    ssize_t (*show)(struct device_driver *driver, char *buf);
    ssize_t (*store)(struct device_driver *driver, const char *buf, size_t count);};

#define DRIVER_ATTR_RW(_name) 
           struct driver_attribute driver_attr_##_name = __ATTR_RW(_name)
#define DRIVER_ATTR_RO(_name) 
           struct driver_attribute driver_attr_##_name = __ATTR_RO(_name)
#define DRIVER_ATTR_WO(_name) 
           struct driver_attribute driver_attr_##_name = __ATTR_WO(_name)

extern int __must_check driver_create_file(struct device_driver *driver, const struct driver_attribute *attr);
extern void driver_remove_file(struct device_driver *driver, const struct driver_attribute *attr);

• 内核源码路径：内核源码/include/linux/device.h。
• DRIVER_ATTR_RW、DRIVER_ATTR_RO 以及 DRIVER_ATTR_WO 宏：用于定义一个driver_attribute类型的变量。
  • 带有 driver_attr_ 的前缀，区别在于文件权限不同；
  • RW 后缀表示文件可读写；
  • RO 后缀表示文件仅可读；
  • WO 后缀表示文件仅可写。
  • DRIVER_ATTR 类型的宏定义没有参数来设置 show 和 store 回调函数，在写驱动代码时，只需要提供 xxx_store 以及 xxx_show 这两个函数， 并确保两个函数的 xxx 和 DRIVER_ATTR 类型的宏定义中名字是一致的即可。
• driver_create_file 和 driver_remove_file 函数用于创建和移除文件，使用driver_create_file 函数， 会在 /sys/bus//drivers// 目录下创建文件。

6.6.4 总线属性文件

struct bus_attribute 结构体：

struct bus_attribute 
{
    struct attribute        attr;
    ssize_t (*show)(struct bus_type *bus, char *buf);
    ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
};

#define BUS_ATTR(_name, _mode, _show, _store)       
           struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
           
extern int __must_check bus_create_file(struct bus_type *, struct bus_attribute *);
extern void bus_remove_file(struct bus_type *, struct bus_attribute *);

• 内核源码路径：内核源码/include/linux/device.h。
• BUS_ATTR 宏定义用于定义一个 bus_attribute 变量；
• 使用 bus_create_file 函数，会在 /sys/bus/ 下创建对应的文件。
• bus_remove_file 则用于移除该文件。

6.7 匹配规则 **

下章笔记就是记录平台设备。本次匹配规则就参考 平台设备驱动 源码。

6.7.1 最先比较

最先比较 platform_device.driver_override 和 platform_driver.driver.name。

可以设置 platform_device 的 driver_override，强制选择某个 platform_driver。

6.7.2 其次比较

其次比较 platform_device.name 和 platform_driver.id_table[i].name。

platform_driver.id_table 是 platform_device_id 指针，表示该 drv 支持若干个 device，它里面列出了各个 device 的 {.name, .driver_data}，其中的 name 表示该 drv 支持的设备的名字，driver_data是些提供给该 device 的私有数据。

6.7.3 最后比较

最后比较 platform_device.name 和 platform_driver.driver.name。

由于 platform_driver.id_table 可能为空，所以，接下来就可以使用 platform_driver.driver.name 来匹配。

6.7.4 函数调用关系

platform_device_register
platform_device_add
    device_add
        bus_add_device // 放入链表
        bus_probe_device // probe 枚举设备，即找到匹配的(dev, drv)
            device_initial_probe
                __device_attach
                    bus_for_each_drv(...,__device_attach_driver,...)
                        __device_attach_driver
                            driver_match_device(drv, dev) // 是否匹配
                            driver_probe_device // 调用 drv 的 probe
                            
                            
platform_driver_register
__platform_driver_register
    driver_register
        bus_add_driver // 放入链表
            driver_attach(drv)
                bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
                    __driver_attach
                        driver_match_device(drv, dev) // 是否匹配
                        driver_probe_device // 调用 drv 的 probe

6.8 实现设备模型的简要步骤 *

总线、设备、驱动都基于驱动模型上实现，方便插入。

模块三步骤：

1. 入口函数；
2. 出口函数；
3. 协议。

6.8.1 总线

1. 实现总线结构体内容；
2. 填充总线结构体；
3. 实现属性文件内容，包括设置属性文件结构体；
4. 注册总线；（模块入口函数）
5. 创建属性文件；
6. 移除属性文件；（模块出口函数）
7. 注销总线。

6.8.2 设备

1. 声明外部总线变量；
2. 实现总线设备结构体内容；
3. 填充总线设备结构体；
4. 实现总线设备属性文件内容，包括设置属性文件结构体；
5. 注册总线设备；（模块入口函数）
6. 创建总线设备属性文件；
7. 移除总线设备属性文件；（模块出口函数）
8. 注销总线设备。

6.8.3 驱动

1. 声明外部总线变量；
2. 实现总线驱动结构体内容；
3. 填充总线驱动结构体；
4. 实现总线驱动属性文件内容，包括设置属性文件结构体；
5. 注册总线驱动；（模块入口函数）
6. 创建总线驱动属性文件；
7. 移除总线驱动属性文件；（模块出口函数）
8. 注销总线驱动。

• 注意：总线驱动只是一个框架，类似于模块框架，填空，然后内核帮你操作。具体的设备文件、设备号、设备节点这些还是和以前一样自己实现。

链接

• 李柱明博客：https://www.cnblogs.com/lizhuming/
• 本文链接：https://www.cnblogs.com/lizhuming/p/14596239.html