usb

1. usb hub

 以前不太了解hub，一直认为它只是一个可选设备，和网络集线器类似，有它不多，少它也可；
太低调了，以至于都不晓得它长在哪里，今天在网上百度了一下，发现它是window和linux系统上一个必备的设备；是EHCI/UHCI的私生子，一直躺在妈妈的怀里；

设备部分：<usb_device_type 篇>
hub是usb控制器的私生子，那么他就在hcd.c中生成：
usb_add_hcd（）
{
...
rhdev = usb_alloc_dev(NULL, &hcd->self, 0);
hcd->self.root_hub = rhdev;
register_root_hub(hcd);//完成设备添加了；
...
}
下面中的介绍usb_alloc_dev和register_root_hub
函数一

点击(此处)折叠或打开

1. /**
   
2. * usb_add_hcd - finish generic HCD structure initialization and register
   
3. * @hcd: the usb_hcd structure to initialize
   
4. * @irqnum: Interrupt line to allocate
   
5. * @irqflags: Interrupt type flags
   
6. *
   
7. * Finish the remaining parts of generic HCD initialization: allocate the
   
8. * buffers of consistent memory, register the bus, request the IRQ line,
   
9. * and call the driver's reset() and start() routines.
   
10. */
    
11. int usb_add_hcd(struct usb_hcd *hcd,
    
12.         unsigned int irqnum, unsigned long irqflags)
    
13. {
    
14.     int retval;
    
15.     struct usb_device *rhdev;
    
16. 
    
17.     dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
    
18. 
    
19.     hcd->authorized_default = hcd->wireless? 0 : 1;
    
20.     set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
    
21. 
    
22.     /* HC is in reset state, but accessible. Now do the one-time init,
    
23.      * bottom up so that hcds can customize the root hubs before khubd
    
24.      * starts talking to them. (Note, bus id is assigned early too.)
    
25.      */
    
26.     if ((retval = hcd_buffer_create(hcd)) != 0) {
    
27.         dev_dbg(hcd->self.controller, "pool alloc failed\n");
    
28.         return retval;
    
29.     }
    
30. 
    
31.     if ((retval = usb_register_bus(&hcd->self)) < 0)
    
32.         goto err_register_bus;
    
33. 
    
34.     if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) {
    
35.         dev_err(hcd->self.controller, "unable to allocate root hub\n");
    
36.         retval = -ENOMEM;
    
37.         goto err_allocate_root_hub;
    
38.     }
    
39. 
    
40.     switch (hcd->driver->flags & HCD_MASK) {
    
41.     case HCD_USB11:
    
42.         rhdev->speed = USB_SPEED_FULL;
    
43.         break;
    
44.     case HCD_USB2:
    
45.         rhdev->speed = USB_SPEED_HIGH;
    
46.         break;
    
47.     case HCD_USB3:
    
48.         rhdev->speed = USB_SPEED_SUPER;
    
49.         break;
    
50.     default:
    
51.         goto err_allocate_root_hub;
    
52.     }
    
53.     hcd->self.root_hub = rhdev;//设备
    
54. 
    
55.     /* wakeup flag init defaults to "everything works" for root hubs,
    
56.      * but drivers can override it in reset() if needed, along with
    
57.      * recording the overall controller's system wakeup capability.
    
58.      */
    
59.     device_init_wakeup(&rhdev->dev, 1);
    
60. 
    
61.     /* "reset" is misnamed; its role is now one-time init. the controller
    
62.      * should already have been reset (and boot firmware kicked off etc).
    
63.      */
    
64.      //控制器复位:ehci_pci_setup
    
65.     if (hcd->driver->reset && (retval = hcd->driver->reset(hcd)) < 0) {
    
66.         dev_err(hcd->self.controller, "can't setup\n");
    
67.         goto err_hcd_driver_setup;
    
68.     }
    
69. 
    
70.     /* NOTE: root hub and controller capabilities may not be the same */
    
71.     if (device_can_wakeup(hcd->self.controller)
    
72.             && device_can_wakeup(&hcd->self.root_hub->dev))
    
