devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

usb主机控制器ehci_usb ehci "dma

作者：Monodyee | 2024-03-16 04:17:19

赞

踩

usb ehci "dma

1. 主机控制器流程图


device_add()上图和下图的连接！



关于hub_probe()内部的具体实现，详见：点击打开链接


2. echi设备注册

  1. static struct platform_device *nuc970_public_dev[] __initdata = {
  2.         &&nuc970_device_ehci,
  3. };
  1. static u64 nuc970_device_usb_ehci_dmamask = 0xffffffffUL;
  2.  
  3. static struct platform_device nuc970_device_ehci = {
  4.         .name		  = "nuc970-ehci", //平台设备名，用来与设备驱动匹配的
  5.         .id		  = -1,
  6.         .num_resources	  = ARRAY_SIZE(nuc970_ehci_resource),
  7.         .resource	  = nuc970_ehci_resource,
  8.         .dev              = {
  9.                 .dma_mask = &nuc970_device_usb_ehci_dmamask,
  10.                 .coherent_dma_mask = 0xffffffffUL
  11.         }
  12. };
  1. static struct resource nuc970_ehci_resource[] = {
  2.         [0] = { //寄存器地址
  3.                 .start = NUC970_PA_EHCI,
  4.                 .end   = NUC970_PA_EHCI + NUC970_SZ_EHCI - 1,
  5.                 .flags = IORESOURCE_MEM,
  6.         },
  7.         [1] = { //中断
  8.                 .start = IRQ_EHCI,
  9.                 .end   = IRQ_EHCI,
  10.                 .flags = IORESOURCE_IRQ,
  11.         }
  12. };

ehci设备注册：

platform_add_devices(nuc970_public_dev, ARRAY_SIZE(nuc970_public_dev));

3. echi平台驱动注册

  1. static int __init ehci_nuc970_init(void)
  2. {
  3.  
  4. 	return platform_driver_register(&ehci_hcd_nuc970_driver); //echi平台设备驱动注册
  5. }
  6.  
  7. static void __exit ehci_nuc970_cleanup(void)
  8. {
  9. 	platform_driver_unregister(&ehci_hcd_nuc970_driver); //echi平台设备驱动注销
  10.  
  11. }
  1. static struct platform_driver ehci_hcd_nuc970_driver = { //平台设备驱动
  2.  
  3.         .probe = ehci_nuc970_probe,
  4.         .remove = ehci_nuc970_remove,
  5.         .driver = {
  6.                 .name = "nuc970-ehci", //平台设备驱动名称，用来与2.中的平台设备匹配
  7.                 .owner= THIS_MODULE,
  8.         },
  9. };

当platform_device平台设备和platform_driver平台驱动注册到platform总线上时，通过设备名和设备驱动名“nuc970-echi”相匹配，最终调用ehci_nuc970_probe()探测函数，接下来我们将重点分析该函数。

4. ehci_nuc970_probe()

  1. static int ehci_nuc970_probe(struct platform_device *pdev)
  2. {
  3.         //printk("ehci_nuc970_probe()\n");
  4.         if (usb_disabled())
  5.                 return -ENODEV;
  6.  
  7.         return usb_nuc970_probe(&ehci_nuc970_hc_driver, pdev); //见下
  8. }

usb_nuc970_probe()的函数参数为平台设备和ehci主机控制器驱动ehci_nuc970_hc_driver，对应结构体如下：

  1. static const struct hc_driver ehci_nuc970_hc_driver = {
  2.         .description = hcd_name, //hcd主机控制器名称“ehci-platform”
  3.         .product_desc = "Nuvoton NUC970 EHCI Host Controller", //产品描述
  4.         .hcd_priv_size = sizeof(struct ehci_hcd), //echi主机控制器大小
  5.  
  6.         /*
  7.          * generic hardware linkage
  8.          */
  9.         .irq = ehci_irq, //echi硬件中断
  10.         .flags = HCD_USB2|HCD_MEMORY, //usb2.0 | hcd使用内存（其它就是I/O）
  11.  
  12.         /*
  13.          * basic lifecycle operations
  14.          */
  15.         .reset = ehci_init, //复位主机控制器
  16.         .start = ehci_run, //启动主机控制器
  17.  
  18.         .stop = ehci_stop, //停止主机控制器
  19.  
  20.         /*
  21.          * managing i/o requests and associated device resources
  22.          */
  23.         .urb_enqueue = ehci_urb_enqueue, //urq请求队列
  24.         .urb_dequeue = ehci_urb_dequeue, //urb释放队列
  25.         .endpoint_disable = ehci_endpoint_disable, //端点禁止
  26.  
  27.         /*
  28.          * scheduling support
  29.          */
  30.         .get_frame_number = ehci_get_frame,
  31.  
  32.         /*
  33.          * root hub support
  34.          */
  35.         .hub_status_data = ehci_hub_status_data, //获取hub状态
  36.         .hub_control = ehci_hub_control, //hub控制操作
  37. #ifdef	CONFIG_PM
  38.         .bus_suspend = ehci_bus_suspend,
  39.         .bus_resume = ehci_bus_resume,
  40. #endif
  41. };

usb_nuc970_probe()函数：

return usb_nuc970_probe(&ehci_nuc970_hc_driver, pdev);
  1. static int usb_nuc970_probe(const struct hc_driver *driver,
  2.                             struct platform_device *pdev)
  3. {
  4.         struct usb_hcd *hcd;
  5.         struct ehci_hcd *ehci;
  6.         u32  physical_map_ehci;
  7.         struct pinctrl *p;
  8.         int retval;
  9.  
  10.         if (IS_ERR(clk_get(NULL, "usbh_hclk"))) {
  11.                 printk("clk_get error!!\n");
  12.                 return -1;
  13.         }
  14.  
  15. 		/* multi-function pin select */
  16. #if defined (CONFIG_NUC970_USBH_PWR_PE)
  17.         /* set over-current active low */
  18.         __raw_writel(__raw_readl(NUC970_VA_OHCI+0x204) | 0x8, NUC970_VA_OHCI+0x204);
  19.  
  20.     	/* initial USBH_PPWR0 & USBH_PPWR1 pin -> PE.14 & PE.15 */
  21.     	p = devm_pinctrl_get_select(&pdev->dev, "usbh-ppwr-pe");
  22.     	if (IS_ERR(p))
  23.     	{
  24.         	dev_err(&pdev->dev, "unable to reserve pin\n");
  25.         	retval = PTR_ERR(p);
  26.     	}
  27. #elif defined (CONFIG_NUC970_USBH_PWR_PF)
  28.         /* set over-current active low */
  29.         __raw_writel(__raw_readl(NUC970_VA_OHCI+0x204) | 0x8, NUC970_VA_OHCI+0x204);
  30.  
  31.     	/* initial USBH_PPWR pin -> PF.10 */
  32.     	p = devm_pinctrl_get_select(&pdev->dev, "usbh-ppwr-pf");
  33.     	if (IS_ERR(p))
  34.     	{
  35.         	dev_err(&pdev->dev, "unable to reserve pin\n");
  36.         	retval = PTR_ERR(p);
  37.     	}
  38. #elif defined (CONFIG_NUC970_USBH_OC_ONLY)
  39.         /* set over-current active low */
  40.         __raw_writel(__raw_readl(NUC970_VA_OHCI+0x204) | 0x8, NUC970_VA_OHCI+0x204);
  41.  
  42.     	p = devm_pinctrl_get_select(&pdev->dev, "usbh-ppwr-oc");
  43.     	if (IS_ERR(p))
  44.     	{
  45.         	dev_err(&pdev->dev, "unable to reserve pin\n");
  46.         	retval = PTR_ERR(p);
  47.     	}
  48. #else  //  CONFIG_NUC970_USBH_NONE
  49.         /* set over-current active high */
  50.         __raw_writel(__raw_readl(NUC970_VA_OHCI+0x204) &~0x8, NUC970_VA_OHCI+0x204);
  51. #endif
  52. 		/* Enable USB Host clock */
  53.         clk_prepare(clk_get(NULL, "usb_eclk"));	
  54.         clk_enable(clk_get(NULL, "usb_eclk"));
  55.         
  56.         clk_prepare(clk_get(NULL, "usbh_hclk"));	
  57.         clk_enable(clk_get(NULL, "usbh_hclk"));
  58.  
  59.         if (pdev->resource[1].flags != IORESOURCE_IRQ) { //判定是否是中断
  60.                 pr_debug("resource[1] is not IORESOURCE_IRQ");
  61.                 retval = -ENOMEM;
  62.         }
  63.  
  64.         hcd = usb_create_hcd(driver, &pdev->dev, "nuc970-ehci"); //创建一个usb hcd主机控制器（struct usb_hcd）
  65.         if (!hcd) {
  66.                 retval = -ENOMEM;
  67.                 goto err1;
  68.         }
  69.  
  70. 		
  71. 		//赋值ehci寄存器地址
  72.         hcd->rsrc_start = pdev->resource[0].start;
  73.         hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
  74.  
  75. 		//申请内存
  76.         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
  77.                 pr_debug("ehci probe request_mem_region failed");
  78.                 retval = -EBUSY;
  79.                 goto err2;
  80.         }
  81.  
  82. 		//映射内存
  83.         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
  84.         if (hcd->regs == NULL) {
  85.                 pr_debug("ehci error mapping memory\n");
  86.                 retval = -EFAULT;
  87.                 goto err3;
  88.         }
  89.  
  90.         ehci = hcd_to_ehci(hcd);
  91.         ehci->caps = hcd->regs;
  92.         ehci->regs = hcd->regs + 0x20;
  93.  
  94.         /* enable PHY 0/1 */
  95.         physical_map_ehci = (u32)ehci->caps;
  96.         __raw_writel(0x160, physical_map_ehci+0xC4);
  97.         __raw_writel(0x520, physical_map_ehci+0xC8);
  98.  
  99.         /* cache this readonly data; minimize chip reads */
  100.         ehci->hcs_params = readl(&ehci->caps->hcs_params); //echi结构体参数寄存器
  101.         ehci->sbrn = 0x20;
  102.  
  103.         retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED); //增加主机控制器
  104.  
  105.         if (retval != 0)
  106.             goto err4;
  107.  
  108.         return retval;
  109.  
  110. err4:
  111.         iounmap(hcd->regs);
  112. err3:
  113.         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
  114. err2:
  115.         usb_put_hcd(hcd);
  116. err1:
  117.  
  118.         return retval;
  119. }

