Linux设备模型(十) - bus/device/device_driver/class

四，驱动的注册

1，struct device_driver结构体

/**
* struct device_driver - The basic device driver structure
* @name:    Name of the device driver.
* @bus:    The bus which the device of this driver belongs to.
* @owner:    The module owner.
* @mod_name:    Used for built-in modules.
* @suppress_bind_attrs: Disables bind/unbind via sysfs.
* @probe_type:    Type of the probe (synchronous or asynchronous) to use.
* @of_match_table: The open firmware table.
* @acpi_match_table: The ACPI match table.
* @probe:    Called to query the existence of a specific device,
*        whether this driver can work with it, and bind the driver
*        to a specific device.
* @sync_state:    Called to sync device state to software state after all the
*        state tracking consumers linked to this device (present at
*        the time of late_initcall) have successfully bound to a
*        driver. If the device has no consumers, this function will
*        be called at late_initcall_sync level. If the device has
*        consumers that are never bound to a driver, this function
*        will never get called until they do.
* @remove:    Called when the device is removed from the system to
*        unbind a device from this driver.
* @shutdown:    Called at shut-down time to quiesce the device.
* @suspend:    Called to put the device to sleep mode. Usually to a
*        low power state.
* @resume:    Called to bring a device from sleep mode.
* @groups:    Default attributes that get created by the driver core
*        automatically.
* @dev_groups:    Additional attributes attached to device instance once the
*        it is bound to the driver.
* @pm:        Power management operations of the device which matched
*        this driver.
* @coredump:    Called when sysfs entry is written to. The device driver
*        is expected to call the dev_coredump API resulting in a
*        uevent.
* @p:        Driver core's private data, no one other than the driver
*        core can touch this.
*
* The device driver-model tracks all of the drivers known to the system.
* The main reason for this tracking is to enable the driver core to match
* up drivers with new devices. Once drivers are known objects within the
* system, however, a number of other things become possible. Device drivers
* can export information and configuration variables that are independent
* of any specific device.
*/
struct device_driver {const char        *name; //该driver的名称struct bus_type        *bus; //该driver所驱动设备的总线struct module        *owner;const char        *mod_name;    /* used for built-in modules */bool suppress_bind_attrs;    /* disables bind/unbind via sysfs */ /* 在kernel中，bind/unbind是从用户空间手动的为driver绑定/解绑定指定的设备的机制 */enum probe_type probe_type;const struct of_device_id    *of_match_table;const struct acpi_device_id    *acpi_match_table;int (*probe) (struct device *dev); /* probe、remove，这两个接口函数用于实现driver逻辑的开始和结束。Driver是一段软件code，因此会有开始和结束两个代码逻辑，就像PC程序，会有一个main函数，main函数的开始就是开始，return的地方就是结束。而内核driver却有其特殊性：在设备模型的结构下，只有driver和device同时存在时，才需要开始执行driver的代码逻辑。这也是probe和remove两个接口名称的由来：检测到了设备和移除了设备（就是为热拔插起的！） */void (*sync_state)(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; /* 默认的attribute，在driver注册到内核时，内核设备模型部分的代码（driver/base/driver.c）会自动将这些attribute添加到sysfs中 */const struct attribute_group **dev_groups;const struct dev_pm_ops *pm;void (*coredump) (struct device *dev);struct driver_private *p; //driver core的私有数据指针，其它模块不能访问ANDROID_KABI_RESERVE(1);ANDROID_KABI_RESERVE(2);ANDROID_KABI_RESERVE(3);ANDROID_KABI_RESERVE(4);
};

driver的私有数据driver_private:

struct driver_private {struct kobject kobj; //该数据结构对应的struct kobject,代表自身struct klist klist_devices; //该driver驱动的所有设备的链表struct klist_node knode_bus; //用来挂接到bus的driver liststruct module_kobject *mkobj;struct device_driver *driver; //回指到本结构体};

2，driver_register()流程

清晰分解图：

  

3，关键代码流程分析

/* driver_register */

int driver_register(struct device_driver *drv)
{int ret;struct device_driver *other;if (!drv->bus->p) {pr_err("Driver '%s' was unable to register with bus_type '%s' because the bus was not initialized.\n",drv->name, drv->bus->name);return -EINVAL; //如果bus未被初始化退出注册driver}if ((drv->bus->probe && drv->probe) ||(drv->bus->remove && drv->remove) ||(drv->bus->shutdown && drv->shutdown)) //driver和bus的同名操作函数如果同时存在，会出现警告，并且会优先选用bus的pr_warn("Driver '%s' needs updating - please use ""bus_type methods\n", drv->name);other = driver_find(drv->name, drv->bus); //进入bus的driver链表，确认该driver是否已经注册if (other) {pr_err("Error: Driver '%s' is already registered, ""aborting...\n", drv->name); //该driver已经被注册，退出return -EBUSY;}ret = bus_add_driver(drv); //如果没有被注册，就把该driver加入所在busif (ret)return ret;ret = driver_add_groups(drv, drv->groups); //创建attribute文件if (ret) {bus_remove_driver(drv);return ret;}kobject_uevent(&drv->p->kobj, KOBJ_ADD); //该driver已被成功注册，发出KOBJ_ADD ueventreturn ret;
}

/* driver_find */

struct device_driver *driver_find(const char *name, struct bus_type *bus)
{struct kobject *k = kset_find_obj(bus->p->drivers_kset, name); /* bus->p->drivers_kset代表bus下的driver目录，此处会遍历kset->list，该list中包含了所有的挂接到该bus上的driver的kobject，然后通过比较driver内嵌的kobj名字，就是通过kset与kobj之间的关系来查找 */struct driver_private *priv;if (k) {/* Drop reference added by kset_find_obj() */kobject_put(k); //减少kobject的引用计数priv = to_driver(k);return priv->driver; //如果找到同名的kobj就返回该driver}return NULL;
}

/* kset_find_obj */

struct kobject *kset_find_obj(struct kset *kset, const char *name)
{struct kobject *k;struct kobject *ret = NULL;spin_lock(&kset->list_lock);list_for_each_entry(k, &kset->list, entry) { //遍历kset->list链表，取出其中的每一个kobjif (kobject_name(k) && !strcmp(kobject_name(k), name)) { //比较取出的kobj的名字跟指定的kobj的名字是否一致ret = kobject_get_unless_zero(k); //找到匹配的kobj把该driver的kobj引用计数+1并返回break;}}spin_unlock(&kset->list_lock);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': add driver %s\n", bus->name, drv->name);priv = kzalloc(sizeof(*priv), GFP_KERNEL); //开始初始化这个driver的私有成员if (!priv) {error = -ENOMEM;goto out_put_bus;}klist_init(&priv->klist_devices, NULL, NULL);priv->driver = drv; //回指到本结构体drv->p = priv; //给driver的私有数据赋值priv->kobj.kset = bus->p->drivers_kset; //本driver的kobject属于bus的drivers_kseterror = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,"%s", drv->name); //初始化driver的kobject并在sysfs中创建目录结构if (error)goto out_unregister;klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers); //将该driver挂接在bus的drivers listif (drv->bus->p->drivers_autoprobe) { error = driver_attach(drv); //如果device与driver自动probe的flag为真，那么到bus的devices上去匹配设备if (error)goto out_del_list;}module_add_driver(drv->owner, drv);error = driver_create_file(drv, &driver_attr_uevent); //创建uevent attribute, /sys/bus/platform/drivers/gpio-keys/ueventif (error) {printk(KERN_ERR "%s: uevent attr (%s) failed\n",__func__, drv->name);}error = driver_add_groups(drv, bus->drv_groups); //创建默认的drv_groups attributesif (error) {/* How the hell do we get out of this pickle? Give up */printk(KERN_ERR "%s: driver_create_groups(%s) failed\n",__func__, drv->name);}if (!drv->suppress_bind_attrs) {error = add_bind_files(drv); /* 创建手动device与driver的bind/unbind的文件节点, /sys/bus/platform/drivers/gpio-keys/bind， /sys/bus/platform/drivers/gpio-keys/unbind */if (error) {/* Ditto */printk(KERN_ERR "%s: add_bind_files(%s) failed\n",__func__, drv->name);}}return 0;out_del_list:klist_del(&priv->knode_bus);
out_unregister:kobject_put(&priv->kobj);/* drv->p is freed in driver_release()  */drv->p = NULL;
out_put_bus:bus_put(bus);return error;
}

/* driver_attach */

int driver_attach(struct device_driver *drv)
{return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); /* 遍历bus的设备链表找到合适的设备就调用__driver_attach，NULL表示从头开始遍历 */
}

/* bus_for_each_dev */

int bus_for_each_dev(struct bus_type *bus, struct device *start,void *data, int (*fn)(struct device *, void *))
{struct klist_iter i;struct device *dev;int error = 0;if (!bus || !bus->p)return -EINVAL;klist_iter_init_node(&bus->p->klist_devices, &i,(start ? &start->p->knode_bus : NULL)); //进入bus的devices链表while (!error && (dev = next_device(&i))) //设备存在则调用fn即__driver_attach进行匹配error = fn(dev, data);klist_iter_exit(&i);return error;
}

/* __driver_attach */

static int __driver_attach(struct device *dev, void *data)
{struct device_driver *drv = data;bool async = false;int ret;/** Lock device and try to bind to it. We drop the error* here and always return 0, because we need to keep trying* to bind to devices and some drivers will return an error* simply if it didn't support the device.** driver_probe_device() will spit a warning if there* is an error.*/ret = driver_match_device(drv, dev); /* bus的match存在就用bus的，否则就直接匹配成功,match通常实现为首先扫描driver支持的id设备表，如果为NULL就用名字进行匹配 */if (ret == 0) {/* no match */return 0;} else if (ret == -EPROBE_DEFER) {dev_dbg(dev, "Device match requests probe deferral\n");driver_deferred_probe_add(dev);/** Driver could not match with device, but may match with* another device on the bus.*/return 0;} else if (ret < 0) {dev_dbg(dev, "Bus failed to match device: %d\n", ret);return ret;} /* ret > 0 means positive match */if (driver_allows_async_probing(drv)) {/** Instead of probing the device synchronously we will* probe it asynchronously to allow for more parallelism.** We only take the device lock here in order to guarantee* that the dev->driver and async_driver fields are protected*/dev_dbg(dev, "probing driver %s asynchronously\n", drv->name);device_lock(dev);if (!dev->driver) {get_device(dev);dev->p->async_driver = drv;async = true;}device_unlock(dev);if (async)async_schedule_dev(__driver_attach_async_helper, dev);return 0;}device_driver_attach(drv, dev); //匹配成功，将driver与device绑定return 0;
}

/* device_driver_attach */

int device_driver_attach(struct device_driver *drv, struct device *dev)
{int ret = 0;__device_driver_lock(dev, dev->parent);/** If device has been removed or someone has already successfully* bound a driver before us just skip the driver probe call.*/if (!dev->p->dead && !dev->driver)ret = driver_probe_device(drv, dev); //driver与device绑定操作跟之前device注册流程中的一致，后面不再分析__device_driver_unlock(dev, dev->parent);return ret;
}

总结一下，driver的注册，主要涉及将自身挂接到bus的driver链表，并将匹配到的设备加入自己的device链表，并且将匹配到的 device的driver成员初始化为该driver，私有属性的driver节点也挂到driver的设备链表下，其中匹配函数是利用利用bus的 match函数，该函数通常判断如果driver有id表，就查表匹配，如果没有就用driver和device名字匹配。bus的probe优先级始终高于driver的。另外注意一点driver是没有总的起始端点的，driver不是 可具体描述的事物。

五，class

1，class概述

在设备模型中，Bus、Device、Device driver等等，都比较好理解，因为它们对应了实实在在的东西，所有的逻辑都是围绕着这些实体展开的。而本文所要描述的Class就有些不同了，因为它是虚拟出来的，只是为了抽象设备的共性。

举个例子，一些年龄相仿、需要获取的知识相似的人，聚在一起学习，就构成了一个班级（Class）。这个班级可以有自己的名称（如295），但如果离开构成它的学生（device），它就没有任何存在意义。另外，班级存在的最大意义是什么呢？是由老师讲授的每一个课程！因为老师只需要讲一遍，一个班的学生都可以听到。不然的话（例如每个学生都在家学习），就要为每人请一个老师，讲授一遍。而讲的内容，大多是一样的，这就是极大的浪费。

设备模型中的Class所提供的功能也一样了，例如一些相似的device（学生），需要向用户空间提供相似的接口（课程），如果每个设备的驱动都实现一遍的话，就会导致内核有大量的冗余代码，这就是极大的浪费。所以，Class说了，我帮你们实现吧，你们会用就行了。

2，struct class结构体

msm_kernel\include\linux\device\class.h
/**
* struct class - device classes
* @name:    Name of the class.
* @owner:    The module owner.
* @class_groups: Default attributes of this class.
* @dev_groups:    Default attributes of the devices that belong to the class.
* @dev_kobj:    The kobject that represents this class and links it into the hierarchy.
* @dev_uevent:    Called when a device is added, removed from this class, or a
*        few other things that generate uevents to add the environment
*        variables.
* @devnode:    Callback to provide the devtmpfs.
* @class_release: Called to release this class.
* @dev_release: Called to release the device.
* @shutdown_pre: Called at shut-down time before driver shutdown.
* @ns_type:    Callbacks so sysfs can detemine namespaces.
* @namespace:    Namespace of the device belongs to this class.
* @get_ownership: Allows class to specify uid/gid of the sysfs directories
*        for the devices belonging to the class. Usually tied to
*        device's namespace.
* @pm:        The default device power management operations of this class.
* @p:        The private data of the driver core, no one other than the
*        driver core can touch this.
*
* A class is a higher-level view of a device that abstracts out low-level
* implementation details. Drivers may see a SCSI disk or an ATA disk, but,
* at the class level, they are all simply disks. Classes allow user space
* to work with devices based on what they do, rather than how they are
* connected or how they work.
*/
struct class {const char        *name; //class的名称，会在“/sys/class/”目录下体现struct module        *owner; //class所属的模块，虽然class是涉及一类设备，但也是由相应的模块注册的。比如usb类就是由usb模块注册的const struct attribute_group    **class_groups; /* 该class的默认attribute，会在class注册到内核时，自动在“/sys/class/xxx_class”下创建对应的attribute文件 */const struct attribute_group    **dev_groups; /* 该class下每个设备的attribute，会在设备注册到内核时，自动在该设备的sysfs目录下创建对应的attribute文件 */struct kobject            *dev_kobj; /* 表示该class下的设备在/sys/dev/下的目录，现在一般有char和block两个，如果dev_kobj为NULL，则默认选择char */int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env); /* 当该class下有设备发生变化时，会调用class的uevent回调函数 */char *(*devnode)(struct device *dev, umode_t *mode);void (*class_release)(struct class *class); //用于release自身的回调函数void (*dev_release)(struct device *dev); /* 用于release class内设备的回调函数。在device_release接口中，会依次检查Device、Device Type以及Device所在的class，是否注册release接口，如果有则调用相应的release接口release设备指针 */int (*shutdown_pre)(struct device *dev);const struct kobj_ns_type_operations *ns_type;const void *(*namespace)(struct device *dev);void (*get_ownership)(struct device *dev, kuid_t *uid, kgid_t *gid);const struct dev_pm_ops *pm;struct subsys_private *p; //私有数据,和struct bus_type中的subsys_private一致ANDROID_KABI_RESERVE(1);ANDROID_KABI_RESERVE(2);ANDROID_KABI_RESERVE(3);ANDROID_KABI_RESERVE(4);
};

struct class_interface：

struct class_interface是这样的一个结构：它允许class driver在class下有设备添加或移除的时候，调用预先设置好的回调函数（add_dev和remove_dev）。那调用它们做什么呢？想做什么都行（例如修改设备的名称），由具体的class driver实现。

该结构的定义如下：

struct class_interface {struct list_head    node;struct class        *class;int (*add_dev)        (struct device *, struct class_interface *);void (*remove_dev)    (struct device *, struct class_interface *);
};

3，class创建流程

4，device注册时，和class有关的动作

4.1 调用device_add_class_symlinks接口，创建device与class之间的各种符号链接

static int device_add_class_symlinks(struct device *dev)
{struct device_node *of_node = dev_of_node(dev);int error;if (of_node) {error = sysfs_create_link(&dev->kobj, of_node_kobj(of_node), "of_node");if (error)dev_warn(dev, "Error %d creating of_node link\n",error);/* An error here doesn't warrant bringing down the device */}if (!dev->class)return 0;error = sysfs_create_link(&dev->kobj,&dev->class->p->subsys.kobj,"subsystem"); /* 在该设备所在的sysfs目录创建到该设备所在的class目录的链接，链接名字为subsystem eg: /sys/devices/platform/soc/994000.qcom,qup_uart/tty/ttyMSM0/sussystem -> ../../../../../../class/tty ; /sys/devices/platform/soc/99c000.qcom,qup_uart/tty/ttyHS0/subsystem -> ../../../../../../class/tty */if (error)goto out_devnode;if (dev->parent && device_is_not_partition(dev)) {error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,"device");if (error)goto out_subsys;}#ifdef CONFIG_BLOCK/* /sys/block has directories and does not need symlinks */if (sysfs_deprecated && dev->class == &block_class)return 0;
#endif/* link in the class directory pointing to the device */error = sysfs_create_link(&dev->class->p->subsys.kobj,&dev->kobj, dev_name(dev)); /* 在该设备所在的class目录创建到该设备所在目录的链接，链接名字为设备的名字，eg: /sys/class/tty/ttyMSM0 -> ../../devices/platform/soc/994000.qcom,qup_uart/tty/ttyMSM0 ; /sys/class/tty/ttyHS0 -> ../../devices/platform/soc/99c000.qcom,qup_uart/tty/ttyHS0 */if (error)goto out_device;return 0;out_device:sysfs_remove_link(&dev->kobj, "device");out_subsys:sysfs_remove_link(&dev->kobj, "subsystem");
out_devnode:sysfs_remove_link(&dev->kobj, "of_node");return error;
}

4.2 调用device_add_attrs，添加由class指定的attributes（class->dev_attrs）

static int device_add_attrs(struct device *dev)
->struct class *class = dev->class;if (class) {error = device_add_groups(dev, class->dev_groups);if (error)return error;}

4.3 如果存在对应该class的add_dev回调函数，调用该回调函数

    struct class_interface *class_intf;if (dev->class) {mutex_lock(&dev->class->p->mutex);/* tie the class to the device */klist_add_tail(&dev->p->knode_class,&dev->class->p->klist_devices);/* notify any interfaces that the device is here */list_for_each_entry(class_intf,&dev->class->p->interfaces, node)if (class_intf->add_dev)class_intf->add_dev(dev, class_intf);mutex_unlock(&dev->class->p->mutex);}

5，应用示例

5.1 使用class_create()创建一个class，并在class中创建一个设备

struct class *sec_class;
struct device *factory_ts_dev;sec_class = class_create(THIS_MODULE, "tsp");factory_ts_dev = device_create(sec_class, NULL, 0, info, "tsp");
if (unlikely(!factory_ts_dev)) {dev_err(&info->client->dev, "Failed to create factory dev\n");ret = -ENODEV;goto err_create_device;
}ret = sysfs_create_group(&factory_ts_dev->kobj, &ts_attr_group);
if (unlikely(ret)) {dev_err(&info->client->dev, "Failed to create ts sysfs group\n");goto err_create_sysfs;
}

5.2 使用device_register()在已存在的class目录创建一个设备

info->dev.class = sec_class;
info->dev.parent = &info->client->dev;
info->dev.release = bt541_registered_release;dev_set_name(&info->dev, "tsp_%d", 1);
dev_set_drvdata(&info->dev, info);ret = device_register(&info->dev);
if (ret) {dev_err(&info->client->dev,"%s: Failed to register device\n",__func__);
}ret = device_create_bin_file(&info->dev, &attr_data);
if (ret < 0) {dev_err(&info->client->dev,"%s: Failed to create sysfs bin file\n",__func__);
}

show result info:

lynkco:/sys/class/tsp # ls -l //链接到实际的device

total 0

lrwxrwxrwx 1 root root 0 2023-09-11 15:00 tsp -> ../../devices/virtual/tsp/tsp

lrwxrwxrwx 1 root root 0 2023-09-11 15:00 tsp_1 -> ../../devices/platform/soc/984000.i2c/i2c-2/2-0020/tsp/tsp_1

lynkco:/sys/class/tsp/tsp # ls -l

total 0

-rw-rw-r-- 1 root        root   4096 2023-09-11 15:40 bigobject_off

--w--w---- 1 vendor_tcmd system 4096 2023-09-11 13:09 cmd

-r--r----- 1 vendor_tcmd system 4096 2023-09-11 13:09 cmd_result

-r--r--r-- 1 root        root   4096 2023-09-11 15:40 cmd_status

-rw-rw-r-- 1 root        root   4096 2023-09-11 15:40 easy_wakeup_gesture

lrwxrwxrwx 1 root        root      0 2023-09-11 15:40 input -> ../../../platform/soc/984000.i2c/i2c-2/2-0020/input/input12

drwxr-xr-x 2 root        root      0 2023-09-11 15:40 power

-r--r----- 1 vendor_tcmd system 4096 2023-09-11 13:09 raw_data

-r--r----- 1 vendor_tcmd system 4096 2023-09-11 13:09 short_data

lrwxrwxrwx 1 root        root      0 2023-09-11 15:40 subsystem -> ../../../../class/tsp

-rw-r--r-- 1 root        root   4096 2023-09-11 15:40 uevent

 

 

lynkco:/sys/class/tsp/tsp_1 # ls -l

total 0

-rw-rw-r-- 1 root root    0 2023-09-11 15:40 data

lrwxrwxrwx 1 root root    0 2023-09-11 15:40 device -> ../../../2-0020

drwxr-xr-x 2 root root    0 2023-09-11 15:40 power

lrwxrwxrwx 1 root root    0 2023-09-11 15:40 subsystem -> ../../../../../../../../class/tsp

-rw-r--r-- 1 root root 4096 2023-09-11 15:40 uevent

 

六，通过实例来看bus/device/device_driver/class在sysfs中的关系

1，device，/sys/devices/platform/soc/soc:gpio_keys

虚线表示软连接。

2，device，/sys/devices/platform/soc/994000.qcom,qup_uart

device，/sys/devices/platform/soc/99c000.qcom,qup_uart

参考链接：

Linux设备模型(5)_device和device driver

【Linux内核|驱动模型】bus/class/device/driver - 知乎

Linux的设备驱动模型 - 知乎

https://www.cnblogs.com/bcfx/articles/2915120.html