73.         dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
    
74. //控制器中断处理接口
    
75.     /* enable irqs just before we start the controller */
    
76.     if (hcd->driver->irq) {
    
77. 
    
78.         /* IRQF_DISABLED doesn't work as advertised when used together
    
79.          * with IRQF_SHARED. As usb_hcd_irq() will always disable
    
80.          * interrupts we can remove it here.
    
81.          */
    
82.         if (irqflags & IRQF_SHARED)
    
83.             irqflags &= ~IRQF_DISABLED;
    
84. 
    
85.         snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
    
86.                 hcd->driver->description, hcd->self.busnum);
    
87.         if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
    
88.                 hcd->irq_descr, hcd)) != 0) {
    
89.             dev_err(hcd->self.controller,
    
90.                     "request interrupt %d failed\n", irqnum);
    
91.             goto err_request_irq;
    
92.         }
    
93.         hcd->irq = irqnum;
    
94.         dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
    
95.                 (hcd->driver->flags & HCD_MEMORY) ?
    
96.                     "io mem" : "io base",
    
97.                     (unsigned long long)hcd->rsrc_start);
    
98.     } else {
    
99.         hcd->irq = -1;
    
100.         if (hcd->rsrc_start)
     
101.             dev_info(hcd->self.controller, "%s 0x%08llx\n",
     
102.                     (hcd->driver->flags & HCD_MEMORY) ?
     
103.                     "io mem" : "io base",
     
104.                     (unsigned long long)hcd->rsrc_start);
     
105.     }
     
106. //控制器run:ehci_run
     
107.     if ((retval = hcd->driver->start(hcd)) < 0) {
     
108.         dev_err(hcd->self.controller, "startup error %d\n", retval);
     
109.         goto err_hcd_driver_start;
     
110.     }
     
111. 
     
112.     /* starting here, usbcore will pay attention to this root hub */
     
113.     rhdev->bus_mA = min(500u, hcd->power_budget);
     
114.     if ((retval = register_root_hub(hcd)) != 0)//设备添加到内核中了；
     
115.         goto err_register_root_hub;
     
116. 
     
117.     retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
     
118.     if (retval < 0) {
     
119.         printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
     
120.                retval);
     
121.         goto error_create_attr_group;
     
122.     }
     
123.     if (hcd->uses_new_polling && hcd->poll_rh)
     
124.         usb_hcd_poll_rh_status(hcd);
     
125.     return retval;
     
126. 
     
127. error_create_attr_group:
     
128.     mutex_lock(&usb_bus_list_lock);
     
129.     usb_disconnect(&hcd->self.root_hub);
     
130.     mutex_unlock(&usb_bus_list_lock);
     
131. err_register_root_hub:
     
132.     hcd->driver->stop(hcd);
     
133. err_hcd_driver_start:
     
134.     if (hcd->irq >= 0)
     
135.         free_irq(irqnum, hcd);
     
136. err_request_irq:
     
137. err_hcd_driver_setup:
     
138.     hcd->self.root_hub = NULL;
     
139.     usb_put_dev(rhdev);
     
140. err_allocate_root_hub:
     
141.     usb_deregister_bus(&hcd->self);
     
142. err_register_bus:
     
143.     hcd_buffer_destroy(hcd);
     
144.     return retval;
     
145. }

函数二

点击(此处)折叠或打开

1. /**
   
2. * usb_alloc_dev - usb device constructor (usbcore-internal)
   
3. * @parent: hub to which device is connected; null to allocate a root hub
   
4. * @bus: bus used to access the device
   
5. * @port1: one-based index of port; ignored for root hubs
   
6. * Context: !in_interrupt()
   
7. *
   
8. * Only hub drivers (including virtual root hub drivers for host
   
9. * controllers) should ever call this.
   
10. *
    
11. * This call may not be used in a non-sleeping context.
    
12. */
    
13. struct usb_device *usb_alloc_dev(struct usb_device *parent,
    
14.                  struct usb_bus *bus, unsigned port1)
    