这个函数内部主要时完成一些资源的分配和初始化，我们只关注usb hcd主机控制器的创建和增加，对应的接口函数如下：

  1. hcd = usb_create_hcd(driver, &pdev->dev, "nuc970-ehci"); //创建一个usb hcd主机控制器（struct usb_hcd）
  2.  
  3. retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED); //增加主机控制器

这里我们将逐个分析。

5. usb主机控制器创建

  1. struct usb_hcd *usb_create_hcd(const struct hc_driver *driver,
  2. 		struct device *dev, const char *bus_name)
  3. {
  4. 	return usb_create_shared_hcd(driver, dev, bus_name, NULL); //创建一个共享的USB hcd控制器
  5. }
  6. EXPORT_SYMBOL_GPL(usb_create_hcd);
  1. struct usb_hcd *usb_create_shared_hcd(const struct hc_driver *driver,
  2. 		struct device *dev, const char *bus_name,
  3. 		struct usb_hcd *primary_hcd)
  4. {
  5. 	struct usb_hcd *hcd;
  6.  
  7. 	hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL); //分配一个usb hcd主机控制器
  8. 	if (!hcd) {
  9. 		dev_dbg (dev, "hcd alloc failed\n");
  10. 		return NULL;
  11. 	}
  12.  
  13. 	//分配"带宽"互斥锁，干啥用的，忘了！！！
  14. 	if (primary_hcd == NULL) { //=NULL，为真
  15. 		hcd->bandwidth_mutex = kmalloc(sizeof(*hcd->bandwidth_mutex),
  16. 				GFP_KERNEL);
  17. 		if (!hcd->bandwidth_mutex) {
  18. 			kfree(hcd);
  19. 			dev_dbg(dev, "hcd bandwidth mutex alloc failed\n");
  20. 			return NULL;
  21. 		}
  22. 		mutex_init(hcd->bandwidth_mutex);
  23. 		dev_set_drvdata(dev, hcd); //将usb hcd绑定为设备的私有数据
  24. 	} else {
  25. 		hcd->bandwidth_mutex = primary_hcd->bandwidth_mutex;
  26. 		hcd->primary_hcd = primary_hcd;
  27. 		primary_hcd->primary_hcd = primary_hcd;
  28. 		hcd->shared_hcd = primary_hcd;
  29. 		primary_hcd->shared_hcd = hcd;
  30. 	}
  31.  
  32. 	kref_init(&hcd->kref);
  33.  
  34. 	usb_bus_init(&hcd->self); //usb-hcd 作为一个总线初始化
  35. 	hcd->self.controller = dev; //绑定设备,对应platform_device
  36. 	hcd->self.bus_name = bus_name; //usb-hcd总线名称“nuc970-ehci”
  37. 	hcd->self.uses_dma = (dev->dma_mask != NULL); //主机控制器是否使用DMA,通过platfrom_device知道dev->dma_mask=0xffff
  38.  
  39. 	init_timer(&hcd->rh_timer); //初始化一个root-hub定时器
  40. 	hcd->rh_timer.function = rh_timer_func; //绑定定时器超时的回调函数
  41. 	hcd->rh_timer.data = (unsigned long) hcd; //回调函数的参数为usb-hcd主机控制器
  42. #ifdef CONFIG_PM_RUNTIME
  43. 	INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
  44. #endif
  45.  
  46. 	hcd->driver = driver; //usb-hcd主机控制器绑定主机控制器驱动driver
  47. 	hcd->speed = driver->flags & HCD_MASK; //获取主机控制器速率
  48. 	hcd->product_desc = (driver->product_desc) ? driver->product_desc : //初始化主机控制器的产品描述符
  49. 			"USB Host Controller";
  50. 	return hcd;
  51. }

该函数内部主要分配了一个usb-hcd主机控制器，初始化主机控制器root-hub的一个定时器回调函数，最后将主机控制器驱动hcd_driver绑定到usb-hcd主机控制器上，这里要区分他们的关系:

a> struct usb_hcd usb主机控制器

b> struct hc_driver 主机控制器驱动

c> struct usb_bus self 总线

d> struct usb_device *rhdev 设备

6. usb主机控制器添加

retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED); //增加主机控制器
  1. int usb_add_hcd(struct usb_hcd *hcd,
  2. 		unsigned int irqnum, unsigned long irqflags)
  3. {
  4. 	int retval;
  5. 	struct usb_device *rhdev;
  6.  
  7. 	dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
  8.  
  9. 	/* Keep old behaviour if authorized_default is not in [0, 1]. */
  10. 	/*authorized_default
  11. 	的三种设备状态
  12. 		-1 表示认证无线之外的所有设备
  13. 		 0 表示不认证任何设备
  14. 		 1 表示认证所有设备
  15. 	*/
  16. 	if (authorized_default < 0 || authorized_default > 1)
  17. 		hcd->authorized_default = hcd->wireless? 0 : 1;
  18. 	else
  19. 		hcd->authorized_default = authorized_default;
  20. 	set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); //设置usb-hcd的状态标识为“上电”
  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) { //创建一个DMA缓冲池
  27. 		dev_dbg(hcd->self.controller, "pool alloc failed\n");
  28. 		return retval;
  29. 	}
  30.  
  31. 	if ((retval = usb_register_bus(&hcd->self)) < 0) //注册一个usb-bus
  32. 		goto err_register_bus;
  33.  
  34. 	if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) { //分配一个usb设备，作为root_hub
  35. 		dev_err(hcd->self.controller, "unable to allocate root hub\n");
  36. 		retval = -ENOMEM;
  37. 		goto err_allocate_root_hub;
  38. 	}
  39. 	hcd->self.root_hub = rhdev;
  40.  
  41. 	switch (hcd->speed) {
  42. 	case HCD_USB11:
  43. 		rhdev->speed = USB_SPEED_FULL;
  44. 		break;
  45. 	case HCD_USB2:
  46. 		rhdev->speed = USB_SPEED_HIGH;
  47. 		break;
  48. 	case HCD_USB3:
  49. 		rhdev->speed = USB_SPEED_SUPER;
  50. 		break;
  51. 	default:
  52. 		retval = -EINVAL;
  53. 		goto err_set_rh_speed;
  54. 	}
  55.  
  56. 	/* wakeup flag init defaults to "everything works" for root hubs,
  57. 	 * but drivers can override it in reset() if needed, along with
  58. 	 * recording the overall controller's system wakeup capability.
  59. 	 */
  60. 	device_set_wakeup_capable(&rhdev->dev, 1);
  61.  
  62. 	/* HCD_FLAG_RH_RUNNING doesn't matter until the root hub is
  63. 	 * registered.  But since the controller can die at any time,
  64. 	 * let's initialize the flag before touching the hardware.
  65. 	 */
  66. 	set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
  67.  
  68. 	/* "reset" is misnamed; its role is now one-time init. the controller
  69. 	 * should already have been reset (and boot firmware kicked off etc).
  70. 	 */
  71. 	if (hcd->driver->reset && (retval = hcd->driver->reset(hcd)) < 0) {
  72. 		dev_err(hcd->self.controller, "can't setup\n");
  73. 		goto err_hcd_driver_setup;
  74. 	}
  75. 	hcd->rh_pollable = 1;
  76.  
  77. 	/* NOTE: root hub and controller capabilities may not be the same */
  78. 	if (device_can_wakeup(hcd->self.controller)
  79. 			&& device_can_wakeup(&hcd->self.root_hub->dev))
  80. 		dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
  81.  
  82. 	/* enable irqs just before we start the controller,
  83. 	 * if the BIOS provides legacy PCI irqs.
  84. 	 */
  85. 	if (usb_hcd_is_primary_hcd(hcd) && irqnum) {
  86. 		retval = usb_hcd_request_irqs(hcd, irqnum, irqflags); //申请中断
  87. 		if (retval)
  88. 			goto err_request_irq;
  89. 	}
  90.  
  91. 	hcd->state = HC_STATE_RUNNING;
  92. 	retval = hcd->driver->start(hcd); //.start = ehci_run
  93. 	if (retval < 0) {
  94. 		dev_err(hcd->self.controller, "startup error %d\n", retval);
  95. 		goto err_hcd_driver_start;
  96. 	}
  97.  
  98. 	/* starting here, usbcore will pay attention to this root hub */
  99. 	if ((retval = register_root_hub(hcd)) != 0)
  100. 		goto err_register_root_hub;
  101.  
  102. 	retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
  103. 	if (retval < 0) {
  104. 		printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
  105. 		       retval);
  106. 		goto error_create_attr_group;
  107. 	}
  108. 	if (hcd->uses_new_polling && HCD_POLL_RH(hcd))
  109. 		usb_hcd_poll_rh_status(hcd);
  110.  
  111. 	/*
  112. 	 * Host controllers don't generate their own wakeup requests;
  113. 	 * they only forward requests from the root hub.  Therefore
  114. 	 * controllers should always be enabled for remote wakeup.
  115. 	 */
  116. 	device_wakeup_enable(hcd->self.controller);
  117. 	return retval;
  118.  
  119. error_create_attr_group:
  120. 	clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
  121. 	if (HC_IS_RUNNING(hcd->state))
  122. 		hcd->state = HC_STATE_QUIESCING;
  123. 	spin_lock_irq(&hcd_root_hub_lock);
  124. 	hcd->rh_registered = 0;
  125. 	spin_unlock_irq(&hcd_root_hub_lock);
  126.  
  127. #ifdef CONFIG_PM_RUNTIME
  128. 	cancel_work_sync(&hcd->wakeup_work);
  129. #endif
  130. 	mutex_lock(&usb_bus_list_lock);
  131. 	usb_disconnect(&rhdev);		/* Sets rhdev to NULL */
  132. 	mutex_unlock(&usb_bus_list_lock);
  133. err_register_root_hub:
  134. 	hcd->rh_pollable = 0;
  135. 	clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
  136. 	del_timer_sync(&hcd->rh_timer);
  137. 	hcd->driver->stop(hcd);
  138. 	hcd->state = HC_STATE_HALT;
  139. 	clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
  140. 	del_timer_sync(&hcd->rh_timer);
  141. err_hcd_driver_start:
  142. 	if (usb_hcd_is_primary_hcd(hcd) && hcd->irq > 0)
  143. 		free_irq(irqnum, hcd);
  144. err_request_irq:
  145. err_hcd_driver_setup:
  146. err_set_rh_speed:
  147. 	usb_put_dev(hcd->self.root_hub);
  148. err_allocate_root_hub:
  149. 	usb_deregister_bus(&hcd->self);
  150. err_register_bus:
  151. 	hcd_buffer_destroy(hcd);
  152. 	return retval;
  153. } 
  154. EXPORT_SYMBOL_GPL(usb_add_hcd);

