总线设备驱动模型——驱动篇

本文详细解析了Linux中驱动的注册流程与设备匹配机制,包括关键数据结构如struct device_driver和struct driver_private,以及核心函数driver_register()和driver_match_device()的作用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

驱动struct device_driver

struct device_driver {

    const char        *name;                 //驱动的名字

    struct bus_type        *bus;             //驱动呈现属于的总线类型

 

    struct module        *owner;

    const char        *mod_name;   /* usedfor built-in modules */

 

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

 

    const struct of_device_id    *of_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;

};

struct driver_private

    与device类型相似,其中有一个指向driver_private的指针p,一些与其他的组件相关的联系都被移到这个结构变量中。由driver_private可以看出driver指针最后也由driver_private回到了device_driver之中。

struct driver_private {

    struct kobject kobj;           //sysfs中代表目录本身

    struct klist klist_devices;      //驱动链表

    struct klist_node knode_bus; //挂载在总线的驱动链表的节点

    struct module_kobject *mkobj;    //driver与相关的module之间的联系

    struct device_driver *driver;

};

#define to_driver(obj) container_of(obj,struct driver_private, kobj)

驱动属性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(_name, _mode, _show, _store)    \

struct driver_attribute driver_attr_##_name =        \

    __ATTR(_name, _mode, _show, _store)

驱动注册driver_register()

    看完了关于驱动的一些重要的数据结构,那么如何向内核注册一个drv呢?使用driver_register,首先drv->bus一定要预先设置,再使用driver_find从bus的驱动链表中特定名字的driver,然后就进入这个函数的重点bus_add_driver,几乎注册所有的工作都是由它来完成。

int driver_register(struct device_driver *drv)

{

    int ret;

    struct device_driver *other;

 

    BUG_ON(!drv->bus->p);

 

    if ((drv->bus->probe && drv->probe) ||

     (drv->bus->remove && drv->remove) ||

     (drv->bus->shutdown && drv->shutdown))

        printk(KERN_WARNING "Driver '%s'needs updating - please use "

            "bus_type methods\n", drv->name);

 

    other = driver_find(drv->name, drv->bus);

    if (other) {

        put_driver(other);

        printk(KERN_ERR "Error: Driver'%s' is already registered, "

            "aborting...\n", drv->name);

        return -EBUSY;

    }

 

    ret = bus_add_driver(drv);

    if (ret)

        return ret;

    ret = driver_add_groups(drv, drv->groups);

    if (ret)

        bus_remove_driver(drv);

    return ret;

}

    几乎注册所有的工作都是由bus_add_driver来完成。

int bus_add_driver(struct device_driver *drv)

{

    struct bus_type *bus;

    struct driver_private *priv;

    int error = 0;

 

    bus = bus_get(drv->bus);                 //增加对bus的引用

    if (!bus)

        return -EINVAL;

 

    pr_debug("bus: '%s': adddriver %s\n", bus->name, drv->name);

 

    priv = kzalloc(sizeof(*priv), GFP_KERNEL);//分配初始化一个drv->p,也就是上面的driver_private结构

    if (!priv) {

        error = -ENOMEM;

        goto out_put_bus;

    }

    klist_init(&priv->klist_devices, NULL, NULL);

    priv->driver = drv;

    drv->p = priv;

    priv->kobj.kset = bus->p->drivers_kset;

    error =kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,

                 "%s", drv->name);              //drv加入sysfs

    if (error)

        goto out_unregister;

 

    if (drv->bus->p->drivers_autoprobe) {

        error = driver_attach(drv);           //如果总线可以自动probe,就会调用匹配函数

        if (error)

            goto out_unregister;

    }

    klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);//drv挂入到总线的链表中

    module_add_driver(drv->owner, drv);      //创建driver相关的模块

 

    error = driver_create_file(drv, &driver_attr_uevent);//drv目录下创建event属性文件

    if (error) {

        printk(KERN_ERR "%s: ueventattr (%s) failed\n",

            __func__, drv->name);

    }

    error = driver_add_attrs(bus, drv);          //添加属性

    if (error) {

        /* How the hell do we get out of thispickle? Give up */

        printk(KERN_ERR "%s:driver_add_attrs(%s) failed\n",

            __func__, drv->name);

    }

 

    if (!drv->suppress_bind_attrs) {

        error = add_bind_files(drv);

        if (error) {

            /* Ditto */

            printk(KERN_ERR "%s:add_bind_files(%s) failed\n",

                __func__, drv->name);

        }

    }

 

    kobject_uevent(&priv->kobj, KOBJ_ADD);//向用户空间发布kobj_add消息

    return 0;

 