15. {
    
16.     struct usb_device *dev;
    
17.     struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self);
    
18.     unsigned root_hub = 0;
    
19. //usb设备对象；
    
20.     dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    
21.     if (!dev)
    
22.         return NULL;
    
23. 
    
24.     if (!usb_get_hcd(bus_to_hcd(bus))) {
    
25.         kfree(dev);
    
26.         return NULL;
    
27.     }
    
28.     /* Root hubs aren't true devices, so don't allocate HCD resources */
    
29.     if (usb_hcd->driver->alloc_dev && parent &&
    
30.         !usb_hcd->driver->alloc_dev(usb_hcd, dev)) {
    
31.         usb_put_hcd(bus_to_hcd(bus));
    
32.         kfree(dev);
    
33.         return NULL;
    
34.     }
    
35.     //usb_device_type
    
36. //usb设备的基本属性还是device；
    
37.     device_initialize(&dev->dev);
    
38.     dev->dev.bus = &usb_bus_type;//所属总线；
    
39.     dev->dev.type = &usb_device_type;//usb设备类型，有别于usb_if_device_type;
    
40.     dev->dev.groups = usb_device_groups;
    
41.     dev->dev.dma_mask = bus->controller->dma_mask;
    
42.     set_dev_node(&dev->dev, dev_to_node(bus->controller));
    
43.     //USB设备的状态变化；表示已连接上(生来就是在一起的)
    
44.     //后面这个状态会一直变化的；
    
45.     dev->state = USB_STATE_ATTACHED;
    
46.     atomic_set(&dev->urbnum, 0);
    
47. 
    
48.     INIT_LIST_HEAD(&dev->ep0.urb_list);
    
49.     //初始化端点信息
    
50.     dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
    
51.     dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
    
52.     /* ep0 maxpacket comes later, from device descriptor */
    
53.     //使能控制:ep->enabled = 1;
    
54.     usb_enable_endpoint(dev, &dev->ep0, false);
    
55.     dev->can_submit = 1;
    
56. 
    
57.     /* Save readable and stable topology id, distinguishing devices
    
58.      * by location for diagnostics, tools, driver model, etc.  The
    
59.      * string is a path along hub ports, from the root.  Each device's
    
60.      * dev->devpath will be stable until USB is re-cabled, and hubs
    
61.      * are often labeled with these port numbers.  The name isn't
    
62.      * as stable:  bus->busnum changes easily from modprobe order,
    
63.      * cardbus or pci hotplugging, and so on.
    
64.      */
    
65.     if (unlikely(!parent)) {//hub就是这条路；
    
66.         dev->devpath[0] = '0';
    
67.         dev->route = 0;
    
68. 
    
69.         dev->dev.parent = bus->controller;
    
70.         dev_set_name(&dev->dev, "usb%d", bus->busnum);//设备名称usbXX
    
71.         root_hub = 1;
    
72.     } else {
    
73.         /* match any labeling on the hubs; it's one-based */
    
74.         if (parent->devpath[0] == '0') {
    
75.             snprintf(dev->devpath, sizeof dev->devpath,
    
76.                 "%d", port1);
    
77.             /* Root ports are not counted in route string */
    
78.             dev->route = 0;
    
79.         } else {
    
80.             snprintf(dev->devpath, sizeof dev->devpath,
    
81.                 "%s.%d", parent->devpath, port1);
    
82.             /* Route string assumes hubs have less than 16 ports */
    
83.             if (port1 < 15)
    
84.                 dev->route = parent->route +
    
85.                     (port1 << ((parent->level - 1)*4));
    
86.             else
    
87.                 dev->route = parent->route +
    
88.                     (15 << ((parent->level - 1)*4));
    
89.         }
    
90. 
    
91.         dev->dev.parent = &parent->dev;
    
92.         dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
    
93. 
    
94.         /* hub driver sets up TT records */
    
95.     }
    
96. 
    
97.     dev->portnum = port1;
    
98.     dev->bus = bus;
    
99.     dev->parent = parent;
    
