一.安卓8.1 设备匹配驱动过程

一.安卓8.1 设备匹配驱动过程
当内核发现一个新设备总是会调用device_add
Y:\kernel\drivers\base\core.c
device_add->{
bus_add_device
bus_probe_device(dev);
}

bus_add_device->                            Y:\kernel\drivers\base\bus.c
 bus_probe_device(dev);->
            device_initial_probe->           Y:\kernel\drivers\base\dd.c
                __device_attach(dev, true);->
                                bus_for_each_drv->          Y:\kernel\drivers\base\bus.c
                                         error = fn(drv, data);
        fn 等于传递的函数指针 __device_attach_driver

__device_attach_driver->                                  Y:\kernel\drivers\base\dd.c
       driver_match_device    //检查设备与驱动是否匹配
        ->driver_probe_device(drv, dev);->
                    really_probe(dev, drv);             Y:\kernel\drivers\base\dd.c

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) { //interface级别:
ret = drv->probe(dev);
if (ret)
goto probe_failed;
}

}
1.对于usb设备则是调用一下2种方式
① usb设备
usb_register_device_driver-> Y:\kernel\drivers\usb\core\driver.c
usb_probe_device ->
udriver->probe(udev);
②usb接口
usb_register_driver->
usb_probe_interface->
driver->probe(intf, id);

二.检查驱动与设备是否匹配

__device_attach_driver-> Y:\kernel\drivers\base\dd.c
driver_match_device-> drivers/base/base.h //检查设备与驱动是否匹配

static inline int driver_match_device(struct device_driver *drv,
struct device *dev)
{
return drv->bus->match ? drv->bus->match(dev, drv) : 1;
}
1.对于平台设备 drivers/base/platform.c中

 int __platform_driver_register(struct platform_driver *drv,struct module *owner)   中

{
drv->driver.owner = owner;
drv->driver.bus = &platform_bus_type;
drv->driver.probe = platform_drv_probe;
drv->driver.remove = platform_drv_remove;
drv->driver.shutdown = platform_drv_shutdown;

    return driver_register(&drv->driver);

}
而struct bus_type platform_bus_type = {
.name = “platform”,
.dev_groups = platform_dev_groups,
.match = platform_match,
.uevent = platform_uevent,
.pm = &platform_dev_pm_ops,
};

所以 ->drv->bus->match()==platform_match()
->比较strncmp(pdev->name, drv->name, BUS_ID_SIZE)
如果相符就调用platform_drv_probe()->driver->probe()，如果probe成功则绑定该设备到该驱动.
1.对于usb设备Y:\kernel\drivers\usb\core\driver.c中
int usb_register_device_driver(struct usb_device_driver *new_udriver,
struct module *owner)
{
int retval = 0;

if (usb_disabled())
    return -ENODEV;

new_udriver->drvwrap.for_devices = 1;
new_udriver->drvwrap.driver.name = new_udriver->name;
new_udriver->drvwrap.driver.bus = &usb_bus_type;
new_udriver->drvwrap.driver.probe = usb_probe_device;
new_udriver->drvwrap.driver.remove = usb_unbind_device;
new_udriver->drvwrap.driver.owner = owner;

retval = driver_register(&new_udriver->drvwrap.driver);

if (!retval)
    pr_info("%s: registered new device driver %s\n",
        usbcore_name, new_udriver->name);
else
    printk(KERN_ERR "%s: error %d registering device "
        "    driver %s\n",
        usbcore_name, retval, new_udriver->name);

return retval;

}
struct bus_type usb_bus_type = {
.name = “usb”,
.match = usb_device_match,
.uevent = usb_uevent,
};
所以usb_device_match 简单判断是否usb设备
if (is_usb_device(dev)) {
}
else if (is_usb_interface(dev)) {}