USB模块的疑惑

hk2305621

我看 USB 模块, 有一个地方, 有点疑惑. 请诸位帮忙解答下.

<drivers/usb/storage/usb.c 中间定义了 usb_storage_driver, 声明如下:

1. static struct usb_driver usb_storage_driver = {
   
2.         .name =                "usb-storage",
   
3.         .probe =        storage_probe,
   
4.         .disconnect =        usb_stor_disconnect,
   
5.         .suspend =        usb_stor_suspend,
   
6.         .resume =        usb_stor_resume,
   
7.         .reset_resume =        usb_stor_reset_resume,
   
8.         .pre_reset =        usb_stor_pre_reset,
   
9.         .post_reset =        usb_stor_post_reset,
   
10.         .id_table =        usb_storage_usb_ids,
    
11.         .supports_autosuspend = 1,
    
12.         .soft_unbind =        1,
    
13. };

复制代码

而其中 storage_probe 函数的定义形式如下:

1. static int storage_probe(struct usb_interface *intf,
   
2.                          const struct usb_device_id *id)

复制代码

<drivers/usb/core/hub.c> 中有一个函数调用过程如下

1. hub_thread() -> hub_events() -> hub_port_connect_change() ->usb_new_device() -> device_add()

复制代码

函数 usb_new_device 传递给 device_add 函数的参数是

1. err = device_add(&udev->dev);

复制代码

其中 udev 是 usb_device 类型.

在 device_add 函数中会去匹配 usb bus 上的 driver. 如果匹配上了, 就会调用 driver 的 probe 函数.
调用路径为:

1. device_add() -> bus_probe_device() -> device_attach() -> __device_attach() -> driver_probe_device() -> really_probe()

复制代码

其中 really_probe 函数定义如下:

1. static int really_probe(struct device *dev, struct device_driver *drv)
   
2. {
   
3.         int ret = 0;
   
4. 
   
5.         atomic_inc(&probe_count);
   
6.         pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
   
7.                  drv->bus->name, __func__, drv->name, dev_name(dev));
   
8.         WARN_ON(!list_empty(&dev->devres_head));
   
9. 
   
10.         dev->driver = drv;
    
11.         if (driver_sysfs_add(dev)) {
    
12.                 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
    
13.                         __func__, dev_name(dev));
    
14.                 goto probe_failed;
    
15.         }
    
16. 
    
17.         if (dev->bus->probe) {
    
18.                 ret = dev->bus->probe(dev);
    
19.                 if (ret)
    
20.                         goto probe_failed;
    
21.         } else if (drv->probe) {
    
22.                 ret = drv->probe(dev);
    
23.                 if (ret)
    
24.                         goto probe_failed;
    
25.         }
    
26. 
    
27.         driver_bound(dev);
    
28.         ret = 1;
    
29.         pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
    
30.                  drv->bus->name, __func__, dev_name(dev), drv->name);
    
31.         goto done;
    
32. 
    
33. probe_failed:
    
34.         devres_release_all(dev);
    
35.         driver_sysfs_remove(dev);
    
36.         dev->driver = NULL;
    
37. 
    
38.         if (ret != -ENODEV && ret != -ENXIO) {
    
39.                 /* driver matched but the probe failed */
    
40.                 printk(KERN_WARNING
    
41.                        "%s: probe of %s failed with error %d\n",
    
42.                        drv->name, dev_name(dev), ret);
    
43.         }
    
44.         /*
    
45.          * Ignore errors returned by ->probe so that the next driver can try
    
46.          * its luck.
    
47.          */
    
48.         ret = 0;
    
49. done:
    
50.         atomic_dec(&probe_count);
    
51.         wake_up(&probe_waitqueue);
    
52.         return ret;
    
53. }
    

复制代码

我的疑惑在于:

当有U盘插入设备时: 由于 usb bus 并没有定义 probe 函数, 那么会调用 driver 的 probe 函数, 也应该就是 storage_probe 函数.
而storage_probe函数需要的两个参数类型和really_probe 传递给 probe 的不一致.

请问这中间是如何协调的? 还是调用的 probe 函数是 usb-core 的 probe, usb-core 的probe 再去调用 usb-storage 的 probe 的呢？

tempname2

>> 由于 usb bus 并没有定义 probe 函数, 那么会调用 driver 的 probe 函数, 也应该就是 storage_probe 函数

看清楚storage_probe是哪个结构体的probe，generic的代码怎么会突然扯到那个结构体上去了。

hk2305621

回复 2# tempname2


   不太好意思, 没有理解你这话的深层含义.

storage_probe 函数是 usb_driver usb_storage_driver 的成员函数.

而 usb_storage_driver 是挂接在 usb bus 上的.

然后, generic的代码？ 没理解？

hk2305621

回复 2# tempname2


    我刚看代码了解了. 知道这个问题的答案了.

在 drivers/usb/core/driver.c 中, usb_register_dirver函数, 将usb_driver 中 drvwrap 成员的 device_driver 的 probe 函数替换了.

1. int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
   
2.                         const char *mod_name)
   
3. {
   
4.         int retval = 0;
   
5. 
   
6.         if (usb_disabled())
   
7.                 return -ENODEV;
   
8. 
   
9.         new_driver->drvwrap.for_devices = 0;
   
10.         new_driver->drvwrap.driver.name = (char *) new_driver->name;
    
11.         new_driver->drvwrap.driver.bus = &usb_bus_type;
    
12.         new_driver->drvwrap.driver.probe = usb_probe_interface; // here.....
    
13.         new_driver->drvwrap.driver.remove = usb_unbind_interface;
    
14.         new_driver->drvwrap.driver.owner = owner;
    
15.         new_driver->drvwrap.driver.mod_name = mod_name;
    
16.         spin_lock_init(&new_driver->dynids.lock);
    
17.         INIT_LIST_HEAD(&new_driver->dynids.list);
    
18. 
    
19.         retval = driver_register(&new_driver->drvwrap.driver);
    
20.         if (retval)
    
21.                 goto out;
    
22. 
    
23.         usbfs_update_special();
    
24. 
    
25.         retval = usb_create_newid_file(new_driver);
    
26.         if (retval)
    
27.                 goto out_newid;
    
28. 
    
29.         retval = usb_create_removeid_file(new_driver);
    
30.         if (retval)
    
31.                 goto out_removeid;
    
32. 
    
33.         pr_info("%s: registered new interface driver %s\n",
    
34.                         usbcore_name, new_driver->name);
    
35. 
    
36. out:
    
37.         return retval;
    
38. 
    
39. out_removeid:
    
40.         usb_remove_newid_file(new_driver);
    
41. out_newid:
    
42.         driver_unregister(&new_driver->drvwrap.driver);
    
43. 
    
44.         printk(KERN_ERR "%s: error %d registering interface "
    
45.                         "        driver %s\n",
    
46.                         usbcore_name, retval, new_driver->name);
    
47.         goto out;
    
48. }

复制代码

usb_probe_interface这个借口函数才会去调用 usb_storage_driver结构的probe 函数. 接口函数为:

1. static int usb_probe_interface(struct device *dev)
   