100.     INIT_LIST_HEAD(&dev->filelist);
     
101. 
     
102. #ifdef    CONFIG_PM
     
103.     mutex_init(&dev->pm_mutex);
     
104.     INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);
     
105.     INIT_WORK(&dev->autoresume, usb_autoresume_work);
     
106.     dev->autosuspend_delay = usb_autosuspend_delay * HZ;
     
107.     dev->connect_time = jiffies;
     
108.     dev->active_duration = -jiffies;
     
109. #endif
     
110.     if (root_hub)    /* Root hub always ok [and always wired] */
     
111.         dev->authorized = 1;//hub 默认；
     
112.     else {
     
113.         dev->authorized = usb_hcd->authorized_default;
     
114.         dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;
     
115.     }
     
116.     return dev;
     
117. }

函数三

点击(此处)折叠或打开

1. /**
   
2. * register_root_hub - called by usb_add_hcd() to register a root hub
   
3. * @hcd: host controller for this root hub
   
4. *
   
5. * This function registers the root hub with the USB subsystem. It sets up
   
6. * the device properly in the device tree and then calls usb_new_device()
   
7. * to register the usb device. It also assigns the root hub's USB address
   
8. * (always 1).
   
9. */
   
10. static int register_root_hub(struct usb_hcd *hcd)
    
11. {
    
12.     struct device *parent_dev = hcd->self.controller;
    
13.     struct usb_device *usb_dev = hcd->self.root_hub;
    
14.     const int devnum = 1;
    
15.     int retval;
    
16. 
    
17.     usb_dev->devnum = devnum;
    
18.     usb_dev->bus->devnum_next = devnum + 1;
    
19.     memset (&usb_dev->bus->devmap.devicemap, 0,
    
20.             sizeof usb_dev->bus->devmap.devicemap);
    
21.     set_bit (devnum, usb_dev->bus->devmap.devicemap);
    
22. //作为usb设备状态，第二种:USB_STATE_ADDRESS
    
23.     usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
    
24. 
    
25.     mutex_lock(&usb_bus_list_lock);
    
26. 
    
27.     usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
    
28. //usb_get_descriptor--usb_control_msg--usb_start_wait_urb--usb_hcd_submit_urb--rh_urb_enqueue
    
29. //其实只知道一点就好了，roothub的描述符都是不需要控制器帮忙的，
    
30. //自带的；hub.c中有列出来；
    
31.     retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
    
32.     if (retval != sizeof usb_dev->descriptor) {
    
33.         mutex_unlock(&usb_bus_list_lock);
    
34.         dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
    
35.                 dev_name(&usb_dev->dev), retval);
    
36.         return (retval < 0) ? retval : -EMSGSIZE;
    
37.     }
    
38. //这里面就是很熟悉的代码了
    
39. //device_add(dev);
    
40.     retval = usb_new_device (usb_dev);
    
41.     if (retval) {
    
42.         dev_err (parent_dev, "can't register root hub for %s, %d\n",
    
43.                 dev_name(&usb_dev->dev), retval);
    
44.     }
    
45.     mutex_unlock(&usb_bus_list_lock);
    
46. 
    
47.     if (retval == 0) {
    
48.         spin_lock_irq (&hcd_root_hub_lock);
    
49.         hcd->rh_registered = 1;
    
50.         spin_unlock_irq (&hcd_root_hub_lock);
    
51. 
    
52.         /* Did the HC die before the root hub was registered? */
    
53.         if (hcd->state == HC_STATE_HALT)
    
54.             usb_hc_died (hcd);    /* This time clean up */
    
55.     }
    
56. 
    
57.     return retval;
    
58. }

   hub的设备出生后，就要找驱动；哪里找呢？看关键字<usb_device_type,for_devices>
看代码很多后，才发现，所谓usb驱动分为接口驱动和设备驱动，大多时候，网友口口相传驱动都指定为接口驱动；而我们这里讲的是设备驱动，据我对代码的查看，在usb hub驱动时找到一例；至于其他地方，我们不要去理会了，少则得，多则惑；

     后来，我界定，这种驱动还只是属于设备创建的一部分，它只是创建接口设备；
