前面我们已经注册了自己的总线，并可以在总线上注册设备和驱动，那么两者怎么匹配？若笔记中有错误或者不合适的地方，欢迎批评指正😃。
点击查看使用工具及版本
PC端开发环境 Windows Windows11 Ubuntu Ubuntu20.04.2的64位版本 VMware® Workstation 17 Pro 17.6.0 build-24238078 终端软件 MobaXterm(Professional Edition v23.0 Build 5042 (license)) Win32DiskImager Win32DiskImager v1.0 Linux开发板环境 Linux开发板 正点原子 i.MX6ULL Linux 阿尔法开发板 uboot NXP官方提供的uboot，使用的uboot版本为U-Boot 2019.04 linux内核 linux-4.19.71(NXP官方提供)
点击查看本文参考资料
点击查看相关文件下载
一、设备和驱动匹配 1. 总线 1.1 xxx_match() 总线中，我们需要实现xxx_match()函数：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 static int sbus_match (struct device *dev, struct device_driver *drv) { const char *device_name = dev_name(dev); int len = strlen (drv->name); PRT("dev name is %s, drv name is %s, name len = %d\n" , device_name, drv->name, len); if (!strncmp (device_name, drv->name, len)) { PRT("dev is %s <---> drv is %s, match success!\n" , drv->name, device_name); return 1 ; } return 0 ; }
我们在这里比较两个驱动的名称和设备的名称，若是一样，就表示匹配成功，需要返回1，若是不同，就是没有匹配上，就返回0。那能反过来吗？比如匹配成功返回0，匹配失败返回1？这样不行，应该是调用的时候判断条件进行了限制。
1.2 xxx_probe() 在总线中还需要实现一个xxx_probe()函数：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 static int sbus_probe (struct device *dev) { struct device_driver *drv = const char *device_name = dev_name(dev); PRT("device_name=%s driver_name=%s\n" , device_name, drv->name); if (drv->probe) { drv->probe(dev); } return 0 ; }
1.3 sbus_demo.c 完整源码如下所示：
点击查看详情
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 #include <linux/init.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/kobject.h> #include <linux/slab.h> #include <linux/device.h> #include "./timestamp_autogenerated.h" #include "./version_autogenerated.h" #include "./sdrv_common.h" #ifndef PRT #define PRT printk #endif #ifndef PRTE #define PRTE printk #endif #define SBUS_NAME "sbus" typedef struct __SBUS_ATTR_VAR_ { char name_attr[32 ]; int data; }sbus_attr_var_t ; sbus_attr_var_t sbus_attr = {0 }; static int sbus_match (struct device *dev, struct device_driver *drv) { const char *device_name = dev_name(dev); int len = strlen (drv->name); PRT("dev name is %s, drv name is %s, name len = %d\n" , device_name, drv->name, len); if (!strncmp (device_name, drv->name, len)) { PRT("dev is %s <---> drv is %s, match success!\n" , drv->name, device_name); return 1 ; } return 0 ; } static int sbus_probe (struct device *dev) { struct device_driver *drv = const char *device_name = dev_name(dev); PRT("device_name=%s driver_name=%s\n" , device_name, drv->name); if (drv->probe) { drv->probe(dev); } return 0 ; } static struct bus_type g_sbus = .name = SBUS_NAME, .match = sbus_match, .probe = sbus_probe, }; EXPORT_SYMBOL_GPL(g_sbus); static ssize_t sbus_attr_name_show (struct bus_type *bus, char *buf) { ssize_t count = 0 ; count = sprintf (buf, "%s\n" , sbus_attr.name_attr); PRT("bus->name=%s count=%d\n" , bus->name, count); return count; } static ssize_t sbus_attr_name_store (struct bus_type *bus, const char *buf, size_t count) { PRT("bus->name=%s count=%d\n" , bus->name, count); sscanf (buf, "%s\n" , sbus_attr.name_attr); return count; } struct bus_attribute sbus_attr_name_var = .attr = { .name = "sbus_attr_name" , .mode = 0664 , }, .show = sbus_attr_name_show, .store = sbus_attr_name_store, }; static ssize_t sbus_attr_data_show (struct bus_type *bus, char *buf) { ssize_t count = 0 ; count = sprintf (buf, "%d\n" , sbus_attr.data); PRT("bus->name=%s count=%d\n" , bus->name, count); return count; } static ssize_t sbus_attr_data_store (struct bus_type *bus, const char *buf, size_t count) { PRT("bus->name=%s count=%d\n" , bus->name, count); sscanf (buf, "%d\n" , &sbus_attr.data); return count; } BUS_ATTR(sbus_attr_data, 0664 , sbus_attr_data_show, sbus_attr_data_store); static __init int sbus_demo_init (void ) { int ret = 0 ; printk("*** [%s:%d]Build Time: %s %s, git version:%s ***\n" , __FUNCTION__, __LINE__, KERNEL_KO_DATE, KERNEL_KO_TIME, KERNEL_KO_VERSION); PRT("sbus_demo module init!\n" ); ret = bus_register(&g_sbus); if (ret < 0 ) { PRTE("bus_register fail!\n" ); goto err_bus_register; } snprintf (sbus_attr.name_attr, sizeof (sbus_attr.name_attr), SBUS_NAME); sbus_attr.data = 1 ; ret = bus_create_file(&g_sbus, &sbus_attr_name_var); if (ret < 0 ) { PRTE("bus_create_file sbus_attr_name_var fail!ret=%d\n" , ret); goto err_bus_create_file1; } ret = bus_create_file(&g_sbus, &bus_attr_sbus_attr_data); if (ret < 0 ) { PRTE("bus_create_file bus_attr_sbus_attr_data fail!ret=%d\n" , ret); goto err_bus_create_file2; } return 0 ; err_bus_create_file2: bus_remove_file(&g_sbus, &sbus_attr_name_var); err_bus_create_file1: bus_unregister(&g_sbus); err_bus_register: return ret; } static __exit void sbus_demo_exit (void ) { bus_remove_file(&g_sbus, &bus_attr_sbus_attr_data); bus_remove_file(&g_sbus, &sbus_attr_name_var); bus_unregister(&g_sbus); PRT("sbus_demo module exit!\n" ); } module_init(sbus_demo_init); module_exit(sbus_demo_exit); MODULE_LICENSE("GPL v2" ); MODULE_AUTHOR("sumu" ); MODULE_DESCRIPTION("Description" ); MODULE_ALIAS("module's other name" );
2. 设备 2.1 设备名称 主要是要定义好设备名称：
1 #define SDEV_NAME "sumu-dev"
2.2 xxx_release() 可以在这里实现一个释放函数：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 void sdev_release (struct device *dev) { int len = 0 ; const char *device_name = dev_name(dev); len = strlen (device_name); PRT("dev name is %s, len = %d\n" , device_name, len); }
2.3 sdevice_demo.c 完整源码如下所示：
点击查看详情
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 #include <linux/init.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/device.h> #include "./timestamp_autogenerated.h" #include "./version_autogenerated.h" #include "./sdrv_common.h" #ifndef PRT #define PRT printk #endif #ifndef PRTE #define PRTE printk #endif #define SDEV_NAME "sumu-dev" extern struct bus_type g_sbus ;typedef struct __SDEV_ATTR_VAR_ { char name_attr[32 ]; int data; }sdev_attr_var_t ; sdev_attr_var_t sdev_attr = {0 }; void sdev_release (struct device *dev) { int len = 0 ; const char *device_name = dev_name(dev); len = strlen (device_name); PRT("dev name is %s, len = %d\n" , device_name, len); } static struct device sdev = .init_name = SDEV_NAME, .bus = &g_sbus, .release = sdev_release, }; static ssize_t sdev_attr_name_show (struct device *dev, struct device_attribute *attr, char *buf) { ssize_t count = 0 ; count = sprintf (buf, "%s\n" , sdev_attr.name_attr); PRT("attr->name=%s count=%d\n" , attr->attr.name, count); return count; } static ssize_t sdev_attr_name_store (struct device * dev, struct device_attribute * attr, const char *buf, size_t count) { PRT("attr->name=%s count=%d\n" , attr->attr.name, count); sscanf (buf, "%s\n" , sdev_attr.name_attr); return count; } struct device_attribute sdev_attr_name_var = .attr = { .name = "sdev_attr_name" , .mode = 0664 , }, .show = sdev_attr_name_show, .store = sdev_attr_name_store, }; static ssize_t sdev_attr_data_show (struct device *dev, struct device_attribute *attr, char *buf) { ssize_t count = 0 ; count = sprintf (buf, "%d\n" , sdev_attr.data); PRT("attr->name=%s count=%d\n" , attr->attr.name, count); return count; } static ssize_t sdev_attr_data_store (struct device * dev, struct device_attribute * attr, const char *buf, size_t count) { PRT("attr->name=%s count=%d\n" , attr->attr.name, count); sscanf (buf, "%d\n" , &sdev_attr.data); return count; } DEVICE_ATTR(sdev_attr_data, 0664 , sdev_attr_data_show, sdev_attr_data_store); static __init int sdev_demo_init (void ) { int ret = 0 ; printk("*** [%s:%d]Build Time: %s %s, git version:%s ***\n" , __FUNCTION__, __LINE__, KERNEL_KO_DATE, KERNEL_KO_TIME, KERNEL_KO_VERSION); PRT("sdev_demo module init!\n" ); ret = device_register(&sdev); if (ret < 0 ) { PRTE("device_register fail! ret = %d\n" , ret); goto err_device_register; } snprintf (sdev_attr.name_attr, sizeof (sdev_attr.name_attr), SDEV_NAME); sdev_attr.data = 1 ; ret = device_create_file(&sdev, &sdev_attr_name_var); if (ret < 0 ) { PRTE("device_create_file sdev_attr_name_var fail!ret=%d\n" , ret); goto err_device_create_file1; } ret = device_create_file(&sdev, &dev_attr_sdev_attr_data); if (ret < 0 ) { PRTE("device_create_file dev_attr_sdev_attr_data fail!ret=%d\n" , ret); goto err_device_create_file2; } return 0 ; err_device_create_file2: device_remove_file(&sdev, &sdev_attr_name_var); err_device_create_file1: device_unregister(&sdev); err_device_register: return ret; } static __exit void sdev_demo_exit (void ) { device_remove_file(&sdev, &dev_attr_sdev_attr_data); device_remove_file(&sdev, &sdev_attr_name_var); device_unregister(&sdev); PRT("sdev_demo module exit!\n" ); } module_init(sdev_demo_init); module_exit(sdev_demo_exit); MODULE_LICENSE("GPL v2" ); MODULE_AUTHOR("sumu" ); MODULE_DESCRIPTION("Description" ); MODULE_ALIAS("module's other name" );
3. 驱动 3.1 驱动名称 需要注意的是，驱动的名称要和设备名称一致，这样我们才能在对应的总线中通过xxx_match()函数，实现驱动和设备的匹配：
1 #define SDRV_MATCH_NAME "sumu-dev"
3.2 xxx_probe() 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 static int sdrv_probe (struct device *dev) { int len = 0 ; const char *device_name = dev_name(dev); len = strlen (device_name); PRT("dev name is %s, len = %d\n" , device_name, len); return 0 ; }
其实驱动自己的探测函数实现之后，在加载的时候反而会有一个警告，后面再分析。
3.3 xxx_remove() 可以再实现一个remove函数，用于清理资源：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 static int sdrv_remove (struct device *dev) { int len = 0 ; const char *device_name = dev_name(dev); len = strlen (device_name); PRT("dev name is %s, len = %d\n" , device_name, len); return 0 ; }
3.4 sdriver_demo.c 完整源码如下：
点击查看详情
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 #include <linux/init.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/device.h> #include "./timestamp_autogenerated.h" #include "./version_autogenerated.h" #include "./sdrv_common.h" #ifndef PRT #define PRT printk #endif #ifndef PRTE #define PRTE printk #endif #define SDRV_MATCH_NAME "sumu-dev" extern struct bus_type g_sbus ;typedef struct __SDRV_ATTR_VAR_ { char name_attr[32 ]; int data; }sdrv_attr_var_t ; sdrv_attr_var_t sdrv_attr = {0 }; static int sdrv_probe (struct device *dev) { int len = 0 ; const char *device_name = dev_name(dev); len = strlen (device_name); PRT("dev name is %s, len = %d\n" , device_name, len); return 0 ; } static int sdrv_remove (struct device *dev) { int len = 0 ; const char *device_name = dev_name(dev); len = strlen (device_name); PRT("dev name is %s, len = %d\n" , device_name, len); return 0 ; } static struct device_driver sdrv = .name = SDRV_MATCH_NAME, .bus = &g_sbus, .probe = sdrv_probe, .remove = sdrv_remove, }; static ssize_t sdrv_attr_name_show (struct device_driver *driver, char *buf) { ssize_t count = 0 ; count = sprintf (buf, "%s\n" , sdrv_attr.name_attr); PRT("device_driver->name=%s count=%d\n" , driver->name, count); return count; } static ssize_t sdrv_attr_name_store (struct device_driver *driver, const char *buf, size_t count) { PRT("device_driver->name=%s count=%d\n" , driver->name, count); sscanf (buf, "%s\n" , sdrv_attr.name_attr); return count; } struct driver_attribute sdrv_attr_name_var = .attr = { .name = "sdrv_attr_name" , .mode = 0664 , }, .show = sdrv_attr_name_show, .store = sdrv_attr_name_store, }; static ssize_t sdrv_attr_data_show (struct device_driver *driver, char *buf) { ssize_t count = 0 ; count = sprintf (buf, "%d\n" , sdrv_attr.data); PRT("device_driver->name=%s count=%d\n" , driver->name, count); return count; } static ssize_t sdrv_attr_data_store (struct device_driver *driver, const char *buf, size_t count) { PRT("device_driver->name=%s count=%d\n" , driver->name, count); sscanf (buf, "%d\n" , &sdrv_attr.data); return count; } DRIVER_ATTR_RW(sdrv_attr_data); static __init int sdrv_demo_init (void ) { int ret = 0 ; printk("*** [%s:%d]Build Time: %s %s, git version:%s ***\n" , __FUNCTION__, __LINE__, KERNEL_KO_DATE, KERNEL_KO_TIME, KERNEL_KO_VERSION); PRT("sdrv_demo module init!\n" ); ret = driver_register(&sdrv); if (ret < 0 ) { PRTE("driver_register fail!\n" ); goto err_driver_register; } snprintf (sdrv_attr.name_attr, sizeof (sdrv_attr.name_attr), SDRV_MATCH_NAME); sdrv_attr.data = 1 ; ret = driver_create_file(&sdrv, &sdrv_attr_name_var); if (ret < 0 ) { PRTE("driver_create_file sdrv_attr_name_var fail!ret=%d\n" , ret); goto err_driver_create_file1; } ret = driver_create_file(&sdrv, &driver_attr_sdrv_attr_data); if (ret < 0 ) { PRTE("driver_create_file driver_attr_sdrv_attr_data fail!ret=%d\n" , ret); goto err_driver_create_file2; } return 0 ; err_driver_create_file2: driver_remove_file(&sdrv, &sdrv_attr_name_var); err_driver_create_file1: driver_unregister(&sdrv); err_driver_register: return ret; } static __exit void sdrv_demo_exit (void ) { driver_remove_file(&sdrv, &driver_attr_sdrv_attr_data); driver_remove_file(&sdrv, &sdrv_attr_name_var); driver_unregister(&sdrv); PRT("sdrv_demo module exit!\n" ); } module_init(sdrv_demo_init); module_exit(sdrv_demo_exit); MODULE_LICENSE("GPL v2" ); MODULE_AUTHOR("sumu" ); MODULE_DESCRIPTION("Description" ); MODULE_ALIAS("module's other name" );
4. 开发板测试 可以看到，打印出了匹配成功的关键字。
（4）查看 /sys/bus/bus-name 下的文件情况
需要注意，卸载模块的时候要先卸载设备和驱动的，总线的最后卸载，因为设备和驱动都依赖于总线：
1 2 3 rmmod sdevice_demo.ko rmmod sdriver_demo.ko rmmod sbus_demo.ko
会有如下打印：
二、xxx_probe()函数执行流程 前面分析 bus_add_driver() 函数的时候，这个函数调用了 driver_attach() 函数来探测设备，我们来看一下这个 driver_attach() 函数。该函数定义如下：
1 2 3 4 5 int driver_attach (struct device_driver *drv) { return bus_for_each_dev(drv->bus, NULL , drv, __driver_attach); } EXPORT_SYMBOL_GPL(driver_attach);
可以看到里面调用了 bus_for_each_dev() 函数。这里要注意一下，调用这个函数的时候传入了另一个函数 __driver_attach() 。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 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 )); while (!error && (dev = next_device(&i))) error = fn(dev, data); klist_iter_exit(&i); return error; } EXPORT_SYMBOL_GPL(bus_for_each_dev);
这个函数的作用是遍历指定总线上的所有设备，并对每个设备执行指定的函数 fn。
这个函数的参数说明如下：
bus：指定要遍历的总线对象。
start：指定开始遍历的设备对象。如果为 NULL，则从总线的第一个设备开始遍历。
data：传递给函数 fn 的额外数据。
fn：指定要执行的函数，该函数接受一个设备对象和额外数据作为参数，并返回一个整数错误码。在这里，这个指针指向 __driver_attach() 函数
1 2 if (!bus || !bus->p) return -EINVAL;
首先，检查传入的总线对象是否存在以及与该总线相关的私有数据是否存 在。如果总线对象或其私有数据不存在，返回 -EINVAL 表示无效的参数错误码。
1 2 klist_iter_init_node(&bus->p->klist_devices, &i, (start ? &start->p->knode_bus : NULL ));
接下来，初始化设备列表迭代器，以便遍历总线上的设备。 使用 klist_iter_init_node() 函数初始化一个设备列表迭代器。传递总线对象的设备列表 klist_devices、迭代器对象 i，以及可选的起始设备的节点指针。然后，在一个循环中遍历设备列表并执行指定的函数。
1 2 while (!error && (dev = next_device(&i))) error = fn(dev, data);
使用 next_device() 函数从迭代器中获取下一个设备。如果存在下一个设 备，则调用传入的函数指针 fn，并将当前设备和额外的数据参数传递给它。如果执行函数时出现错误，将错误码赋值给 error。
最后，退出设备列表迭代器，释放相关资源。使用 klist_iter_exit() 函数退 出设备列表的迭代器。 总的来说， bus_for_each_dev() 函数主要是提供了一个遍历指定总线上的设备对象列表， 并对每个设备对象进行特定操作的快捷方式，可以用于驱动程序中需要管理和操作大量设备实例的场景。
前面知道fn指针指向的是__driver_attach() 函数：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 static int __driver_attach(struct device *dev, void *data){ struct device_driver *drv = int ret; ret = driver_match_device(drv, dev); if (ret == 0 ) { return 0 ; } else if (ret == -EPROBE_DEFER) { dev_dbg(dev, "Device match requests probe deferral\n" ); driver_deferred_probe_add(dev); } else if (ret < 0 ) { dev_dbg(dev, "Bus failed to match device: %d" , ret); return ret; } if (dev->parent && dev->bus->need_parent_lock) device_lock(dev->parent); device_lock(dev); if (!dev->p->dead && !dev->driver) driver_probe_device(drv, dev); device_unlock(dev); if (dev->parent && dev->bus->need_parent_lock) device_unlock(dev->parent); return 0 ; }
__driver_attach() 中使用 driver_match_device() 函数尝试将驱动程序绑定到设备上。可以看到，函数返回大于0的值后表示匹配成功。继续往下会调用 driver_probe_device() 函数来尝试绑定设备和驱动程序。其他的我们暂时不关心。
我们来看一下 driver_match_device() 函数：
1 2 3 4 5 static inline int driver_match_device (struct device_driver *drv, struct device *dev) { return drv->bus->match ? drv->bus->match(dev, drv) : 1 ; }
可以看到，该函数用于检查设备是否与驱动程序匹配。其中，drv是指向设备驱动程序对象的指针，dev是指向设备对象的指针。它的执行过程如下：
（1）检查驱动程序对象的 bus 字段是否为 NULL，以及 bus 字段的 match 函数是否存在。 驱动程序对象的 bus 字段表示该驱动程序所属的总线。match 函数是总线对象中的一个函数指 针，用于检查设备与驱动程序是否匹配。
（2）如果 match函数存在，则调用总线对象的 match 函数，传入设备对象和驱动程序对象作为参数。drv->bus->match(dev, drv)表示调用总线对象的 match 函数，并将设备对象和驱动程序对象 作为参数传递给该函数。dev 是用于匹配的设备对象。drv 是用于匹配的驱动程序对象。
（3）如果总线对象的 match 函数返回 0，则表示设备与驱动程序不匹配，函数将返回 0。返回值为 0 表示不匹配。
（4）如果总线对象的 match 函数返回非零值（大于 0），则表示设备与驱动程序匹配，函数将返回 1。返回值为 1 表示匹配。
（5）如果总线对象的 match 函数不存在（为 NULL），则默认认为设备与驱动程序匹配，函数将返回 1。
总之，它其实就是调用了 drv->bus->match 函数，就是我们前面总线中实现的xxx_match()函数来完成匹配。这个逻辑就是先判断一下match函数是否为空，若为空，就返回1，上一级函数 __driver_attach() 就可以正常往下执行，若是match函数不为空，这个时候返回值就是函数执行的结果，当返回0的时候表示没有设备匹配，返回1表示有设备匹配成功。
如果设备和驱动匹配上，会继续执行 driver_probe_device() 函数，它的定义如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 int driver_probe_device (struct device_driver *drv, struct device *dev) { int ret = 0 ; if (!device_is_registered(dev)) return -ENODEV; pr_debug("bus: '%s': %s: matched device %s with driver %s\n" , drv->bus->name, __func__, dev_name(dev), drv->name); pm_runtime_get_suppliers(dev); if (dev->parent) pm_runtime_get_sync(dev->parent); pm_runtime_barrier(dev); if (initcall_debug) ret = really_probe_debug(dev, drv); else ret = really_probe(dev, drv); pm_request_idle(dev); if (dev->parent) pm_runtime_put(dev->parent); pm_runtime_put_suppliers(dev); return ret; }
其他先不管，我们直接看第 658 - 661 行，上面这个 initcall_debug 是个全局变量，应该是调试的时候用，调试的时候调用 really_probe_debug() 函数，这个函数内部也是在调用 really_probe() 函数，我们直接看这个 really_probe() 函数：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 static int really_probe (struct device *dev, struct device_driver *drv) { if (dev->bus->probe) { ret = dev->bus->probe(dev); if (ret) goto probe_failed; } else if (drv->probe) { ret = drv->probe(dev); if (ret) goto probe_failed; } return ret; }
这个函数挺长的，别的就没咋关心了，直接看第 499 - 507 行这段。从这里可以看到，这里其实就是判断了一下dev->bus->probe、drv->probe这两个函数是否存在，存在的话就执行。 dev->bus->probe这个函数其实就是总线中实现的xxx_probe()函数，而 drv->probe 则是驱动中实现的xxx_probe()函数，上面的逻辑就是优先执行总线中的probe函数，若是总线中不存在，我们还可以找驱动中的probe函数执行。
1.3 总结 经过前面代码的分析，设备和驱动匹配流程函数的调用关系如下图所示：
really_probe() 函数定义如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 static int really_probe (struct device *dev, struct device_driver *drv) { int ret = -EPROBE_DEFER; int local_trigger_count = atomic_read (&deferred_trigger_count); bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) && !drv->suppress_bind_attrs; if (defer_all_probes) { dev_dbg(dev, "Driver %s force probe deferral\n" , drv->name); driver_deferred_probe_add(dev); return ret; } ret = device_links_check_suppliers(dev); if (ret == -EPROBE_DEFER) driver_deferred_probe_add_trigger(dev, local_trigger_count); if (ret) return ret; atomic_inc (&probe_count); pr_debug("bus: '%s': %s: probing driver %s with device %s\n" , drv->bus->name, __func__, drv->name, dev_name(dev)); WARN_ON(!list_empty(&dev->devres_head)); re_probe: dev->driver = drv; ret = pinctrl_bind_pins(dev); if (ret) goto pinctrl_bind_failed; ret = dma_configure(dev); if (ret) goto probe_failed; if (driver_sysfs_add(dev)) { printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n" , __func__, dev_name(dev)); goto probe_failed; } if (dev->pm_domain && dev->pm_domain->activate) { ret = dev->pm_domain->activate(dev); if (ret) goto probe_failed; } if (dev->bus->probe) { ret = dev->bus->probe(dev); if (ret) goto probe_failed; } else if (drv->probe) { ret = drv->probe(dev); if (ret) goto probe_failed; } if (test_remove) { test_remove = false ; if (dev->bus->remove) dev->bus->remove(dev); else if (drv->remove) drv->remove(dev); devres_release_all(dev); driver_sysfs_remove(dev); dev->driver = NULL ; dev_set_drvdata(dev, NULL ); if (dev->pm_domain && dev->pm_domain->dismiss) dev->pm_domain->dismiss(dev); pm_runtime_reinit(dev); goto re_probe; } pinctrl_init_done(dev); if (dev->pm_domain && dev->pm_domain->sync) dev->pm_domain->sync(dev); driver_bound(dev); ret = 1 ; pr_debug("bus: '%s': %s: bound device %s to driver %s\n" , drv->bus->name, __func__, dev_name(dev), drv->name); goto done; probe_failed: if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_DRIVER_NOT_BOUND, dev); pinctrl_bind_failed: device_links_no_driver(dev); devres_release_all(dev); dma_deconfigure(dev); driver_sysfs_remove(dev); dev->driver = NULL ; dev_set_drvdata(dev, NULL ); if (dev->pm_domain && dev->pm_domain->dismiss) dev->pm_domain->dismiss(dev); pm_runtime_reinit(dev); dev_pm_set_driver_flags(dev, 0 ); switch (ret) { case -EPROBE_DEFER: dev_dbg(dev, "Driver %s requests probe deferral\n" , drv->name); driver_deferred_probe_add_trigger(dev, local_trigger_count); break ; case -ENODEV: case -ENXIO: pr_debug("%s: probe of %s rejects match %d\n" , drv->name, dev_name(dev), ret); break ; default : printk(KERN_WARNING "%s: probe of %s failed with error %d\n" , drv->name, dev_name(dev), ret); } ret = 0 ; done: atomic_dec (&probe_count); wake_up(&probe_waitqueue); return ret; }
三、驱动和设备加载的先后顺序 由于驱动和设备都要用到总线中的符号，所以总线一定是最先加载的，这个毫无疑问，其实在测试demo的过程中，会发现不管先加载驱动，还是先加载设备，最终都会完成匹配。
加载驱动的时候上面已经分析过了，会在 __driver_attach() 函数中调用总线中的匹配函数完成设备和驱动的匹配（若是有驱动在的话）。那么先加载驱动后加载设备，也是可以完成匹配的，设备加载的时候是怎么完成匹配的呢？
device_add() 函数定义如下：
1 2 3 4 5 6 7 8 9 10 int device_add (struct device *dev) { bus_probe_device(dev); if (parent) klist_add_tail(&dev->p->knode_parent, &parent->p->klist_children); } EXPORT_SYMBOL_GPL(device_add);
该函数内部调用了 bus_probe_device() 函数，这个函数定义如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 void bus_probe_device (struct device *dev) { struct bus_type *bus = struct subsys_interface *sif ; if (!bus) return ; if (bus->p->drivers_autoprobe) device_initial_probe(dev); mutex_lock(&bus->p->mutex); list_for_each_entry(sif, &bus->p->interfaces, node) if (sif->add_dev) sif->add_dev(dev, sif); mutex_unlock(&bus->p->mutex); }
可以看到在函数内部调用了 device_initial_probe() 函数，该函数定义如下：
1 2 3 4 void device_initial_probe (struct device *dev) { __device_attach(dev, true ); }
可以看到这个函数最终又调用了 __device_attach() 函数。
__device_attach() 函数定义如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 static int __device_attach(struct device *dev, bool allow_async){ int ret = 0 ; device_lock(dev); if (dev->driver) { if (device_is_bound(dev)) { ret = 1 ; goto out_unlock; } ret = device_bind_driver(dev); if (ret == 0 ) ret = 1 ; else { dev->driver = NULL ; ret = 0 ; } } else { struct device_attach_data data = { .dev = dev, .check_async = allow_async, .want_async = false , }; if (dev->parent) pm_runtime_get_sync(dev->parent); ret = bus_for_each_drv(dev->bus, NULL , &data, __device_attach_driver); if (!ret && allow_async && data.have_async) { dev_dbg(dev, "scheduling asynchronous probe\n" ); get_device(dev); async_schedule(__device_attach_async_helper, dev); } else { pm_request_idle(dev); } if (dev->parent) pm_runtime_put(dev->parent); } out_unlock: device_unlock(dev); return ret; }
通过调用 device_lock(dev) 锁定设备，确保在进行设备附加操作时不会被其他线程干扰。
1 2 3 4 5 6 7 8 9 10 11 12 13 if (dev->driver) { if (device_is_bound(dev)) { ret = 1 ; goto out_unlock; } ret = device_bind_driver(dev); if (ret == 0 ) ret = 1 ; else { dev->driver = NULL ; ret = 0 ; } }
检查 dev->driver 成员是否为空，此处非空的情况。设备已经绑定了驱动程序，则返回 1。如果设备没有绑定驱动程序，则尝试将设备与驱动程序进行绑定。如果绑定成功，返回 1；否则，将设备的驱动程序指针置为 NULL，并返回 0。
1 2 3 4 5 struct device_attach_data data = .dev = dev, .check_async = allow_async, .want_async = false , };
dev->driver 为空时，那么需要遍历总线上的驱动程序进行匹配。为此，定义了一个结构体 struct device_attach_data ，其中包含了设备、是否允许异步 探测以及是否有驱动程序要求异步探测的信息。
1 2 if (dev->parent) pm_runtime_get_sync(dev->parent);
如果设备有父设备，调用 pm_runtime_get_sync(dev->parent) 增加父设备的引用计数。
第 814 - 829 行
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ret = bus_for_each_drv(dev->bus, NULL , &data, __device_attach_driver); if (!ret && allow_async && data.have_async) { dev_dbg(dev, "scheduling asynchronous probe\n" ); get_device(dev); async_schedule(__device_attach_async_helper, dev); } else { pm_request_idle(dev); }
调用 bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver) 遍历总线上的驱动 程序，并调用 __device_attach_driver() 进行匹配。__device_attach_driver() 是一个回调函数，用于判断驱动程序是否适配当前设备。
如果无法同步找到适合的驱动程序，并且允许异步探测以及有驱动程序要求异步探测，则调度异步任务 __device_attach_async_helper() 进行异步探测。在异步探测之前，会增加设备的引用计数以确保设备在异步探测期间不会被释放。异步探测会在后台进行，不会阻塞当前线程。
如果无法异步探测或者没有驱动程序要求异步探测，则调用 pm_request_idle(dev) 进入空 闲状态，让设备进入省电模式。
device_bind_driver() 函数定义如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 int device_bind_driver (struct device *dev) { int ret; ret = driver_sysfs_add(dev); if (!ret) driver_bound(dev); else if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_DRIVER_NOT_BOUND, dev); return ret; } EXPORT_SYMBOL_GPL(device_bind_driver);
函数中调用 driver_bound() 函数完成设备和驱动程序的绑定，这个函数定义如下：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 static void driver_bound (struct device *dev) { if (device_is_bound(dev)) { printk(KERN_WARNING "%s: device %s already bound\n" , __func__, kobject_name(&dev->kobj)); return ; } pr_debug("driver: '%s': %s: bound to device '%s'\n" , dev->driver->name, __func__, dev_name(dev)); klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices); device_links_driver_bound(dev); device_pm_check_callbacks(dev); driver_deferred_probe_del(dev); driver_deferred_probe_trigger(); if (dev->bus) blocking_notifier_call_chain(&dev->bus->p->bus_notifier, BUS_NOTIFY_BOUND_DRIVER, dev); kobject_uevent(&dev->kobj, KOBJ_BIND); }
driver_bound() 函数的作用是将驱动和设备进行绑定，首先，通过调用 device_is_bound(dev) 检查设备是否已经绑定了驱动程序。如果设备已经绑定了驱动程序，则输出警告信息并返回。如果设备未绑定驱动程序，将输出绑定信息，其中包括驱动程序的名称、函数名和设备的名称。接下 来，通过调用 klist_add_tail() 将设备添加到驱动程序的设备链表中。这样，驱动程序可以通 过遍历该链表来访问所有已绑定的设备。 然后，调用 device_links_driver_bound() 更新设备的驱动程序链接状态。这个函数会确保设备和驱动程序之间的链接关系是正确的。
4. 总结 先加载驱动，后加载设备的时候，设备和驱动匹配的时候的函数调用关系如下：
四、总结 1. 设备和驱动数据结构关系 到为止简单地了解了总线、设备、驱动的数据结构以及注册/注销接口函数。下图是总线关联上设备与驱动之后的数据结构关系图：
2. 注册流程 设备和驱动的注册流程如下：
系统启动之后会调用buses_init函数创建/sys/bus文件目录，这部分系统在开机时已经帮我们准备好了， 接下去就是通过总线注册函数bus_register进行总线注册，注册完总线后在总线的目录下生成devices文件夹和drivers文件夹， 最后分别通过device_register以及driver_register函数注册相对应的设备和驱动。
