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

USB驱动之Android usb鼠标驱动_安卓鼠标驱动

作者：从前慢现在也慢 | 2024-03-27 21:54:07

赞

踩

安卓鼠标驱动

1. 前言

        HID是Human Interface Devices的缩写，翻译成中文即为人机交互设备。这里的人机交互设备是一个宏观上面的概念，任何设备只要符合HID spec都可以称之为HID设备，常见的HID设备有鼠标键盘，游戏操纵杆等等。

        usb鼠标在android代码中没有使用linux中常用的drivers/hid/usbhid/usbmouse.c驱动，而是使用了hid-generic驱动【注：从内核配置可知，内核选项配置了CONFIG_HID，CONFIG_USB_HID，CONFIG_HID_GENERIC，但是没有配置CONFIG_USB_KBD，CONFIG_USB_MOUSE选项】。

        注意有两个hid-core.c文件，分别为hid/hid-core.c和hid/usbhid/hid-core.c文件。前者注册hid总线，后者注册hid device。

2. hid bus

        在内核启动时，注册了hid总线驱动，在drivers/hid/hid-core.c中注册了一个名为hid_bus_type的hid总线。

  1. static int __init hid_init(void)
  2. {
  3. 	int ret;
  4. 	ret = bus_register(&hid_bus_type);//---->
  5. 	ret = hidraw_init();
  6. 	hid_debug_init();
  7. 	return 0;
  8. }
  9.  
  10. static struct bus_type hid_bus_type = {
  11. 	.name		= "hid",
  12. 	.dev_groups	= hid_dev_groups,
  13. 	.drv_groups	= hid_drv_groups,
  14. 	.match		= hid_bus_match,
  15. 	.probe		= hid_device_probe,
  16. 	.remove		= hid_device_remove,
  17. 	.uevent		= hid_uevent,
  18. };

3. hid driver

        在hid-generic.c中定义了module_hid_driver(hid_generic)，这个宏实际上是调用__hid_register_driver(drivers/hid/)接口注册一个hid_driver，并把它挂接在hid_bus_type总线驱动链表上。

  1. static const struct hid_device_id hid_table[] = {
  2. 	{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_GENERIC, HID_ANY_ID, HID_ANY_ID) },
  3. 	{ }
  4. };
  5. static struct hid_driver hid_generic = {
  6. 	.name = "hid-generic",
  7. 	.id_table = hid_table,
  8. };
  9. module_hid_driver(hid_generic);
  10. //usb鼠标将和hid_generic匹配