2. {
   
3.         struct usb_driver *driver = to_usb_driver(dev->driver);
   
4.         struct usb_interface *intf = to_usb_interface(dev);
   
5.         struct usb_device *udev = interface_to_usbdev(intf);
   
6.         const struct usb_device_id *id;
   
7.         int error = -ENODEV;
   
8. 
   
9.         dev_dbg(dev, "%s\n", __func__);
   
10. 
    
11.         intf->needs_binding = 0;
    
12. 
    
13.         if (usb_device_is_owned(udev))
    
14.                 return error;
    
15. 
    
16.         if (udev->authorized == 0) {
    
17.                 dev_err(&intf->dev, "Device is not authorized for usage\n");
    
18.                 return error;
    
19.         }
    
20. 
    
21.         id = usb_match_id(intf, driver->id_table);
    
22.         if (!id)
    
23.                 id = usb_match_dynamic_id(intf, driver);
    
24.         if (!id)
    
25.                 return error;
    
26. 
    
27.         dev_dbg(dev, "%s - got id\n", __func__);
    
28. 
    
29.         error = usb_autoresume_device(udev);
    
30.         if (error)
    
31.                 return error;
    
32. 
    
33.         intf->condition = USB_INTERFACE_BINDING;
    
34. 
    
35.         /* Probed interfaces are initially active.  They are
    
36.          * runtime-PM-enabled only if the driver has autosuspend support.
    
37.          * They are sensitive to their children's power states.
    
38.          */
    
39.         pm_runtime_set_active(dev);
    
40.         pm_suspend_ignore_children(dev, false);
    
41.         if (driver->supports_autosuspend)
    
42.                 pm_runtime_enable(dev);
    
43. 
    
44.         /* Carry out a deferred switch to altsetting 0 */
    
45.         if (intf->needs_altsetting0) {
    
46.                 error = usb_set_interface(udev, intf->altsetting[0].
    
47.                                 desc.bInterfaceNumber, 0);
    
48.                 if (error < 0)
    
49.                         goto err;
    
50.                 intf->needs_altsetting0 = 0;
    
51.         }
    
52. 
    
53.         error = driver->probe(intf, id);  // here, to call usb_storage_driver.probe 函数.
    
54.         if (error)
    
55.                 goto err;
    
56. 
    
57.         intf->condition = USB_INTERFACE_BOUND;
    
58.         usb_autosuspend_device(udev);
    
59.         return error;
    
60. 
    
61. err:
    
62.         intf->needs_remote_wakeup = 0;
    
63.         intf->condition = USB_INTERFACE_UNBOUND;
    
64.         usb_cancel_queued_reset(intf);
    
65. 
    
66.         /* Unbound interfaces are always runtime-PM-disabled and -suspended */
    
67.         if (driver->supports_autosuspend)
    
68.                 pm_runtime_disable(dev);
    
69.         pm_runtime_set_suspended(dev);
    
70. 
    
71.         usb_autosuspend_device(udev);
    
72.         return error;
    
73. }

复制代码

usb_driver 结构体为:

1. struct usb_driver {
   
2.         const char *name;
   
3. 
   
4.         int (*probe) (struct usb_interface *intf,
   
5.                       const struct usb_device_id *id);
   
6. 
   
7.         void (*disconnect) (struct usb_interface *intf);
   
8. 
   
9.         int (*unlocked_ioctl) (struct usb_interface *intf, unsigned int code,
   
10.                         void *buf);
    
11. 
    
12.         int (*suspend) (struct usb_interface *intf, pm_message_t message);
    
13.         int (*resume) (struct usb_interface *intf);
    
14.         int (*reset_resume)(struct usb_interface *intf);
    
15. 
    
16.         int (*pre_reset)(struct usb_interface *intf);
    
17.         int (*post_reset)(struct usb_interface *intf);
    
18. 
    
19.         const struct usb_device_id *id_table;
    
20. 
    
21.         struct usb_dynids dynids;
    
22.         struct usbdrv_wrap drvwrap;
    
23.         unsigned int no_dynamic_id:1;
    
24.         unsigned int supports_autosuspend:1;
    
25.         unsigned int soft_unbind:1;
    
26. }

复制代码

struct usbdrv_wrap j结构体为:

1. struct usbdrv_wrap {
   
2.         struct device_driver driver;
   
3.         int for_devices;
   
4. };

复制代码

当调用 device_add 函数时, 相应的 driver 是 usb-core. 不知道这样理解对不对.