usb-hcd主机控制器添加，主要完成以下几点：

1> hcd_buffer_create(hcd) 创建一个hcd DMA池；

2> usb_register_bus(&hcd->self) 注册一个usb总线；

3> usb_alloc_dev(NULL, &hcd->self, 0) 分配一个usb-device设备；

4> usb_hcd_request_irqs(hcd, irqnum, irqflags)申请一个hcd中断定时器；

5> register_root_hub(hcd)注册一个root-hub。

这里将逐个分析：

5.1 hcd_buffer_create()

创建DMA池：

hcd_buffer_create()--> dma_pool_create()-->device_create_file(dev, &dev_attr_pools)

static DEVICE_ATTR(pools, S_IRUGO, show_pools, NULL);
  1. static ssize_t
  2. show_pools(struct device *dev, struct device_attribute *attr, char *buf)
  3. {
  4. 	unsigned temp;
  5. 	unsigned size;
  6. 	char *next;
  7. 	struct dma_page *page;
  8. 	struct dma_pool *pool;
  9.  
  10. 	next = buf;
  11. 	size = PAGE_SIZE;
  12.  
  13. 	temp = scnprintf(next, size, "poolinfo - 0.1\n");
  14. 	size -= temp;
  15. 	next += temp;
  16.  
  17. 	mutex_lock(&pools_lock);
  18. 	list_for_each_entry(pool, &dev->dma_pools, pools) {
  19. 		unsigned pages = 0;
  20. 		unsigned blocks = 0;
  21.  
  22. 		spin_lock_irq(&pool->lock);
  23. 		list_for_each_entry(page, &pool->page_list, page_list) {
  24. 			pages++;
  25. 			blocks += page->in_use;
  26. 		}
  27. 		spin_unlock_irq(&pool->lock);
  28.  
  29. 		/* per-pool info, no real statistics yet */
  30. 		temp = scnprintf(next, size, "%-16s %4u %4Zu %4Zu %2u\n",
  31. 				 pool->name, blocks,
  32. 				 pages * (pool->allocation / pool->size),
  33. 				 pool->size, pages);
  34. 		size -= temp;
  35. 		next += temp;
  36. 	}
  37. 	mutex_unlock(&pools_lock);
  38.  
  39. 	return PAGE_SIZE - size;
  40. }

在终端上执行: cat pools命令调用上面的show_pools()，打印如下信息：

  1. [root@szclou /sys/devices/platform/nuc970-ehci]#cat pools 
  2. poolinfo - 0.1
  3. ehci_sitd           0    0   96  0
  4. ehci_itd            0    0  160  0
  5. ehci_qh             1   42   96  1
  6. ehci_qtd            1   42   96  1
  7. buffer-2048         0    0 2048  0
  8. buffer-512          0    0  512  0
  9. buffer-128          0    0  128  0
  10. buffer-32           0    0   32  0

至此，属性文件的操作就是用来显示这些信息的，再看一个usb-root信息

dev->dev.groups = usb_device_groups;

其中dev->dev.groups类型为

const struct attribute_group **groups
  1. const struct attribute_group *usb_device_groups[] = {
  2. 	&dev_attr_grp, //属性组信息
  3. 	&dev_string_attr_grp, //属性字符串组
  4. 	NULL
  5. };
  1. static struct attribute_group dev_attr_grp = {
  2. 	.attrs = dev_attrs,
  3. };
  1. static struct attribute *dev_attrs[] = {
  2. 	/* current configuration's attributes */
  3. 	&dev_attr_configuration.attr,
  4. 	&dev_attr_bNumInterfaces.attr,
  5. 	&dev_attr_bConfigurationValue.attr,
  6. 	&dev_attr_bmAttributes.attr,
  7. 	&dev_attr_bMaxPower.attr,
  8. 	/* device attributes */
  9. 	&dev_attr_urbnum.attr,
  10. 	&dev_attr_idVendor.attr,
  11. 	&dev_attr_idProduct.attr,
  12. 	&dev_attr_bcdDevice.attr,
  13. 	&dev_attr_bDeviceClass.attr,
  14. 	&dev_attr_bDeviceSubClass.attr,
  15. 	&dev_attr_bDeviceProtocol.attr,
  16. 	&dev_attr_bNumConfigurations.attr,
  17. 	&dev_attr_bMaxPacketSize0.attr,
  18. 	&dev_attr_speed.attr,
  19. 	&dev_attr_busnum.attr,
  20. 	&dev_attr_devnum.attr,
  21. 	&dev_attr_devpath.attr,
  22. 	&dev_attr_version.attr,
  23. 	&dev_attr_maxchild.attr,
  24. 	&dev_attr_quirks.attr,
  25. 	&dev_attr_avoid_reset_quirk.attr,
  26. 	&dev_attr_authorized.attr,
  27. 	&dev_attr_remove.attr,
  28. 	&dev_attr_removable.attr,
  29. 	&dev_attr_ltm_capable.attr,
  30. 	NULL,
  31. };

  1. static struct attribute_group dev_string_attr_grp = {
  2. 	.attrs =	dev_string_attrs,
  3. 	.is_visible =	dev_string_attrs_are_visible,
  4. };
  1. static struct attribute *dev_string_attrs[] = {
  2. 	&dev_attr_manufacturer.attr,
  3. 	&dev_attr_product.attr,
  4. 	&dev_attr_serial.attr,
  5. 	NULL
  6. };

*dev_string_attrs[] 和 *dev_attrs[]对应系统目录结构信息为：

  1. [root@szclou /sys/devices/platform/nuc970-ehci/usb1]#ls
  2. 1-0:1.0              bmAttributes         maxchild
  3. authorized           busnum               product
  4. authorized_default   configuration        quirks
  5. avoid_reset_quirk    descriptors          removable
  6. bConfigurationValue  dev                  remove
  7. bDeviceClass         devnum               serial
  8. bDeviceProtocol      devpath              speed
  9. bDeviceSubClass      driver               subsystem
  10. bMaxPacketSize0      ep_00                uevent
  11. bMaxPower            idProduct            urbnum
  12. bNumConfigurations   idVendor             version
  13. bNumInterfaces       ltm_capable
  14. bcdDevice            manufacturer

5.2 usb_register_bus()

  1. static int usb_register_bus(struct usb_bus *bus)
  2. {
  3. 	int result = -E2BIG;
  4. 	int busnum;
  5.  
  6. 	mutex_lock(&usb_bus_list_lock);
  7. 	busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
  8. 	if (busnum >= USB_MAXBUS) {
  9. 		printk (KERN_ERR "%s: too many buses\n", usbcore_name);
  10. 		goto error_find_busnum;
  11. 	}
  12. 	set_bit (busnum, busmap.busmap);
  13. 	bus->busnum = busnum;
  14.  
  15. 	/* Add it to the local list of buses */
  16. 	list_add (&bus->bus_list, &usb_bus_list); //将当前usb总线添加到usb_bus_list链表中
  17. 	mutex_unlock(&usb_bus_list_lock);
  18.  
  19. 	usb_notify_add_bus(bus);
  20.  
  21. 	dev_info (bus->controller, "new USB bus registered, assigned bus "
  22. 		  "number %d\n", bus->busnum);
  23. 	return 0;
  24.  
  25. error_find_busnum:
  26. 	mutex_unlock(&usb_bus_list_lock);
  27. 	return result;
  28. }