4. hid device

        在drivers/hid/usbhid/hid-core.c中定义了hid_driver，它是个usb_driver，并且调用usb_register_driver接口注册到了usb总线(usb_bus_type)上。

  1. static int __init hid_init(void)
  2. {
  3. 	int retval = -ENOMEM;
  4. 	retval = usbhid_quirks_init(quirks_param);
  5. 	retval = usb_register(&hid_driver);	//---->
  6. 	return 0;
  7. }
  8.  
  9. static struct usb_driver hid_driver = {
  10. 	.name =		"usbhid",
  11. 	.probe =	usbhid_probe,
  12. 	.disconnect =	usbhid_disconnect,
  13. #ifdef CONFIG_PM
  14. 	.suspend =	hid_suspend,
  15. 	.resume =	hid_resume,
  16. 	.reset_resume =	hid_reset_resume,
  17. #endif
  18. 	.pre_reset =	hid_pre_reset,
  19. 	.post_reset =	hid_post_reset,
  20. 	.id_table =	hid_usb_ids,
  21. 	.supports_autosuspend = 1,
  22. };
  23.  
  24. static const struct usb_device_id hid_usb_ids[] = {
  25. 	{ .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
  26. 		.bInterfaceClass = USB_INTERFACE_CLASS_HID },//所有ClassID为USB_INTERFACE_CLASS_HID的设备都会被这个驱动所匹配.所以,所有USB HID设备都会由这个module来驱动。
  27. 	{ }						/* Terminating entry */
  28. };

        当hid设备插入usb口以后会调用usb_driver的probe函数，这一点由《USB驱动》可知。

  1. static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *id)
  2. {
  3. 	struct usb_host_interface *interface = intf->cur_altsetting;
  4. 	struct usb_device *dev = interface_to_usbdev(intf);
  5. 	struct usbhid_device *usbhid;
  6. 	struct hid_device *hid;
  7. 	unsigned int n, has_in = 0;
  8. 	size_t len;
  9. 	int ret;
  10.  
  11. 	dbg_hid("HID probe called for ifnum %d\n",
  12. 			intf->altsetting->desc.bInterfaceNumber);
  13.  
  14. 	for (n = 0; n < interface->desc.bNumEndpoints; n++)
  15. 		if (usb_endpoint_is_int_in(&interface->endpoint[n].desc))
  16. 			has_in++;
  17. 	if (!has_in) {
  18. 		hid_err(intf, "couldn't find an input interrupt endpoint\n");
  19. 		return -ENODEV;
  20. 	}
  21.  
  22.     //分配一个struct hid_device设备
  23. 	hid = hid_allocate_device();
  24.  
  25.     //把这个接口和hid设备关联
  26. 	usb_set_intfdata(intf, hid);
  27.     //安装hid底层驱动，其实是个回调usb hid的回调驱动函数集，具体硬件操作依靠它来实现，hid core层（而不是usb hid core层）回调它。 
  28. 	hid->ll_driver = &usb_hid_driver;
  29. 	hid->ff_init = hid_pidff_init;
  30. #ifdef CONFIG_USB_HIDDEV
  31. 	hid->hiddev_connect = hiddev_connect;
  32. 	hid->hiddev_disconnect = hiddev_disconnect;
  33. 	hid->hiddev_hid_event = hiddev_hid_event;
  34. 	hid->hiddev_report_event = hiddev_report_event;
  35. #endif
  36. 	hid->dev.parent = &intf->dev;
  37. 	hid->bus = BUS_USB;
  38. 	hid->vendor = le16_to_cpu(dev->descriptor.idVendor);
  39. 	hid->product = le16_to_cpu(dev->descriptor.idProduct);
  40. 	hid->name[0] = 0;
  41. 	hid->quirks = usbhid_lookup_quirk(hid->vendor, hid->product);
  42. 	if (intf->cur_altsetting->desc.bInterfaceProtocol ==
  43. 			USB_INTERFACE_PROTOCOL_MOUSE)
  44. 		hid->type = HID_TYPE_USBMOUSE;
  45. 	else if (intf->cur_altsetting->desc.bInterfaceProtocol == 0)
  46. 		hid->type = HID_TYPE_USBNONE;
  47.  
  48. 	if (dev->manufacturer)
  49. 		strlcpy(hid->name, dev->manufacturer, sizeof(hid->name));
  50.  
  51. 	if (dev->product) {
  52. 		if (dev->manufacturer)
  53. 			strlcat(hid->name, " ", sizeof(hid->name));
  54. 		strlcat(hid->name, dev->product, sizeof(hid->name));
  55. 	}
  56.  
  57. 	if (!strlen(hid->name))
  58. 		snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x",
  59. 			 le16_to_cpu(dev->descriptor.idVendor),
  60. 			 le16_to_cpu(dev->descriptor.idProduct));
  61.  
  62. 	usb_make_path(dev, hid->phys, sizeof(hid->phys));
  63. 	strlcat(hid->phys, "/input", sizeof(hid->phys));
  64. 	len = strlen(hid->phys);
  65. 	if (len < sizeof(hid->phys) - 1)
  66. 		snprintf(hid->phys + len, sizeof(hid->phys) - len,
  67. 			 "%d", intf->altsetting[0].desc.bInterfaceNumber);
  68.  
  69. 	if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
  70. 		hid->uniq[0] = 0;
  71.   
  72.    //分配一个usbhid设备，同时也是一个hid_device，继承hid_device
  73. 	usbhid = kzalloc(sizeof(*usbhid), GFP_KERNEL);
  74.  
  75. 	hid->driver_data = usbhid;
  76. 	usbhid->hid = hid;
  77. 	usbhid->intf = intf;
  78. 	usbhid->ifnum = interface->desc.bInterfaceNumber;
  79.  
  80. 	init_waitqueue_head(&usbhid->wait);
  81. 	INIT_WORK(&usbhid->reset_work, hid_reset);
  82. 	setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid);
  83. 	spin_lock_init(&usbhid->lock);
  84.     
  85.    //向hid核心层添加一个hid_device设备，同时也会获取HID report报告描述符 
  86. 	ret = hid_add_device(hid);
  87. 	return 0;
  88. err_free:
  89. 	kfree(usbhid);
  90. err:
  91. 	hid_destroy_device(hid);
  92. 	return ret;
  93. }
  94.  
  95. int hid_add_device(struct hid_device *hdev)
  96. {
  97. 	static atomic_t id = ATOMIC_INIT(0);
  98. 	int ret;
  99.  
  100. 	if (WARN_ON(hdev->status & HID_STAT_ADDED))
  101. 		return -EBUSY;
  102.  
  103. 	/* we need to kill them here, otherwise they will stay allocated to
  104. 	 * wait for coming driver */
  105. 	if (hid_ignore(hdev))
  106. 		return -ENODEV;
  107.  
  108. 	/*
  109. 	 * Check for the mandatory transport channel.
  110. 	 */
  111. 	 if (!hdev->ll_driver->raw_request) {
  112. 		hid_err(hdev, "transport driver missing .raw_request()\n");
  113. 		return -EINVAL;
  114. 	 }
  115.  
  116. 	/*
  117. 	 * Read the device report descriptor once and use as template
  118. 	 * for the driver-specific modifications.
  119. 	 */
  120. 	ret = hdev->ll_driver->parse(hdev);
  121. 	if (ret)
  122. 		return ret;
  123. 	if (!hdev->dev_rdesc)
  124. 		return -ENODEV;
  125.  
  126. 	/*
  127. 	 * Scan generic devices for group information
  128. 	 */
  129. 	if (hid_ignore_special_drivers) {
  130. 		hdev->group = HID_GROUP_GENERIC;
  131. 	} else if (!hdev->group &&
  132. 		   !hid_match_id(hdev, hid_have_special_driver)) {
  133. 		ret = hid_scan_report(hdev);
  134. 		if (ret)
  135. 			hid_warn(hdev, "bad device descriptor (%d)\n", ret);
  136. 	}
  137.  
  138. 	/* XXX hack, any other cleaner solution after the driver core
  139. 	 * is converted to allow more than 20 bytes as the device name? */
  140. 	dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,
  141. 		     hdev->vendor, hdev->product, atomic_inc_return(&id));
  142.  
  143. 	hid_debug_register(hdev, dev_name(&hdev->dev));
  144.    //这里会调用hid_bus的hid_device_probe函数
  145. 	ret = device_add(&hdev->dev);
  146. 	if (!ret)
  147. 		hdev->status |= HID_STAT_ADDED;
  148. 	else
  149. 		hid_debug_unregister(hdev);
  150.  
  151. 	return ret;
  152. }
  153.  
  154. static int hid_device_probe(struct device *dev)
  155. {
  156. 	struct hid_driver *hdrv = to_hid_driver(dev->driver);
  157. 	struct hid_device *hdev = to_hid_device(dev);
  158. 	const struct hid_device_id *id;
  159. 	int ret = 0;
  160.  
  161. 	if (down_interruptible(&hdev->driver_input_lock)) {
  162. 		ret = -EINTR;
  163. 		goto end;
  164. 	}
  165. 	hdev->io_started = false;
  166.  
  167.    //第1次添加hid_device时，一定是为空 
  168. 	if (!hdev->driver) {
  169.            //在注册hid_device时就会调用hid_bus_type总线的match函数，这里再调用一次
  170. 		id = hid_match_device(hdev, hdrv);
  171. 		if (id == NULL) {
  172. 			ret = -ENODEV;
  173. 			goto unlock;
  174. 		}
  175.  
  176. 		hdev->driver = hdrv;
  177.           //hid_generic驱动没有probe函数
  178. 		if (hdrv->probe) {
  179. 			ret = hdrv->probe(hdev, id);
  180. 		} else { /* default probe 会调用这个函数，这里会对hid_add_device函数中获取到的HID report描述符进行解析*/
  181. 			ret = hid_open_report(hdev);
  182. 			if (!ret)
  183.                            //调用hid_ll_driver相关接口
  184. 				ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);	//---->
  185. 		}
  186. 		if (ret) {
  187. 			hid_close_report(hdev);
  188. 			hdev->driver = NULL;
  189. 		}
  190. 	}
  191. unlock:
  192. 	if (!hdev->io_started)
  193. 		up(&hdev->driver_input_lock);
  194. end:
  195.  
  196. 	return ret;
  197. }
  1. int hid_hw_start(struct hid_device *hdev, unsigned int connect_mask)
  2. {
  3. 	int error;
  4.  
  5. 	error = hdev->ll_driver->start(hdev); //启动设备,
  6. 	if (error)
  7. 		return error;
  8.  
  9. 	if (connect_mask) {
  10. 		error = hid_connect(hdev, connect_mask); //将设备与HID框架关联起来---->
  11. 		if (error) {
  12. 			hdev->ll_driver->stop(hdev);
  13. 			return error;
  14. 		}
  15. 	}
  16.  
  17. 	return 0;
  18. }
  19.  
  20. int hid_connect(struct hid_device *hdev, unsigned int connect_mask)
  21. {
  22. 	static const char *types[] = { "Device", "Pointer", "Mouse", "Device",
  23. 		"Joystick", "Gamepad", "Keyboard", "Keypad",
  24. 		"Multi-Axis Controller"
  25. 	};
  26. 	const char *type, *bus;
  27. 	char buf[64] = "";
  28. 	unsigned int i;
  29. 	int len;
  30. 	int ret;
  31.  
  32. 	if (hdev->quirks & HID_QUIRK_HIDDEV_FORCE)
  33. 		connect_mask |= (HID_CONNECT_HIDDEV_FORCE | HID_CONNECT_HIDDEV);
  34. 	if (hdev->quirks & HID_QUIRK_HIDINPUT_FORCE)
  35. 		connect_mask |= HID_CONNECT_HIDINPUT_FORCE;
  36. 	if (hdev->bus != BUS_USB) //如果不是USB总线，那么去掉HID_CONNECT_HIDDEV标记
  37. 		connect_mask &= ~HID_CONNECT_HIDDEV;
  38. 	if (hid_hiddev(hdev)) //匹配某些特定vendorID和productID
  39. 		connect_mask |= HID_CONNECT_HIDDEV_FORCE;
  40.  
  41. 	if ((connect_mask & HID_CONNECT_HIDINPUT) && !hidinput_connect(hdev, //input设备--->
  42. 				connect_mask & HID_CONNECT_HIDINPUT_FORCE))
  43. 		hdev->claimed |= HID_CLAIMED_INPUT;
  44.  
  45. 	if ((connect_mask & HID_CONNECT_HIDDEV) && hdev->hiddev_connect && 
  46. 			!hdev->hiddev_connect(hdev, //hiddev设备
  47. 				connect_mask & HID_CONNECT_HIDDEV_FORCE))
  48. 		hdev->claimed |= HID_CLAIMED_HIDDEV;
  49. 	if ((connect_mask & HID_CONNECT_HIDRAW) && !hidraw_connect(hdev)) //hidraw设备
  50. 		hdev->claimed |= HID_CLAIMED_HIDRAW;
  51.  
  52. 	if (connect_mask & HID_CONNECT_DRIVER)
  53. 		hdev->claimed |= HID_CLAIMED_DRIVER;
  54.  
  55. 	/* Drivers with the ->raw_event callback set are not required to connect
  56. 	 * to any other listener. */
  57. 	if (!hdev->claimed && !hdev->driver->raw_event) {
  58. 		hid_err(hdev, "device has no listeners, quitting\n");
  59. 		return -ENODEV;
  60. 	}
  61.  
  62. 	if ((hdev->claimed & HID_CLAIMED_INPUT) &&
  63. 			(connect_mask & HID_CONNECT_FF) && hdev->ff_init)
  64. 		hdev->ff_init(hdev);
  65.  
  66. 	len = 0;
  67. 	if (hdev->claimed & HID_CLAIMED_INPUT)
  68. 		len += sprintf(buf + len, "input");
  69. 	if (hdev->claimed & HID_CLAIMED_HIDDEV)
  70. 		len += sprintf(buf + len, "%shiddev%d", len ? "," : "",
  71. 				((struct hiddev *)hdev->hiddev)->minor);
  72. 	if (hdev->claimed & HID_CLAIMED_HIDRAW)
  73. 		len += sprintf(buf + len, "%shidraw%d", len ? "," : "",
  74. 				((struct hidraw *)hdev->hidraw)->minor);
  75.  
  76. 	type = "Device";
  77. 	for (i = 0; i < hdev->maxcollection; i++) {
  78. 		struct hid_collection *col = &hdev->collection[i];
  79. 		if (col->type == HID_COLLECTION_APPLICATION &&
  80. 		   (col->usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
  81. 		   (col->usage & 0xffff) < ARRAY_SIZE(types)) {
  82. 			type = types[col->usage & 0xffff];
  83. 			break;
  84. 		}
  85. 	}
  86.  
  87. 	switch (hdev->bus) {
  88. 	case BUS_USB:
  89. 		bus = "USB";
  90. 		break;
  91. 	case BUS_BLUETOOTH:
  92. 		bus = "BLUETOOTH";
  93. 		break;
  94. 	case BUS_I2C:
  95. 		bus = "I2C";
  96. 		break;
  97. 	default:
  98. 		bus = "<UNKNOWN>";
  99. 	}
  100.  
  101. 	ret = device_create_file(&hdev->dev, &dev_attr_country);
  102. 	if (ret)
  103. 		hid_warn(hdev,
  104. 			 "can't create sysfs country code attribute err: %d\n", ret);
  105.  
  106. 	hid_info(hdev, "%s: %s HID v%x.%02x %s [%s] on %s\n",
  107. 		 buf, bus, hdev->version >> 8, hdev->version & 0xff,
  108. 		 type, hdev->name, hdev->phys);
  109.  
  110. 	return 0;
  111. }

        HID中最常用的是input设备，使用hidinput_connect登记到系统。hidinput_connect的主要作用是对hiddev中的每一个report，都建立一个input_dev设备，并登记到input框架中。

  1. int hidinput_connect(struct hid_device *hid, unsigned int force)
  2. {
  3. 	struct hid_driver *drv = hid->driver;
  4. 	struct hid_report *report;
  5. 	struct hid_input *next, *hidinput = NULL;
  6. 	int i, k;
  7.  
  8. 	INIT_LIST_HEAD(&hid->inputs);
  9. 	INIT_WORK(&hid->led_work, hidinput_led_worker);
  10.  
  11. 	if (!force) {
  12. 		for (i = 0; i < hid->maxcollection; i++) {
  13. 			struct hid_collection *col = &hid->collection[i];
  14. 			if (col->type == HID_COLLECTION_APPLICATION ||
  15. 					col->type == HID_COLLECTION_PHYSICAL)
  16. 				if (IS_INPUT_APPLICATION(col->usage))
  17. 					break;
  18. 		}
  19.  
  20. 		if (i == hid->maxcollection)
  21. 			return -1;
  22. 	}
  23.  
  24. 	report_features(hid);
  25.  
  26.    //对每一个report，建立一个input设备 
  27. 	for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++) {
  28. 		if (k == HID_OUTPUT_REPORT &&
  29. 			hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
  30. 			continue;
  31.  
  32. 		list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
  33.  
  34. 			if (!report->maxfield)
  35. 				continue;
  36.  
  37. 			/*
  38. 			 * Find the previous hidinput report attached
  39. 			 * to this report id.
  40. 			 */
  41. 			if (hid->quirks & HID_QUIRK_MULTI_INPUT)
  42. 				hidinput = hidinput_match(report);
  43.  
  44. 			if (!hidinput) {
  45. 				hidinput = hidinput_allocate(hid);
  46. 				if (!hidinput)
  47. 					goto out_unwind;
  48. 			}
  49.  
  50. 			hidinput_configure_usages(hidinput, report);	//---->
  51.  
  52. 			if (hid->quirks & HID_QUIRK_MULTI_INPUT)
  53. 				hidinput->report = report;
  54. 		}
  55. 	}
  56.  
  57. 	list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
  58. 		if ((hid->quirks & HID_QUIRK_NO_EMPTY_INPUT) &&
  59. 		    !hidinput_has_been_populated(hidinput)) {
  60. 			/* no need to register an input device not populated */
  61. 			hidinput_cleanup_hidinput(hid, hidinput);
  62. 			continue;
  63. 		}
  64.  
  65. 		if (drv->input_configured &&
  66. 		    drv->input_configured(hid, hidinput))
  67. 			goto out_unwind;
  68. 		if (input_register_device(hidinput->input)) //将设备注册到Input子系统
  69. 			goto out_unwind;
  70. 		hidinput->registered = true;
  71. 	}
  72.  
  73. 	if (list_empty(&hid->inputs)) {
  74. 		hid_err(hid, "No inputs registered, leaving\n");
  75. 		goto out_unwind;
  76. 	}
  77.  
  78. 	return 0;
  79.  
  80. out_unwind:
  81. 	/* unwind the ones we already registered */
  82. 	hidinput_disconnect(hid);
  83.  
  84. 	return -1;
  85. }

        hidinput是一个将hid数据转为input格式的协议转换者,转换完毕之后,将数据发送给hidinput->input 这个真正的连接到mousedev_handler驱动上input_dev设备， 这样当hid设备上传数据，引发irq中断

        drivers/hid/usbhid/hid-core.c

  1. //hid->ll_driver = &usb_hid_driver
  2. struct hid_ll_driver usb_hid_driver = {
  3.         .parse = usbhid_parse,
  4.         .start = usbhid_start,
  5.         .stop = usbhid_stop,
  6.         .open = usbhid_open,
  7.         .close = usbhid_close,
  8.         .power = usbhid_power,
  9.         .request = usbhid_request,
  10.         .wait = usbhid_wait_io,
  11.         .raw_request = usbhid_raw_request,
  12.         .output_report = usbhid_output_report,
  13.         .idle = usbhid_idle,
  14. };
  15. //启动HID设备
  16. static int usbhid_start(struct hid_device *hid)
  17. {
  18.         struct usb_interface *intf = to_usb_interface(hid->dev.parent);
  19.         struct usb_host_interface *interface = intf->cur_altsetting;
  20.         struct usb_device *dev = interface_to_usbdev(intf);
  21.         struct usbhid_device *usbhid = hid->driver_data;
  22.         unsigned int n, insize = 0;
  23.         int ret;
  24.  
  25.         clear_bit(HID_DISCONNECTED, &usbhid->iofl);
  26.  
  27.         usbhid->bufsize = HID_MIN_BUFFER_SIZE;
  28.         hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize);
  29.         hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize);
  30.         hid_find_max_report(hid, HID_FEATURE_REPORT, &usbhid->bufsize);
  31.  
  32.         if (usbhid->bufsize > HID_MAX_BUFFER_SIZE)
  33.                 usbhid->bufsize = HID_MAX_BUFFER_SIZE;
  34.  
  35.         hid_find_max_report(hid, HID_INPUT_REPORT, &insize);
  36.  
  37.         if (insize > HID_MAX_BUFFER_SIZE)
  38.                 insize = HID_MAX_BUFFER_SIZE;
  39.  
  40.         if (hid_alloc_buffers(dev, hid)) {
  41.                 ret = -ENOMEM;
  42.                 goto fail;
  43.         }
  44.  
  45.         for (n = 0; n < interface->desc.bNumEndpoints; n++) {
  46.                 struct usb_endpoint_descriptor *endpoint;
  47.                 int pipe;
  48.                 int interval;
  49.  
  50.                 endpoint = &interface->endpoint[n].desc;
  51.                 if (!usb_endpoint_xfer_int(endpoint))
  52.                         continue;
  53.  
  54.                 interval = endpoint->bInterval;
  55.  
  56.                 /* Some vendors give fullspeed interval on highspeed devides */
  57.                 if (hid->quirks & HID_QUIRK_FULLSPEED_INTERVAL &&
  58.                     dev->speed == USB_SPEED_HIGH) {
  59.                         interval = fls(endpoint->bInterval*8);
  60.                         pr_info("%s: Fixing fullspeed to highspeed interval: %d -> %d\n",
  61.                                 hid->name, endpoint->bInterval, interval);
  62.                 }
  63.  
  64.                 /* Change the polling interval of mice and joysticks. */
  65.                 switch (hid->collection->usage) {
  66.                 case HID_GD_MOUSE:
  67.                         if (hid_mousepoll_interval > 0)
  68.                                 interval = hid_mousepoll_interval;
  69.                         break;
  70.                 case HID_GD_JOYSTICK:
  71.                         if (hid_jspoll_interval > 0)
  72.                                 interval = hid_jspoll_interval;
  73.                         break;
  74.                 }
  75.  
  76.                 ret = -ENOMEM;
  77.                 if (usb_endpoint_dir_in(endpoint)) {
  78.                         if (usbhid->urbin)
  79.                                 continue;
  80.                         if (!(usbhid->urbin = usb_alloc_urb(0, GFP_KERNEL)))
  81.                                 goto fail;
  82.                         pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
  83.                         usb_fill_int_urb(usbhid->urbin, dev, pipe, usbhid->inbuf, insize,
  84.                                          hid_irq_in, hid, interval); //中断函数hid_irq_in
  85.                         usbhid->urbin->transfer_dma = usbhid->inbuf_dma;
  86.                         usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  87.                 } else {
  88.                         if (usbhid->urbout)
  89.                                 continue;
  90.                         if (!(usbhid->urbout = usb_alloc_urb(0, GFP_KERNEL)))
  91.                                 goto fail;
  92.                         pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress);
  93.                         usb_fill_int_urb(usbhid->urbout, dev, pipe, usbhid->outbuf, 0,
  94.                                          hid_irq_out, hid, interval);
  95.                         usbhid->urbout->transfer_dma = usbhid->outbuf_dma;
  96.                         usbhid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  97.                 }
  98.         }
  99.  
  100.         usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL);
  101.         if (!usbhid->urbctrl) {
  102.                 ret = -ENOMEM;
  103.                 goto fail;
  104.         }
  105.  
  106.         usb_fill_control_urb(usbhid->urbctrl, dev, 0, (void *) usbhid->cr,
  107.                              usbhid->ctrlbuf, 1, hid_ctrl, hid);
  108.         usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma;
  109.         usbhid->urbctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  110.  
  111.         set_bit(HID_STARTED, &usbhid->iofl);
  112.  
  113.         if (hid->quirks & HID_QUIRK_ALWAYS_POLL) {
  114.                 ret = usb_autopm_get_interface(usbhid->intf);
  115.                 if (ret)
  116.                         goto fail;
  117.                 set_bit(HID_IN_POLLING, &usbhid->iofl);
  118.                 usbhid->intf->needs_remote_wakeup = 1;
  119.                 ret = hid_start_in(hid);
  120.                 if (ret) {
  121.                         dev_err(&hid->dev,
  122.                                 "failed to start in urb: %d\n", ret);
  123.                 }
  124.                 usb_autopm_put_interface(usbhid->intf);
  125.         }
  126.  
  127.         /* Some keyboards don't work until their LEDs have been set.
  128.          * Since BIOSes do set the LEDs, it must be safe for any device
  129.          * that supports the keyboard boot protocol.
  130.          * In addition, enable remote wakeup by default for all keyboard
  131.          * devices supporting the boot protocol.
  132.          */
  133.         if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT &&
  134.                         interface->desc.bInterfaceProtocol ==
  135.                                 USB_INTERFACE_PROTOCOL_KEYBOARD) {
  136.                 usbhid_set_leds(hid);
  137.                 device_set_wakeup_enable(&dev->dev, 1);
  138.         }
  139.         return 0;
  140.  
  141. fail:
  142.         usb_free_urb(usbhid->urbin);
  143.         usb_free_urb(usbhid->urbout);
  144.         usb_free_urb(usbhid->urbctrl);
  145.         usbhid->urbin = NULL;
  146.         usbhid->urbout = NULL;
  147.         usbhid->urbctrl = NULL;
  148.         hid_free_buffers(dev, hid);
  149.         return ret;
  150. }
  151.  
  152. /*
  153.  * Input interrupt completion handler.
  154.  */
  155. static void hid_irq_in(struct urb *urb)
  156. {
  157.         struct hid_device       *hid = urb->context;
  158.         struct usbhid_device    *usbhid = hid->driver_data;
  159.         int                     status;
  160.  
  161.         switch (urb->status) {
  162.         case 0:                 /* success */
  163.                 usbhid->retry_delay = 0;
  164.                 if (!test_bit(HID_OPENED, &usbhid->iofl))
  165.                         break;
  166.                 usbhid_mark_busy(usbhid);
  167.                 if (!test_bit(HID_RESUME_RUNNING, &usbhid->iofl)) {
  168.                         //hid_input_report--->
  169.                         hid_input_report(urb->context, HID_INPUT_REPORT,
  170.                                          urb->transfer_buffer,
  171.                                          urb->actual_length, 1);
  172.                         /*
  173.                          * autosuspend refused while keys are pressed
  174.                          * because most keyboards don't wake up when
  175.                          * a key is released
  176.                          */
  177.                         if (hid_check_keys_pressed(hid))
  178.                                 set_bit(HID_KEYS_PRESSED, &usbhid->iofl);
  179.                         else
  180.                                 clear_bit(HID_KEYS_PRESSED, &usbhid->iofl);
  181.                 }
  182.                 break;
  183.         case -EPIPE:            /* stall */
  184.                 usbhid_mark_busy(usbhid);
  185.                 clear_bit(HID_IN_RUNNING, &usbhid->iofl);
  186.                 set_bit(HID_CLEAR_HALT, &usbhid->iofl);
  187.                 schedule_work(&usbhid->reset_work);
  188.                 return;
  189.         case -ECONNRESET:       /* unlink */
  190.         case -ENOENT:
  191.         case -ESHUTDOWN:        /* unplug */
  192.                 clear_bit(HID_IN_RUNNING, &usbhid->iofl);
  193.                 return;
  194.         case -EILSEQ:           /* protocol error or unplug */
  195.         case -EPROTO:           /* protocol error or unplug */
  196.         case -ETIME:            /* protocol error or unplug */
  197.         case -ETIMEDOUT:        /* Should never happen, but... */
  198.                 usbhid_mark_busy(usbhid);
  199.                 clear_bit(HID_IN_RUNNING, &usbhid->iofl);
  200.                 hid_io_error(hid);
  201.                 return;
  202.         default:                /* error */
  203.                 hid_warn(urb->dev, "input irq status %d received\n",
  204.                          urb->status);
  205.         }    
  206.  
  207.         status = usb_submit_urb(urb, GFP_ATOMIC);
  208.         if (status) {
  209.                 clear_bit(HID_IN_RUNNING, &usbhid->iofl);
  210.                 if (status != -EPERM) {
  211.                         hid_err(hid, "can't resubmit intr, %s-%s/input%d, status %d\n",
  212.                                 hid_to_usb_dev(hid)->bus->bus_name,
  213.                                 hid_to_usb_dev(hid)->devpath,
  214.                                 usbhid->ifnum, status);
  215.                         hid_io_error(hid);
  216.                 }    
  217.         }    
  218. }
  219.  
  220. int hid_input_report(struct hid_device *hid, int type, u8 *data, u32 size, int interrupt)
  221. {
  222. 	struct hid_report_enum *report_enum;
  223. 	struct hid_driver *hdrv;
  224. 	struct hid_report *report;
  225. 	int ret = 0;
  226.  
  227. 	if (!hid)
  228. 		return -ENODEV;
  229.  
  230. 	if (down_trylock(&hid->driver_input_lock))
  231. 		return -EBUSY;
  232.  
  233. 	if (!hid->driver) {
  234. 		ret = -ENODEV;
  235. 		goto unlock;
  236. 	}
  237. 	report_enum = hid->report_enum + type;
  238. 	hdrv = hid->driver;
  239.  
  240. 	if (!size) {
  241. 		dbg_hid("empty report\n");
  242. 		ret = -1;
  243. 		goto unlock;
  244. 	}
  245.  
  246. 	/* Avoid unnecessary overhead if debugfs is disabled */
  247. 	if (!list_empty(&hid->debug_list))
  248. 		hid_dump_report(hid, type, data, size);
  249.  
  250. 	report = hid_get_report(report_enum, data);
  251.  
  252. 	if (!report) {
  253. 		ret = -1;
  254. 		goto unlock;
  255. 	}
  256.  
  257. 	if (hdrv && hdrv->raw_event && hid_match_report(hid, report)) {
  258. 		ret = hdrv->raw_event(hid, report, data, size);
  259. 		if (ret < 0)
  260. 			goto unlock;
  261. 	}
  262.  
  263. 	ret = hid_report_raw_event(hid, type, data, size, interrupt);//--->
  264.  
  265. unlock:
  266. 	up(&hid->driver_input_lock);
  267. 	return ret;
  268. }
  269.  
  270. int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size,
  271. 		int interrupt)
  272. {
  273. 	struct hid_report_enum *report_enum = hid->report_enum + type;
  274. 	struct hid_report *report;
  275. 	struct hid_driver *hdrv;
  276. 	unsigned int a;
  277. 	u32 rsize, csize = size;
  278. 	u8 *cdata = data;
  279. 	int ret = 0;
  280.  
  281. 	report = hid_get_report(report_enum, data);
  282. 	if (!report)
  283. 		goto out;
  284.  
  285. 	if (report_enum->numbered) {
  286. 		cdata++;
  287. 		csize--;
  288. 	}
  289.  
  290. 	rsize = ((report->size - 1) >> 3) + 1;
  291.  
  292. 	if (rsize > HID_MAX_BUFFER_SIZE)
  293. 		rsize = HID_MAX_BUFFER_SIZE;
  294.  
  295. 	if (csize < rsize) {
  296. 		dbg_hid("report %d is too short, (%d < %d)\n", report->id,
  297. 				csize, rsize);
  298. 		memset(cdata + csize, 0, rsize - csize);
  299. 	}
  300.  
  301. 	if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
  302. 		hid->hiddev_report_event(hid, report);
  303. 	if (hid->claimed & HID_CLAIMED_HIDRAW) {
  304. 		ret = hidraw_report_event(hid, data, size);
  305. 		if (ret)
  306. 			goto out;
  307. 	}
  308.  
  309. 	if (hid->claimed != HID_CLAIMED_HIDRAW && report->maxfield) {
  310. 		for (a = 0; a < report->maxfield; a++)
  311. 			hid_input_field(hid, report->field[a], cdata, interrupt);
  312. 		hdrv = hid->driver;
  313. 		if (hdrv && hdrv->report)
  314. 			hdrv->report(hid, report);
  315. 	}
  316.  
  317. 	if (hid->claimed & HID_CLAIMED_INPUT)
  318. 		hidinput_report_event(hid, report); //--->
  319. out:
  320. 	return ret;
  321. }
  322.  
  323. void hidinput_report_event(struct hid_device *hid, struct hid_report *report)
  324. {
  325. 	struct hid_input *hidinput;
  326.  
  327. 	if (hid->quirks & HID_QUIRK_NO_INPUT_SYNC)
  328. 		return;
  329.  
  330. 	list_for_each_entry(hidinput, &hid->inputs, list)
  331. 		input_sync(hidinput->input); //上报数据至input-core层
  332. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/327219?site
推荐阅读
相关标签

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

  

闽ICP备14008679号