代码的起始点：retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);

点击(此处)折叠或打开

1. struct usb_device_driver usb_generic_driver = {
   
2.     .name = "usb",
   
3.     .probe = generic_probe,
   
4.     .disconnect = generic_disconnect,
   
5. #ifdef    CONFIG_PM
   
6.     .suspend = generic_suspend,
   
7.     .resume = generic_resume,
   
8. #endif
   
9.     .supports_autosuspend = 1,
   
10. }

 

点击(此处)折叠或打开

1. /**
   
2. * usb_register_device_driver - register a USB device (not interface) driver
   
3. * @new_udriver: USB operations for the device driver
   
4. * @owner: module owner of this driver.
   
5. *
   
6. * Registers a USB device driver with the USB core. The list of
   
7. * unattached devices will be rescanned whenever a new driver is
   
8. * added, allowing the new driver to attach to any recognized devices.
   
9. * Returns a negative error code on failure and 0 on success.
   
10. */
    
11. int usb_register_device_driver(struct usb_device_driver *new_udriver,
    
12.         struct module *owner)
    
13. {
    
14.     int retval = 0;
    
15. 
    
16.     if (usb_disabled())
    
17.         return -ENODEV;
    
18. //对devices；主要是Mark一下，引起注意；
    
19. //在总线匹配中，区分接口设备和usb设备<usb_device_type,>；
    
20.     new_udriver->drvwrap.for_devices = 1;
    
21.     new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
    
22.     new_udriver->drvwrap.driver.bus = &usb_bus_type;//所属总线；
    
23.     new_udriver->drvwrap.driver.probe = usb_probe_device;
    
24.     new_udriver->drvwrap.driver.remove = usb_unbind_device;
    
25.     new_udriver->drvwrap.driver.owner = owner;
    
26. //通用设备驱动的注册
    
27.     retval = driver_register(&new_udriver->drvwrap.driver);
    
28. 
    
29.     if (!retval) {
    
30.         pr_info("%s: registered new device driver %s\n",
    
31.             usbcore_name, new_udriver->name);
    
32.         usbfs_update_special();
    
33.     } else {
    
34.         printk(KERN_ERR "%s: error %d registering device "
    
35.             "    driver %s\n",
    
36.             usbcore_name, retval, new_udriver->name);
    
37.     }
    
38. 
    
39.     return retval;
    
40. }

上面就是usb设备类型的驱动，只要是满足{usb_device_type,for_devices==1}的设备，都会来找他配对；然后生出{usb_if_device_type,for_devices==0}这样的设备；
usb_device_type，usb_if_device_type为usb设备的类型，用来总线匹配驱动。for_devices是驱动中设置，用来总线匹配匹配。
需要牢记一点，出生的设备最新还是需要在那根红线usb_bus_type上仔细找usb_device_match驱动usb_generic_driver；
usb hub 3 驱动的匹配：
只要是驱动，必然有一个标准的方式