5.3 usb_alloc_dev()

  1. 	if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) { //分配一个usb设备，作为root_hub
  2. 		dev_err(hcd->self.controller, "unable to allocate root hub\n");
  3. 		retval = -ENOMEM;
  4. 		goto err_allocate_root_hub;
  5. 	}
  6. 	hcd->self.root_hub = rhdev; //如果上面usb设备分配成功，将作为hcd主机控制器的根设备
  1. struct usb_device *usb_alloc_dev(struct usb_device *parent,
  2. 				 struct usb_bus *bus, unsigned port1)
  3. {
  4. 	struct usb_device *dev;
  5. 	struct usb_hcd *usb_hcd = bus_to_hcd(bus);
  6. 	unsigned root_hub = 0;
  7.  
  8. 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
  9. 	if (!dev)
  10. 		return NULL;
  11.  
  12. 	if (!usb_get_hcd(usb_hcd)) {
  13. 		kfree(dev);
  14. 		return NULL;
  15. 	}
  16. 	/* Root hubs aren't true devices, so don't allocate HCD resources */
  17. 	if (usb_hcd->driver->alloc_dev && parent &&
  18. 		!usb_hcd->driver->alloc_dev(usb_hcd, dev)) {
  19. 		usb_put_hcd(bus_to_hcd(bus));
  20. 		kfree(dev);
  21. 		return NULL;
  22. 	}
  23.  
  24. 	device_initialize(&dev->dev);
  25. 	dev->dev.bus = &usb_bus_type; //绑定设备的总线为“usb”
  26. 	dev->dev.type = &usb_device_type; //设备的类型
  27. 	dev->dev.groups = usb_device_groups; //对sysfs文件系统的属性文件操作，上面有对usb_device_groups分析
  28. 	dev->dev.dma_mask = bus->controller->dma_mask;
  29. 	set_dev_node(&dev->dev, dev_to_node(bus->controller));
  30. 	dev->state = USB_STATE_ATTACHED; //设置usb状态为绑定
  31. 	dev->lpm_disable_count = 1;
  32. 	atomic_set(&dev->urbnum, 0);
  33.  
  34. 	INIT_LIST_HEAD(&dev->ep0.urb_list);
  35. 	dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE; //设置断点长度
  36. 	dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT; //设置端点描述符
  37. 	/* ep0 maxpacket comes later, from device descriptor */
  38. 	usb_enable_endpoint(dev, &dev->ep0, false);
  39. 	dev->can_submit = 1;
  40.  
  41. 	/* Save readable and stable topology id, distinguishing devices
  42. 	 * by location for diagnostics, tools, driver model, etc.  The
  43. 	 * string is a path along hub ports, from the root.  Each device's
  44. 	 * dev->devpath will be stable until USB is re-cabled, and hubs
  45. 	 * are often labeled with these port numbers.  The name isn't
  46. 	 * as stable:  bus->busnum changes easily from modprobe order,
  47. 	 * cardbus or pci hotplugging, and so on.
  48. 	 */
  49. 	if (unlikely(!parent)) {
  50. 		dev->devpath[0] = '0';
  51. 		dev->route = 0;
  52.  
  53. 		dev->dev.parent = bus->controller;
  54. 		dev_set_name(&dev->dev, "usb%d", bus->busnum);
  55. 		root_hub = 1;
  56. 	} else {
  57. 		/* match any labeling on the hubs; it's one-based */
  58. 		if (parent->devpath[0] == '0') {
  59. 			snprintf(dev->devpath, sizeof dev->devpath,
  60. 				"%d", port1);
  61. 			/* Root ports are not counted in route string */
  62. 			dev->route = 0;
  63. 		} else {
  64. 			snprintf(dev->devpath, sizeof dev->devpath,
  65. 				"%s.%d", parent->devpath, port1);
  66. 			/* Route string assumes hubs have less than 16 ports */
  67. 			if (port1 < 15)
  68. 				dev->route = parent->route +
  69. 					(port1 << ((parent->level - 1)*4));
  70. 			else
  71. 				dev->route = parent->route +
  72. 					(15 << ((parent->level - 1)*4));
  73. 		}
  74.  
  75. 		dev->dev.parent = &parent->dev;
  76. 		dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
  77.  
  78. 		/* hub driver sets up TT records */
  79. 	}
  80.  
  81. 	dev->portnum = port1;
  82. 	dev->bus = bus;
  83. 	dev->parent = parent;
  84. 	INIT_LIST_HEAD(&dev->filelist);
  85.  
  86. #ifdef	CONFIG_PM
  87. 	pm_runtime_set_autosuspend_delay(&dev->dev,
  88. 			usb_autosuspend_delay * 1000);
  89. 	dev->connect_time = jiffies;
  90. 	dev->active_duration = -jiffies;
  91. #endif
  92. 	if (root_hub)	/* Root hub always ok [and always wired] */
  93. 		dev->authorized = 1;
  94. 	else {
  95. 		dev->authorized = usb_hcd->authorized_default;
  96. 		dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;
  97. 	}
  98. 	return dev;
  99. }

5.4 usb_hcd_request_irqs()

在分析中断之前，先看下中断的处理流程图 



  1. 	if (usb_hcd_is_primary_hcd(hcd) && irqnum) {
  2. 		retval = usb_hcd_request_irqs(hcd, irqnum, irqflags); //申请中断
  3. 		if (retval)
  4. 			goto err_request_irq;
  5. 	}
  1. static int usb_hcd_request_irqs(struct usb_hcd *hcd,
  2. 		unsigned int irqnum, unsigned long irqflags)
  3. {
  4. 	int retval;
  5.  
  6. 	if (hcd->driver->irq) {
  7.  
  8. 		/* IRQF_DISABLED doesn't work as advertised when used together
  9. 		 * with IRQF_SHARED. As usb_hcd_irq() will always disable
  10. 		 * interrupts we can remove it here.
  11. 		 */
  12. 		if (irqflags & IRQF_SHARED)
  13. 			irqflags &= ~IRQF_DISABLED;
  14.  
  15. 		snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
  16. 				hcd->driver->description, hcd->self.busnum);
  17. 		retval = request_irq(irqnum, &usb_hcd_irq, irqflags, //usb_hcd_irq()函数内部将调用hcd->driver->irq(hcd)
  18. 				hcd->irq_descr, hcd);
  19. 		if (retval != 0) {
  20. 			dev_err(hcd->self.controller,
  21. 					"request interrupt %d failed\n",
  22. 					irqnum);
  23. 			return retval;
  24. 		}
  25. 		hcd->irq = irqnum;
  26. 		dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
  27. 				(hcd->driver->flags & HCD_MEMORY) ?
  28. 					"io mem" : "io base",
  29. 					(unsigned long long)hcd->rsrc_start);
  30. 	} else {
  31. 		hcd->irq = 0;
  32. 		if (hcd->rsrc_start)
  33. 			dev_info(hcd->self.controller, "%s 0x%08llx\n",
  34. 					(hcd->driver->flags & HCD_MEMORY) ?
  35. 					"io mem" : "io base",
  36. 					(unsigned long long)hcd->rsrc_start);
  37. 	}
  38. 	return 0;
  39. }

5.5 register_root_hub()

  1. 	if ((retval = register_root_hub(hcd)) != 0)
  2. 		goto err_register_root_hub;
  1. static int register_root_hub(struct usb_hcd *hcd)
  2. {
  3. 	struct device *parent_dev = hcd->self.controller;
  4. 	struct usb_device *usb_dev = hcd->self.root_hub;
  5. 	const int devnum = 1;
  6. 	int retval;
  7.  
  8. 	usb_dev->devnum = devnum; //设备编号
  9. 	usb_dev->bus->devnum_next = devnum + 1; //下一个要打开的设备编号
  10. 	memset (&usb_dev->bus->devmap.devicemap, 0,
  11. 			sizeof usb_dev->bus->devmap.devicemap);
  12. 	set_bit (devnum, usb_dev->bus->devmap.devicemap); //设备编号屏蔽字
  13. 	usb_set_device_state(usb_dev, USB_STATE_ADDRESS); //设置usb设备状态，当前为USB_STATE_ADDRESS
  14.  
  15. 	mutex_lock(&usb_bus_list_lock);
  16.  
  17. 	usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16(64); //给端点0描述符分配64个字节长度空间
  18. 	retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE); //获取设备描述符，包括配置，接口，端点
  19. 	if (retval != sizeof usb_dev->descriptor) {
  20. 		mutex_unlock(&usb_bus_list_lock);
  21. 		dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
  22. 				dev_name(&usb_dev->dev), retval);
  23. 		return (retval < 0) ? retval : -EMSGSIZE;
  24. 	}
  25. 	if (usb_dev->speed == USB_SPEED_SUPER) { //usb3.0,暂时不分析
  26. 		retval = usb_get_bos_descriptor(usb_dev);
  27. 		if (retval < 0) {
  28. 			mutex_unlock(&usb_bus_list_lock);
  29. 			dev_dbg(parent_dev, "can't read %s bos descriptor %d\n",
  30. 					dev_name(&usb_dev->dev), retval);
  31. 			return retval;
  32. 		}
  33. 	}
  34.  
  35. 	retval = usb_new_device (usb_dev); //新建一个usb设备
  36. 	if (retval) {
  37. 		dev_err (parent_dev, "can't register root hub for %s, %d\n",
  38. 				dev_name(&usb_dev->dev), retval);
  39. 	} else {
  40. 		spin_lock_irq (&hcd_root_hub_lock);
  41. 		hcd->rh_registered = 1;
  42. 		spin_unlock_irq (&hcd_root_hub_lock);
  43.  
  44. 		/* Did the HC die before the root hub was registered? */
  45. 		if (HCD_DEAD(hcd))
  46. 			usb_hc_died (hcd);	/* This time clean up */
  47. 	}
  48. 	mutex_unlock(&usb_bus_list_lock);
  49.  
  50. 	return retval;
  51. }