out_unregister:

    kobject_put(&priv->kobj);

    kfree(drv->p);

    drv->p = NULL;

out_put_bus:

    bus_put(bus);

    return error;

}

    其实上面的处理过程相对于设备来说简单很多,下面主要对当驱动挂接的时候,怎么去匹配进行分析。

int driver_attach(struct device_driver *drv)

{

    return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);

}

 

static int __driver_attach(struct device *dev, void *data)

{

    struct device_driver *drv = data;

 

    /*

     * Lock device and try to bindto it. We drop the error

     * here and always return 0,because we need to keep trying

     * to bind to devices and somedrivers will return an error

     * simply if it didn't supportthe device.

     *

     * driver_probe_device() willspit a warning if there

     * is an error.

     */

 

    if (!driver_match_device(drv, dev))

        return 0;

 

   if (dev->parent)    /* Needed for USB */

        device_lock(dev->parent);

    device_lock(dev);

    if (!dev->driver)

        driver_probe_device(drv, dev);

    device_unlock(dev);

    if (dev->parent)

        device_unlock(dev->parent);

 

   return 0;

}

    最终也是调用总线的match函数来完成设备与驱动的匹配的过程。

static inline int driver_match_device(struct device_driver *drv,

                 struct device *dev)

{

    return drv->bus->match ? drv->bus->match(dev, drv) : 1;

}

module_init(my_driver_init)

extern struct bus_type my_bus_type;

 

static int my_probe(struct device *dev)

{

    printk("Driver founddevice which my driver can handle!\n");

    return 0;

}

 

static int my_remove(struct device *dev)

{

    printk("Driver founddevice unpluged!\n");

    return 0;

}

 

struct device_drivermy_driver = {

    .name = "my_dev",

    .bus = &my_bus_type,

    .probe = my_probe,

        .remove    = my_remove,

};

 

/*

 * Export a simple attribute.

 */

static ssize_tmydriver_show(struct device_driver *driver, char *buf)

{

    return sprintf(buf, "%s\n", "This is mydriver!");

}

 

static DRIVER_ATTR(drv, S_IRUGO, mydriver_show, NULL);

 

static int __initmy_driver_init(void)

{

    int ret = 0;

       

        /*注册驱动*/

    driver_register(&my_driver);

       

    /*创建属性文件*/

    driver_create_file(&my_driver, &driver_attr_drv);

   

    return ret;   

 

}

 

static void my_driver_exit(void)

{

    driver_unregister(&my_driver);

}

 

module_init(my_driver_init);

module_exit(my_driver_exit);

### RT-Thread 操作系统中的驱动总线设备模型 #### 设备管理框架概述 RT-Thread 的设备管理框架设计旨在提供统一的接口来管理和操作硬件资源。该框架不仅简化了不同平台上的移植过程,还提高了代码重用率和可维护性[^1]。 #### 总线概念及其作用 在 RT-Thread 中,“总线”被定义为连接多个相同类型的物理或逻辑组件之间的通信路径。通过引入总线的概念,可以更方便地处理那些具有相似特性的外围模块集合。例如 USB、I2C 或 SPI 接口都可以视为特定种类的总线,在这些总线上挂载着各种功能各异却遵循同一协议标准工作的子节点——即所谓的“设备”。 #### 设备类与实例化机制 针对每一个具体的外设单元(如传感器、存储卡),都会创建对应的软件表示形式—称为 “device”。Device 类型包含了描述此实体所需的一切必要信息:名称、状态标志位以及一组用于执行实际 I/O 操作的方法集等。当应用程序请求访问某个外部装置时,它实际上是在调用关联 device 对象所提供的 API 函数来进行交互;而这些函数内部会进一步封装底层寄存器级别的细节,从而使得上层开发者无需关心具体硬件层面的知识即可完成复杂任务。 #### 动态加载特性支持 值得一提的是,得益于灵活的设计理念,RT-Thread 支持动态注册新的 bus 和 device 。这意味着即使在系统运行期间也可以安全地添加新发现或者刚插入系统的硬件设施到当前环境中去,并立即生效投入使用。这种能力极大地增强了整个生态系统的适应性和灵活性[^2]。 ```c // 示例代码展示如何初始化一个名为 "my_device" 的设备并将其附加到指定总线上 #include <rtthread.h> #include <rtdevice.h> static struct rt_device my_device; int main(void) { /* 初始化设备 */ rt_hw_device_init(&my_device); /* 将设备绑定至某条已存在的总线下 */ rt_bus_attach_device("i2c_bus", &my_device); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值