按照驱动套路：
driver_register-->bus_add_driver-->driver_attach-->__driver_attach-->，(关键位置出来了，总线匹配)
-->driver_probe_device-->drv->probe==驱动(usb_probe_device）-->udriver->probe==通用驱动(generic_probe)。

驱动查找：

点击(此处)折叠或打开

1. static int __driver_attach(struct device *dev, void *data)
   
2. {
   
3.     struct device_driver *drv = data;
   
4. 
   
5. 
   
6. //这个时候就是总线找设备:usb_device_match，和
   
7. //看之前的关键字关键字<usb_device_type,for_devices>
   
8. 
   
9.     if (!driver_match_device(drv, dev))//总线匹配；见代码注释
   
10.         return 0;
    
11. 
    
12.     if (dev->parent) /* Needed for USB */
    
13.         down(&dev->parent->sem);
    
14.     down(&dev->sem);
    
15.     if (!dev->driver)
    
16.         driver_probe_device(drv, dev);//最终会调用的函数driver_probe_device；
    
17.     up(&dev->sem);
    
18.     if (dev->parent)
    
19.         up(&dev->parent->sem);
    
20. 
    
21.     return 0;
    
22. }

//总线匹配：

点击(此处)折叠或打开

1. static int usb_device_match(struct device *dev, struct device_driver *drv)
   
2. {
   
3.     /* devices and interfaces are handled separately */
   
4.     if (is_usb_device(dev)) {//设备驱动的路口<usb_device_type>
   
5. 
   
6.         /* interface drivers never match devices */
   
7. //这里需要看usb.c里面的.
   
8. //匹配到usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
   
9.         if (!is_usb_device_driver(drv))//路口字<for_devices>
   
10.             return 0;
    
11. 
    
12.         /* TODO: Add real matching code */
    
13.         return 1;//这里就告诉我们，这是usb_device_type,且for_devices==1;
    
14. 
    
15.     } else if (is_usb_interface(dev)) {//接口设备的路口,后面再来弄；
    
16.         struct usb_interface *intf;
    
17.         struct usb_driver *usb_drv;
    
18.         const struct usb_device_id *id;
    
19. 
    
20.         /* device drivers never match interfaces */
    
21.         if (is_usb_device_driver(drv))
    
22.             return 0;
    
23. 
    
24.         intf = to_usb_interface(dev);
    
25.         usb_drv = to_usb_driver(drv);
    
26. 
    
27.         id = usb_match_id(intf, usb_drv->id_table);
    
28.         if (id)
    
29.             return 1;
    
30. 
    
31.         id = usb_match_dynamic_id(intf, usb_drv);
    
32.         if (id)
    
33.             return 1;
    
34.     }
    
35. 
    
36.     return 0;
    
37. }
    
38. 
    
39. //device的探测函数
    
40. static int usb_probe_device(struct device *dev)
    
41. {
    
42.     struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
    
43.     struct usb_device *udev = to_usb_device(dev);
    
44.     int error = -ENODEV;
    
45. 
    
46.     dev_dbg(dev, "%s\n", __func__);
    
47. 
    
48.     /* TODO: Add real matching code */
    
49. 
    
50.     /* The device should always appear to be in use
    
51.      * unless the driver suports autosuspend.
    
52.      */
    
53.     udev->pm_usage_cnt = !(udriver->supports_autosuspend);
    
54. 
    
55.     error = udriver->probe(udev);//usb_driver，回到通用驱动usb_generic_driver
    
56.     return error;
    
57. }

//通用驱动探测

点击(此处)折叠或打开

1. static int generic_probe(struct usb_device *udev)
   
2. {
   
3.     int err, c;
   
4. 
   
5.     /* Choose and set the configuration. This registers the interfaces
   
6.      * with the driver core and lets interface drivers bind to them.
   
7.      */
   
8.     if (usb_device_is_owned(udev))
   
9.         ; /* Don't configure if the device is owned */
   
10.     else if (udev->authorized == 0)
    
11.         dev_err(&udev->dev, "Device is not authorized for usage\n");
    
12.     else {
    
13.         c = usb_choose_configuration(udev);
    
14.         if (c >= 0) {
    
15. // 既然已经选好配置了,那就告诉设备选好的配置,这个过程是在usb_set_configuration()中完成的
    
16. //控制器和外设（hub）的通讯
    
17.             err = usb_set_configuration(udev, c);//这里又会生仔(设备)哟；
    
18.             if (err) {
    
19.                 dev_err(&udev->dev, "can't set config #%d, error %d\n",c, err);
    
20.                 /* This need not be fatal. The user can try to
    
21.                  * set other configurations. */
    
22.             }
    
23.         }
    
24.     }
    
25.     /* USB device state == configured ... usable */
    
26.     usb_notify_add_device(udev);
    
27. 
    
28.     return 0;
    
29. }

流程走完了；

这里完成后，整个驱动到了一个新的阶段，usb的枚举阶段的设备配置就完成；配置设备的含义==控制器讲:"你这个设备能够提供这么强大的力量，我选择一种"。
真正usb的功能驱动才刚刚开始，通常讲mass storage，webcam，包括hub的真正的驱动。

之前讲的那些驱动，都是些皮毛，还没有到肉，至少我们还没有弄明白，我们没有学会真正地控制usb；其实里面有好多的usb设备信息读取，我都漏掉，再整理的时候，找个时间再补充上每一章上去；
在用户态下编程可以通过main()的来传递命令行参数，而编写一个内核模块则通过module_param()

module_param宏是Linux 2.6内核中新增的，该宏被定义在include/linux/moduleparam.h文件中，具体定义如下

#define module_param(name, type, perm)                    module_param_named(name, name, type, perm) 其中使用了 3 个参数:要传递的参数变量名, 变量的数据类型, 以及访问参数的权限。 <<< perm参数的作用是什么？ 最后的 module_param 字段是一个权限值,表示此参数在sysfs文件系统中所对应的文件节点的属性。你应当使用 <linux/stat.h> 中定义的值. 这个值控制谁可以存取这些模块参数在 sysfs 中的表示.当perm为0时，表示此参数不存在 sysfs文件系统下对应的文件节点。 否则, 模块被加载后，在/sys/module/ 目录下将出现以此模块名命名的目录, 带有给定的权限.。 权限在include/linux/stat.h中有定义 比如： #define S_IRWXU 00700 #define S_IRUSR 00400 #define S_IWUSR 00200 #define S_IXUSR 00100 #define S_IRWXG 00070 #define S_IRGRP 00040 #define S_IWGRP 00020 #define S_IXGRP 00010 #define S_IRWXO 00007 #define S_IROTH 00004 #define S_IWOTH 00002 #define S_IXOTH 00001 使 用 S_IRUGO 作为参数可以被所有人读取, 但是不能改变; S_IRUGO|S_IWUSR 允许 root 来改变参数. 注意, 如果一个参数被 sysfs 修改, 你的模块看到的参数值也改变了, 但是你的模块没有任何其他的通知. 你应当不要使模块参数可写, 除非你准备好检测这个改变并且因而作出反应. 这个宏定义应当放在任何函数之外, 典型地是出现在源文件的前面.定义如： static char *whom = "world"; static int howmany = 1; module_param(howmany, int, S_IRUGO); module_param(whom, charp, S_IRUGO); 模块参数支持许多类型: bool invbool 一个布尔型( true 或者 false)值(相关的变量应当是 int 类型). invbool 类型颠倒了值, 所以真值变成 false, 反之亦然. charp ：一个字符指针值. 内存为用户提供的字串分配, 指针因此设置. int long short uint ulong ushort 基本的变长整型值. 以 u 开头的是无符号值. 数组参数, 用逗号间隔的列表提供的值, 模块加载者也支持. 声明一个数组参数, 使用: module_param_array(name,type,num,perm); 这里 name 是你的数组的名子(也是参数名), type 是数组元素的类型, num 是一个整型变量, perm 是通常的权限值. 如果数组参数在加载时设置, num 被设置成提供的数的个数. 模块加载者拒绝比数组能放下的多的值. 测试模块，源程序hello.c内容如下： #include <linux/init.h> #include <linux/module.h> #include <linux/moduleparam.h>        MODULE_LICENSE("Dual BSD/GPL");     static char *who= "world";             static int times = 1;       module_param(times,int,S_IRUSR);     module_param(who,charp,S_IRUSR);   static int hello_init(void)       {     int i;     for(i=0;i<times;i++)        printk(KERN_ALERT "(%d) hello, %s!\n",i,who);      return 0; } static void hello_exit(void) {     printk(KERN_ALERT"Goodbye, %s!\n",who); } module_init(hello_init); module_exit(hello_exit); 编译生成可执行文件hello 插入: # insmod hello who="world" times=5 出现5次"hello,world!"： #（1）hello,world! #（2）hello,world! #（3）hello,world! #（4）hello,world! #（5）hello,world! 卸载： # rmmod hello 出现： #Goodbye,world!