该函数主要完成的工作时给usb设备分配一个编号（范围1~127），获取设备描述符usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE)，这里使用了一个技巧，因为不知道设备描述符里面有多少个配置，配置里有多少个接口，所以这里直接读取USB_DT_DEVICE_SIZE个字节，而这个字节的长度恰好对应设备描述符的结构体成员长度，如下：

  1. /* USB_DT_DEVICE: Device descriptor */
  2. struct usb_device_descriptor {  
  3.     __u8  bLength;//设备描述符的字节数大小，为0x12   
  4.     __u8  bDescriptorType;//描述符类型编号，为0x01   
  5.   
  6.     __le16 bcdUSB;//USB版本号   
  7.     __u8  bDeviceClass;//USB分配的设备类代码，0x01~0xfe为标准设备类，0xff为厂商自定义类型   
  8.       
  9.     //0x00不是在设备描述符中定义的，如HID   
  10.     __u8  bDeviceSubClass;//usb分配的子类代码，同上，值由USB规定和分配的  
  11.     __u8  bDeviceProtocol;//USB分配的设备协议代码，同上   
  12.     __u8  bMaxPacketSize0;//端点0的最大包的大小   
  13.     __le16 idVendor;//厂商编号   
  14.     __le16 idProduct;//产品编号   
  15.     __le16 bcdDevice;//设备出厂编号  
  16.     __u8  iManufacturer;//描述厂商字符串的索引   
  17.     __u8  iProduct;//描述产品字符串的索引  
  18.     __u8  iSerialNumber;//描述设备序列号字符串的索引   
  19.     __u8  bNumConfigurations;//可能的配置数量  
  20. } __attribute__ ((packed));

再后续时创建了一个新的usb设备，下面将详细分析。

5.6 usb_new_device

先贴出流程图 

retval = usb_new_device (usb_dev); //新建一个usb设备
  1. int usb_new_device(struct usb_device *udev)
  2. {
  3. 	int err;
  4.  
  5. 	if (udev->parent) {
  6. 		/* Initialize non-root-hub device wakeup to disabled;
  7. 		 * device (un)configuration controls wakeup capable
  8. 		 * sysfs power/wakeup controls wakeup enabled/disabled
  9. 		 */
  10. 		device_init_wakeup(&udev->dev, 0);
  11. 	}
  12.  
  13. 	/* Tell the runtime-PM framework the device is active */
  14. 	pm_runtime_set_active(&udev->dev);
  15. 	pm_runtime_get_noresume(&udev->dev);
  16. 	pm_runtime_use_autosuspend(&udev->dev);
  17. 	pm_runtime_enable(&udev->dev);
  18.  
  19. 	/* By default, forbid autosuspend for all devices.  It will be
  20. 	 * allowed for hubs during binding.
  21. 	 */
  22. 	usb_disable_autosuspend(udev);
  23.  
  24. 	//枚举设备
  25. 	err = usb_enumerate_device(udev);	/* Read descriptors */
  26. 	if (err < 0)
  27. 		goto fail;
  28. 	dev_dbg(&udev->dev, "udev %d, busnum %d, minor = %d\n",
  29. 			udev->devnum, udev->bus->busnum,
  30. 			(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
  31. 	/* export the usbdev device-node for libusb */
  32. 	udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
  33. 			(((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
  34.  
  35. 	/* Tell the world! */
  36. 	announce_device(udev);
  37.  
  38. 	if (udev->serial)
  39. 		add_device_randomness(udev->serial, strlen(udev->serial));
  40. 	if (udev->product)
  41. 		add_device_randomness(udev->product, strlen(udev->product));
  42. 	if (udev->manufacturer)
  43. 		add_device_randomness(udev->manufacturer,
  44. 				      strlen(udev->manufacturer));
  45.  
  46. 	device_enable_async_suspend(&udev->dev);
  47.  
  48. 	/*
  49. 	 * check whether the hub marks this port as non-removable. Do it
  50. 	 * now so that platform-specific data can override it in
  51. 	 * device_add()
  52. 	 */
  53. 	if (udev->parent)
  54. 		set_usb_port_removable(udev);
  55.  
  56. 	/* Register the device.  The device driver is responsible
  57. 	 * for configuring the device and invoking the add-device
  58. 	 * notifier chain (used by usbfs and possibly others).
  59. 	 */
  60. 	err = device_add(&udev->dev);
  61. 	if (err) {
  62. 		dev_err(&udev->dev, "can't device_add, error %d\n", err);
  63. 		goto fail;
  64. 	}
  65.  
  66. 	/* Create link files between child device and usb port device. */
  67. 	if (udev->parent) {
  68. 		struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
  69. 		struct usb_port	*port_dev = hub->ports[udev->portnum - 1];
  70.  
  71. 		err = sysfs_create_link(&udev->dev.kobj,
  72. 				&port_dev->dev.kobj, "port");
  73. 		if (err)
  74. 			goto fail;
  75.  
  76. 		err = sysfs_create_link(&port_dev->dev.kobj,
  77. 				&udev->dev.kobj, "device");
  78. 		if (err) {
  79. 			sysfs_remove_link(&udev->dev.kobj, "port");
  80. 			goto fail;
  81. 		}
  82.  
  83. 		pm_runtime_get_sync(&port_dev->dev);
  84. 	}
  85.  
  86. 	(void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
  87. 	usb_mark_last_busy(udev);
  88. 	pm_runtime_put_sync_autosuspend(&udev->dev);
  89. 	return err;
  90.  
  91. fail:
  92. 	usb_set_device_state(udev, USB_STATE_NOTATTACHED);
  93. 	pm_runtime_disable(&udev->dev);
  94. 	pm_runtime_set_suspended(&udev->dev);
  95. 	return err;
  96. }

这里主要分析设备枚举，是这里最核心的一个地方！！！

  1. 	//枚举设备
  2. 	err = usb_enumerate_device(udev);	/* Read descriptors */
  1. static int usb_enumerate_device(struct usb_device *udev)
  2. {
  3. 	int err;
  4.  
  5. 	if (udev->config == NULL) {
  6. 		err = usb_get_configuration(udev); //获取配置信息
  7. 		if (err < 0) {
  8. 			if (err != -ENODEV)
  9. 				dev_err(&udev->dev, "can't read configurations, error %d\n",
  10. 						err);
  11. 			return err;
  12. 		}
  13. 	}
  14.  
  15. 	/* read the standard strings and cache them if present */
  16. 	udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
  17. 	udev->manufacturer = usb_cache_string(udev,
  18. 					      udev->descriptor.iManufacturer);
  19. 	udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
  20.  
  21. 	err = usb_enumerate_device_otg(udev);
  22. 	if (err < 0)
  23. 		return err;
  24.  
  25. 	usb_detect_interface_quirks(udev);
  26.  
  27. 	return 0;
  28. }

5.6.1 获取配置信息

  1. 	if (udev->config == NULL) {
  2. 		err = usb_get_configuration(udev);
  3. 		if (err < 0) {
  4. 			if (err != -ENODEV)
  5. 				dev_err(&udev->dev, "can't read configurations, error %d\n",
  6. 						err);
  7. 			return err;
  8. 		}
  9. 	}
  1. int usb_get_configuration(struct usb_device *dev)
  2. {
  3. 	struct device *ddev = &dev->dev;
  4. 	int ncfg = dev->descriptor.bNumConfigurations; //usb配置个数
  5. 	int result = 0;
  6. 	unsigned int cfgno, length;
  7. 	unsigned char *bigbuffer;
  8. 	struct usb_config_descriptor *desc;
  9.  
  10. 	cfgno = 0;
  11. 	result = -ENOMEM;
  12. 	if (ncfg > USB_MAXCONFIG) {
  13. 		dev_warn(ddev, "too many configurations: %d, "
  14. 		    "using maximum allowed: %d\n", ncfg, USB_MAXCONFIG);
  15. 		dev->descriptor.bNumConfigurations = ncfg = USB_MAXCONFIG;
  16. 	}
  17.  
  18. 	if (ncfg < 1) {
  19. 		dev_err(ddev, "no configurations\n");
  20. 		return -EINVAL;
  21. 	}
  22.  
  23. 	length = ncfg * sizeof(struct usb_host_config);
  24. 	dev->config = kzalloc(length, GFP_KERNEL); //分配一个设备下的ncfg个config配置结构体
  25. 	if (!dev->config)
  26. 		goto err2;
  27.  
  28. 	length = ncfg * sizeof(char *);
  29. 	dev->rawdescriptors = kzalloc(length, GFP_KERNEL); //分配ncfg个char指针
  30. 	if (!dev->rawdescriptors)
  31. 		goto err2;
  32.  
  33. 	desc = kmalloc(USB_DT_CONFIG_SIZE, GFP_KERNEL);
  34. 	if (!desc)
  35. 		goto err2;
  36.  
  37. 	result = 0;
  38. 	for (; cfgno < ncfg; cfgno++) {
  39. 		/* We grab just the first descriptor so we know how long
  40. 		 * the whole configuration is */
  41. 		result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno,
  42. 		    desc, USB_DT_CONFIG_SIZE); //由于无法知道配置的长度，这里使用一个小技巧，先读取配置USB_DT_CONFIG_SIZE个字节，从该长度内部可以获取配置下的接口长度，所以这里会读取两次，这是第一次！！！
  43. 		if (result < 0) {
  44. 			dev_err(ddev, "unable to read config index %d "
  45. 			    "descriptor/%s: %d\n", cfgno, "start", result);
  46. 			if (result != -EPIPE)
  47. 				goto err;
  48. 			dev_err(ddev, "chopping to %d config(s)\n", cfgno);
  49. 			dev->descriptor.bNumConfigurations = cfgno;
  50. 			break;
  51. 		} else if (result < 4) {
  52. 			dev_err(ddev, "config index %d descriptor too short "
  53. 			    "(expected %i, got %i)\n", cfgno,
  54. 			    USB_DT_CONFIG_SIZE, result);
  55. 			result = -EINVAL;
  56. 			goto err;
  57. 		}
  58. 		length = max((int) le16_to_cpu(desc->wTotalLength), //获取当前配置的的总长度
  59. 		    USB_DT_CONFIG_SIZE);
  60.  
  61. 		/* Now that we know the length, get the whole thing */
  62. 		bigbuffer = kmalloc(length, GFP_KERNEL); 
  63. 		if (!bigbuffer) {
  64. 			result = -ENOMEM;
  65. 			goto err;
  66. 		}
  67.  
  68. 		//获取配置的所有长度信息，这里是第二次读取！！！
  69. 		result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno,
  70. 		    bigbuffer, length);
  71. 		if (result < 0) {
  72. 			dev_err(ddev, "unable to read config index %d "
  73. 			    "descriptor/%s\n", cfgno, "all");
  74. 			kfree(bigbuffer);
  75. 			goto err;
  76. 		}
  77. 		if (result < length) {
  78. 			dev_warn(ddev, "config index %d descriptor too short "
  79. 			    "(expected %i, got %i)\n", cfgno, length, result);
  80. 			length = result;
  81. 		}
  82.  
  83. 		dev->rawdescriptors[cfgno] = bigbuffer; //每一个指针指向一个配置
  84.  
  85.  
  86. 		//解析配置信息
  87. 		result = usb_parse_configuration(dev, cfgno,
  88. 		    &dev->config[cfgno], bigbuffer, length);
  89. 		if (result < 0) {
  90. 			++cfgno;
  91. 			goto err;
  92. 		}
  93. 	}
  94. 	result = 0;
  95.  
  96. err:
  97. 	kfree(desc);
  98. 	dev->descriptor.bNumConfigurations = cfgno;
  99. err2:
  100. 	if (result == -ENOMEM)
  101. 		dev_err(ddev, "out of memory\n");
  102. 	return result;
  103. }

5.6.2 解析配置信息

  1. 		//解析配置信息
  2. 		result = usb_parse_configuration(dev, cfgno,
  3. 		    &dev->config[cfgno], bigbuffer, length);
  1. static int usb_parse_configuration(struct usb_device *dev, int cfgidx,
  2.     struct usb_host_config *config, unsigned char *buffer, int size)
  3. {
  4. 	struct device *ddev = &dev->dev;
  5. 	unsigned char *buffer0 = buffer;
  6. 	int cfgno;
  7. 	int nintf, nintf_orig;
  8. 	int i, j, n;
  9. 	struct usb_interface_cache *intfc;
  10. 	unsigned char *buffer2;
  11. 	int size2;
  12. 	struct usb_descriptor_header *header;
  13. 	int len, retval;
  14. 	u8 inums[USB_MAXINTERFACES], nalts[USB_MAXINTERFACES];
  15. 	unsigned iad_num = 0;
  16.  
  17. 	memcpy(&config->desc, buffer, USB_DT_CONFIG_SIZE); //拷贝当前配置信息到config->desc
  18. 	if (config->desc.bDescriptorType != USB_DT_CONFIG ||
  19. 	    config->desc.bLength < USB_DT_CONFIG_SIZE ||
  20. 	    config->desc.bLength > size) {
  21. 		dev_err(ddev, "invalid descriptor for config index %d: "
  22. 		    "type = 0x%X, length = %d\n", cfgidx,
  23. 		    config->desc.bDescriptorType, config->desc.bLength);
  24. 		return -EINVAL;
  25. 	}
  26. 	cfgno = config->desc.bConfigurationValue; //当前配置编号值
  27.  
  28. 	//这里偏移buffer的目的是啥？？？不过下面又开始计算配置下的接口了！！！
  29. 	//上面是以前的疑问，现在明白了，buffer += config->desc.bLength 表示跳过配置的内容，直接跳转到接口
  30. 	buffer += config->desc.bLength;  //偏移到接口
  31. 	size -= config->desc.bLength; //减去配置的长度
  32.  
  33. 	nintf = nintf_orig = config->desc.bNumInterfaces; //接口个数
  34. 	if (nintf > USB_MAXINTERFACES) {
  35. 		dev_warn(ddev, "config %d has too many interfaces: %d, "
  36. 		    "using maximum allowed: %d\n",
  37. 		    cfgno, nintf, USB_MAXINTERFACES);
  38. 		nintf = USB_MAXINTERFACES;
  39. 	}
  40.  
  41. 	/* Go through the descriptors, checking their length and counting the
  42. 	 * number of altsettings for each interface */
  43. 	n = 0;
  44. 	for ((buffer2 = buffer, size2 = size); //遍历接口
  45. 	      size2 > 0;
  46. 	     (buffer2 += header->bLength, size2 -= header->bLength)) {
  47.  
  48. 		if (size2 < sizeof(struct usb_descriptor_header)) {
  49. 			dev_warn(ddev, "config %d descriptor has %d excess "
  50. 			    "byte%s, ignoring\n",
  51. 			    cfgno, size2, plural(size2));
  52. 			break;
  53. 		}
  54.  
  55. 		header = (struct usb_descriptor_header *) buffer2; //这里先获取描述符接口的长度和描述符的类型（这里类型为接口）两个字段
  56. 		if ((header->bLength > size2) || (header->bLength < 2)) {
  57. 			dev_warn(ddev, "config %d has an invalid descriptor "
  58. 			    "of length %d, skipping remainder of the config\n",
  59. 			    cfgno, header->bLength);
  60. 			break;
  61. 		}
  62.  
  63. 		if (header->bDescriptorType == USB_DT_INTERFACE) { //是接口
  64. 			struct usb_interface_descriptor *d;
  65. 			int inum;
  66.  
  67. 			d = (struct usb_interface_descriptor *) header; //上面通过两个字段确定了为接口，这里直接转换为接口描述符 struct usb_interface_descriptor
  68. 			if (d->bLength < USB_DT_INTERFACE_SIZE) {
  69. 				dev_warn(ddev, "config %d has an invalid "
  70. 				    "interface descriptor of length %d, "
  71. 				    "skipping\n", cfgno, d->bLength);
  72. 				continue;
  73. 			}
  74.  
  75. 			inum = d->bInterfaceNumber; //获取接口的编号
  76.  
  77. 			if ((dev->quirks & USB_QUIRK_HONOR_BNUMINTERFACES) &&
  78. 			    n >= nintf_orig) {
  79. 				dev_warn(ddev, "config %d has more interface "
  80. 				    "descriptors, than it declares in "
  81. 				    "bNumInterfaces, ignoring interface "
  82. 				    "number: %d\n", cfgno, inum);
  83. 				continue;
  84. 			}
  85.  
  86. 			if (inum >= nintf_orig) //当前接口编号是否大于总得接口个数
  87. 				dev_warn(ddev, "config %d has an invalid "
  88. 				    "interface number: %d but max is %d\n",
  89. 				    cfgno, inum, nintf_orig - 1);
  90.  
  91. 			/* Have we already encountered this interface?
  92. 			 * Count its altsettings */
  93. 			for (i = 0; i < n; ++i) {
  94. 				if (inums[i] == inum) //确定之前是否已经统计了该接口
  95. 					break;
  96. 			}
  97. 			if (i < n) { //
  98. 				if (nalts[i] < 255)
  99. 					++nalts[i]; //对当前接口编号相同的进行统计（初始化为1，在else if语句中）
  100. 			} else if (n < USB_MAXINTERFACES) {
  101. 				inums[n] = inum; //记录当前接口的编号到inums数组中
  102. 				nalts[n] = 1; //初始化当前接口值为1
  103. 				++n;
  104. 			}
  105.  
  106. 		} else if (header->bDescriptorType ==
  107. 				USB_DT_INTERFACE_ASSOCIATION) {
  108. 			if (iad_num == USB_MAXIADS) {
  109. 				dev_warn(ddev, "found more Interface "
  110. 					       "Association Descriptors "
  111. 					       "than allocated for in "
  112. 					       "configuration %d\n", cfgno);
  113. 			} else {
  114. 				config->intf_assoc[iad_num] =
  115. 					(struct usb_interface_assoc_descriptor
  116. 					*)header;
  117. 				iad_num++;
  118. 			}
  119.  
  120. 		} else if (header->bDescriptorType == USB_DT_DEVICE ||
  121. 			    header->bDescriptorType == USB_DT_CONFIG)
  122. 			dev_warn(ddev, "config %d contains an unexpected "
  123. 			    "descriptor of type 0x%X, skipping\n",
  124. 			    cfgno, header->bDescriptorType);
  125.  
  126. 	}	/* for ((buffer2 = buffer, size2 = size); ...) */
  127. 	size = buffer2 - buffer; //size=一个配置中所有接口描述符的长度
  128. 	config->desc.wTotalLength = cpu_to_le16(buffer2 - buffer0); //config->desc.wTotalLength = 一个配置和接口描述符的总长度
  129.  
  130. 	if (n != nintf)
  131. 		dev_warn(ddev, "config %d has %d interface%s, different from "
  132. 		    "the descriptor's value: %d\n",
  133. 		    cfgno, n, plural(n), nintf_orig);
  134. 	else if (n == 0)
  135. 		dev_warn(ddev, "config %d has no interfaces?\n", cfgno);
  136. 	config->desc.bNumInterfaces = nintf = n;
  137.  
  138. 	/* Check for missing interface numbers */
  139. 	for (i = 0; i < nintf; ++i) { //由于inums数组中存储的是随机接口编号，所以这里通过从小到大的顺序检测是否正常，否则输出调试警告
  140. 		for (j = 0; j < nintf; ++j) {
  141. 			if (inums[j] == i)
  142. 				break;
  143. 		}
  144. 		if (j >= nintf)
  145. 			dev_warn(ddev, "config %d has no interface number "
  146. 			    "%d\n", cfgno, i);
  147. 	}
  148.  
  149. 	/* Allocate the usb_interface_caches and altsetting arrays */
  150. 	for (i = 0; i < nintf; ++i) { //遍历接口
  151. 		j = nalts[i];
  152. 		if (j > USB_MAXALTSETTING) {
  153. 			dev_warn(ddev, "too many alternate settings for "
  154. 			    "config %d interface %d: %d, "
  155. 			    "using maximum allowed: %d\n",
  156. 			    cfgno, inums[i], j, USB_MAXALTSETTING);
  157. 			nalts[i] = j = USB_MAXALTSETTING;
  158. 		}
  159.  
  160. 		//sizeof(*intfc)： 接口缓存的长度
  161. 		//sizeof(struct usb_host_interface) * j： 表示一个主机控制的长度*接口个数
  162. 		len = sizeof(*intfc) + sizeof(struct usb_host_interface) * j;
  163. 		//表示一个接口的缓存（包括接口轮流, 因为存在多个相同的接口编号）
  164. 		config->intf_cache[i] = intfc = kzalloc(len, GFP_KERNEL); 
  165. 		if (!intfc)
  166. 			return -ENOMEM;
  167. 		kref_init(&intfc->ref);
  168. 	}
  169.  
  170. 	/* FIXME: parse the BOS descriptor */
  171.  
  172. 	/* Skip over any Class Specific or Vendor Specific descriptors;
  173. 	 * find the first interface descriptor */
  174. 	config->extra = buffer; //处理设备中要求的接口个数，之外的接口数据
  175. 	i = find_next_descriptor(buffer, size, USB_DT_INTERFACE,
  176. 	    USB_DT_INTERFACE, &n);
  177. 	config->extralen = i;
  178. 	if (n > 0)
  179. 		dev_dbg(ddev, "skipped %d descriptor%s after %s\n",
  180. 		    n, plural(n), "configuration");
  181. 	buffer += i;
  182. 	size -= i;
  183.  
  184. 	/* Parse all the interface/altsetting descriptors */
  185. 	while (size > 0) {
  186. 		//解析接口数据
  187. 		retval = usb_parse_interface(ddev, cfgno, config,
  188. 		    buffer, size, inums, nalts);
  189. 		if (retval < 0)
  190. 			return retval;
  191.  
  192. 		buffer += retval;
  193. 		size -= retval;
  194. 	}
  195.  
  196. 	/* Check for missing altsettings */
  197. 	for (i = 0; i < nintf; ++i) {
  198. 		intfc = config->intf_cache[i];
  199. 		for (j = 0; j < intfc->num_altsetting; ++j) {
  200. 			for (n = 0; n < intfc->num_altsetting; ++n) {
  201. 				if (intfc->altsetting[n].desc.
  202. 				    bAlternateSetting == j)
  203. 					break;
  204. 			}
  205. 			if (n >= intfc->num_altsetting)
  206. 				dev_warn(ddev, "config %d interface %d has no "
  207. 				    "altsetting %d\n", cfgno, inums[i], j);
  208. 		}
  209. 	}
  210.  
  211. 	return 0;
  212. }

5.6.3 解析接口信息

  1. 	while (size > 0) {
  2. 		//解析接口数据
  3. 		retval = usb_parse_interface(ddev, cfgno, config,
  4. 		    buffer, size, inums, nalts);
  5. 		if (retval < 0)
  6. 			return retval;
  7.  
  8. 		buffer += retval;
  9. 		size -= retval;
  10. 	}
  1. static int usb_parse_interface(struct device *ddev, int cfgno,
  2.     struct usb_host_config *config, unsigned char *buffer, int size,
  3.     u8 inums[], u8 nalts[])
  4. {
  5. 	unsigned char *buffer0 = buffer;
  6. 	struct usb_interface_descriptor	*d;
  7. 	int inum, asnum;
  8. 	struct usb_interface_cache *intfc;
  9. 	struct usb_host_interface *alt;
  10. 	int i, n;
  11. 	int len, retval;
  12. 	int num_ep, num_ep_orig;
  13.  
  14. 	d = (struct usb_interface_descriptor *) buffer; //获取接口描述符信息
  15. 	buffer += d->bLength;
  16. 	size -= d->bLength;
  17.  
  18. 	if (d->bLength < USB_DT_INTERFACE_SIZE)
  19. 		goto skip_to_next_interface_descriptor;
  20.  
  21. 	/* Which interface entry is this? */
  22. 	intfc = NULL;
  23. 	inum = d->bInterfaceNumber; //接口编号
  24. 	for (i = 0; i < config->desc.bNumInterfaces; ++i) { //根据设备中获取的接口总数，遍历接口，匹配与当前inum接口编号相等的
  25. 		if (inums[i] == inum) {
  26. 			intfc = config->intf_cache[i]; //获取接口缓存信息
  27. 			break;
  28. 		}
  29. 	}
  30. 	if (!intfc || intfc->num_altsetting >= nalts[i])
  31. 		goto skip_to_next_interface_descriptor;
  32.  
  33. 	/* Check for duplicate altsetting entries */
  34. 	asnum = d->bAlternateSetting;
  35. 	for ((i = 0, alt = &intfc->altsetting[0]);
  36. 	      i < intfc->num_altsetting;
  37. 	     (++i, ++alt)) {
  38. 		if (alt->desc.bAlternateSetting == asnum) {
  39. 			dev_warn(ddev, "Duplicate descriptor for config %d "
  40. 			    "interface %d altsetting %d, skipping\n",
  41. 			    cfgno, inum, asnum);
  42. 			goto skip_to_next_interface_descriptor;
  43. 		}
  44. 	}
  45.  
  46. 	++intfc->num_altsetting;
  47. 	memcpy(&alt->desc, d, USB_DT_INTERFACE_SIZE); //拷贝一个接口描述符
  48.  
  49. 	/* Skip over any Class Specific or Vendor Specific descriptors;
  50. 	 * find the first endpoint or interface descriptor */
  51. 	alt->extra = buffer;
  52. 	i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT,
  53. 	    USB_DT_INTERFACE, &n);
  54. 	alt->extralen = i;
  55. 	if (n > 0)
  56. 		dev_dbg(ddev, "skipped %d descriptor%s after %s\n",
  57. 		    n, plural(n), "interface");
  58. 	buffer += i;
  59. 	size -= i;
  60.  
  61. 	/* Allocate space for the right(?) number of endpoints */
  62. 	num_ep = num_ep_orig = alt->desc.bNumEndpoints; //获取接口的端点个数
  63. 	alt->desc.bNumEndpoints = 0;		/* Use as a counter */
  64. 	if (num_ep > USB_MAXENDPOINTS) {
  65. 		dev_warn(ddev, "too many endpoints for config %d interface %d "
  66. 		    "altsetting %d: %d, using maximum allowed: %d\n",
  67. 		    cfgno, inum, asnum, num_ep, USB_MAXENDPOINTS);
  68. 		num_ep = USB_MAXENDPOINTS;
  69. 	}
  70.  
  71. 	if (num_ep > 0) {
  72. 		/* Can't allocate 0 bytes */
  73. 		len = sizeof(struct usb_host_endpoint) * num_ep; //分配端点个数的空间
  74. 		alt->endpoint = kzalloc(len, GFP_KERNEL);
  75. 		if (!alt->endpoint)
  76. 			return -ENOMEM;
  77. 	}
  78.  
  79. 	/* Parse all the endpoint descriptors */
  80. 	n = 0;
  81. 	while (size > 0) {
  82. 		if (((struct usb_descriptor_header *) buffer)->bDescriptorType
  83. 		     == USB_DT_INTERFACE)
  84. 			break;
  85.  
  86. 		//解析端点	
  87. 		retval = usb_parse_endpoint(ddev, cfgno, inum, asnum, alt,
  88. 		    num_ep, buffer, size);
  89. 		if (retval < 0)
  90. 			return retval;
  91. 		++n;
  92.  
  93. 		buffer += retval;
  94. 		size -= retval;
  95. 	}
  96.  
  97. 	if (n != num_ep_orig)
  98. 		dev_warn(ddev, "config %d interface %d altsetting %d has %d "
  99. 		    "endpoint descriptor%s, different from the interface "
  100. 		    "descriptor's value: %d\n",
  101. 		    cfgno, inum, asnum, n, plural(n), num_ep_orig);
  102. 	return buffer - buffer0;
  103.  
  104. skip_to_next_interface_descriptor:
  105. 	i = find_next_descriptor(buffer, size, USB_DT_INTERFACE,
  106. 	    USB_DT_INTERFACE, NULL);
  107. 	return buffer - buffer0 + i;
  108. }

5.6.4 解析端点

  1. 		//解析端点	
  2. 		retval = usb_parse_endpoint(ddev, cfgno, inum, asnum, alt,
  3. 		    num_ep, buffer, size);
  1. static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum,
  2.     int asnum, struct usb_host_interface *ifp, int num_ep,
  3.     unsigned char *buffer, int size)
  4. {
  5. 	unsigned char *buffer0 = buffer;
  6. 	struct usb_endpoint_descriptor *d;
  7. 	struct usb_host_endpoint *endpoint;
  8. 	int n, i, j, retval;
  9.  
  10. 	d = (struct usb_endpoint_descriptor *) buffer; //获取端点描述符
  11. 	buffer += d->bLength;
  12. 	size -= d->bLength;
  13.  
  14. 	if (d->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE)
  15. 		n = USB_DT_ENDPOINT_AUDIO_SIZE;
  16. 	else if (d->bLength >= USB_DT_ENDPOINT_SIZE)
  17. 		n = USB_DT_ENDPOINT_SIZE;
  18. 	else {
  19. 		dev_warn(ddev, "config %d interface %d altsetting %d has an "
  20. 		    "invalid endpoint descriptor of length %d, skipping\n",
  21. 		    cfgno, inum, asnum, d->bLength);
  22. 		goto skip_to_next_endpoint_or_interface_descriptor;
  23. 	}
  24.  
  25. 	i = d->bEndpointAddress & ~USB_ENDPOINT_DIR_MASK;
  26. 	if (i >= 16 || i == 0) {
  27. 		dev_warn(ddev, "config %d interface %d altsetting %d has an "
  28. 		    "invalid endpoint with address 0x%X, skipping\n",
  29. 		    cfgno, inum, asnum, d->bEndpointAddress);
  30. 		goto skip_to_next_endpoint_or_interface_descriptor;
  31. 	}
  32.  
  33. 	/* Only store as many endpoints as we have room for */
  34. 	if (ifp->desc.bNumEndpoints >= num_ep)
  35. 		goto skip_to_next_endpoint_or_interface_descriptor;
  36.  
  37. 	endpoint = &ifp->endpoint[ifp->desc.bNumEndpoints];
  38. 	++ifp->desc.bNumEndpoints;
  39.  
  40. 	memcpy(&endpoint->desc, d, n);
  41. 	INIT_LIST_HEAD(&endpoint->urb_list);
  42.  
  43. 	/* Fix up bInterval values outside the legal range. Use 32 ms if no
  44. 	 * proper value can be guessed. */
  45.  
  46. 	//根据不同速率的usb，计算时间
  47. 	i = 0;		/* i = min, j = max, n = default */
  48. 	j = 255;
  49. 	if (usb_endpoint_xfer_int(d)) {
  50. 		i = 1;
  51. 		switch (to_usb_device(ddev)->speed) {
  52. 		case USB_SPEED_SUPER:
  53. 		case USB_SPEED_HIGH:
  54. 			/* Many device manufacturers are using full-speed
  55. 			 * bInterval values in high-speed interrupt endpoint
  56. 			 * descriptors. Try to fix those and fall back to a
  57. 			 * 32 ms default value otherwise. */
  58. 			n = fls(d->bInterval*8);
  59. 			if (n == 0)
  60. 				n = 9;	/* 32 ms = 2^(9-1) uframes */
  61. 			j = 16;
  62. 			break;
  63. 		default:		/* USB_SPEED_FULL or _LOW */
  64. 			/* For low-speed, 10 ms is the official minimum.
  65. 			 * But some "overclocked" devices might want faster
  66. 			 * polling so we'll allow it. */
  67. 			n = 32;
  68. 			break;
  69. 		}
  70. 	} else if (usb_endpoint_xfer_isoc(d)) {
  71. 		i = 1;
  72. 		j = 16;
  73. 		switch (to_usb_device(ddev)->speed) {
  74. 		case USB_SPEED_HIGH:
  75. 			n = 9;		/* 32 ms = 2^(9-1) uframes */
  76. 			break;
  77. 		default:		/* USB_SPEED_FULL */
  78. 			n = 6;		/* 32 ms = 2^(6-1) frames */
  79. 			break;
  80. 		}
  81. 	}
  82. 	if (d->bInterval < i || d->bInterval > j) {
  83. 		dev_warn(ddev, "config %d interface %d altsetting %d "
  84. 		    "endpoint 0x%X has an invalid bInterval %d, "
  85. 		    "changing to %d\n",
  86. 		    cfgno, inum, asnum,
  87. 		    d->bEndpointAddress, d->bInterval, n);
  88. 		endpoint->desc.bInterval = n;
  89. 	}
  90.  
  91. 	/* Some buggy low-speed devices have Bulk endpoints, which is
  92. 	 * explicitly forbidden by the USB spec.  In an attempt to make
  93. 	 * them usable, we will try treating them as Interrupt endpoints.
  94. 	 */
  95. 	if (to_usb_device(ddev)->speed == USB_SPEED_LOW &&
  96. 			usb_endpoint_xfer_bulk(d)) {
  97. 		dev_warn(ddev, "config %d interface %d altsetting %d "
  98. 		    "endpoint 0x%X is Bulk; changing to Interrupt\n",
  99. 		    cfgno, inum, asnum, d->bEndpointAddress);
  100. 		endpoint->desc.bmAttributes = USB_ENDPOINT_XFER_INT;
  101. 		endpoint->desc.bInterval = 1;
  102. 		if (usb_endpoint_maxp(&endpoint->desc) > 8)
  103. 			endpoint->desc.wMaxPacketSize = cpu_to_le16(8); //低速设备端点字节为8个
  104. 	}
  105.  
  106. 	/*
  107. 	 * Some buggy high speed devices have bulk endpoints using
  108. 	 * maxpacket sizes larger than 64 under full-speed mode.  
  109. 	 * Full speed HCDs may not
  110. 	 * be able to handle that particular bug, so let's modify 
  111. 	 * the maxpacket size to make it work.
  112. 	 */
  113. 	if (to_usb_device(ddev)->speed == USB_SPEED_FULL
  114. 			&& usb_endpoint_xfer_bulk(d)) {
  115.  
  116. 		if (usb_endpoint_maxp(&endpoint->desc) > 64)
  117. 			endpoint->desc.wMaxPacketSize = cpu_to_le16(64); //全速设备端点字节为64个
  118. 	}
  119.  
  120. 	/*
  121. 	 * Some buggy high speed devices have bulk endpoints using
  122. 	 * maxpacket sizes other than 512.  High speed HCDs may not
  123. 	 * be able to handle that particular bug, so let's warn...
  124. 	 */
  125. 	if (to_usb_device(ddev)->speed == USB_SPEED_HIGH
  126. 			&& usb_endpoint_xfer_bulk(d)) {
  127. 		unsigned maxp;
  128.  
  129. 		maxp = usb_endpoint_maxp(&endpoint->desc) & 0x07ff;  //高速设备端点字节数。。。
  130. 		if (maxp != 512)
  131. 			dev_warn(ddev, "config %d interface %d altsetting %d "
  132. 				"bulk endpoint 0x%X has invalid maxpacket %d\n",
  133. 				cfgno, inum, asnum, d->bEndpointAddress,
  134. 				maxp);
  135. 	}
  136.  
  137. 	/* Parse a possible SuperSpeed endpoint companion descriptor */
  138. 	if (to_usb_device(ddev)->speed == USB_SPEED_SUPER)
  139. 		usb_parse_ss_endpoint_companion(ddev, cfgno,
  140. 				inum, asnum, endpoint, buffer, size);
  141.  
  142. 	/* Skip over any Class Specific or Vendor Specific descriptors;
  143. 	 * find the next endpoint or interface descriptor */
  144. 	endpoint->extra = buffer;
  145. 	i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT,
  146. 			USB_DT_INTERFACE, &n);
  147. 	endpoint->extralen = i;
  148. 	retval = buffer - buffer0 + i;
  149. 	if (n > 0)
  150. 		dev_dbg(ddev, "skipped %d descriptor%s after %s\n",
  151. 		    n, plural(n), "endpoint");
  152. 	return retval;
  153.  
  154. skip_to_next_endpoint_or_interface_descriptor:
  155. 	i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT,
  156. 	    USB_DT_INTERFACE, NULL);
  157. 	return buffer - buffer0 + i;
  158. }

端点部分主要工作是，根据不同速率的usb，传输不同的字节数，以及主机查询端点的间隔时间。至此分析完了枚举一个usb主机控制器的过程：设备-->N个配置-->N个接口-->N个端点，最后通过如下函数输出控制器的功能信息

6. 输出主机控制器信息

	announce_device(udev);
  1. static void announce_device(struct usb_device *udev)
  2. {
  3. 	dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n",
  4. 		le16_to_cpu(udev->descriptor.idVendor),
  5. 		le16_to_cpu(udev->descriptor.idProduct));
  6. 	dev_info(&udev->dev,
  7. 		"New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
  8. 		udev->descriptor.iManufacturer,
  9. 		udev->descriptor.iProduct,
  10. 		udev->descriptor.iSerialNumber);
  11. 	show_string(udev, "Product", udev->product);
  12. 	show_string(udev, "Manufacturer", udev->manufacturer);
  13. 	show_string(udev, "SerialNumber", udev->serial);
  14. }

系统启动时输出上述信息：

  1. usb usb1: New USB device found, idVendor=1d6b, idProduct=0002
  2. usb usb1: New USB device strings: Mfr=3, Product=2, SerialNumber=1
  3. usb usb1: Product: Nuvoton NUC970 EHCI Host Controller
  4. usb usb1: Manufacturer: Linux 3.10.32 ehci_hcd
  5. usb usb1: SerialNumber: nuc970-ehci

7. 总结

      本文开始通过platform总线完成ehci设备和驱动的匹配调用探测函数ehci_nuc970_probe()，在该函数内部完成主机控制器的寄存器资源分配，然后注册一个hcd主机控制器（包括是否使用DMA池），然后增加主机控制器到usb总线上，然后注册一个根hub，期间包括最重要的部分，即设备枚举，在枚举的过程，先获取设备，通过设备获取接口，因接口长度未定，所以分两次读取接口信息，即第一次读取固定长度的接口信息，第二次根据第一次的描述符信息里的长度再读取整个接口信息，最后根据接口信息解析端点，最后将该主机控制器的根hub注册到usb总线上。





















本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号