18 #include <linux/module.h>
19 #include <linux/slab.h>
21 #include <linux/kernel.h>
22 #include <linux/list.h>
26 #include <asm/unaligned.h>
27 #include <asm/byteorder.h>
28 #include <linux/input.h>
29 #include <linux/wait.h>
31 #include <linux/string.h>
35 #include <linux/hid.h>
36 #include <linux/hiddev.h>
38 #include <linux/hidraw.h>
45 #define DRIVER_DESC "USB HID core driver"
46 #define DRIVER_LICENSE "GPL"
52 static unsigned int hid_mousepoll_interval;
56 static unsigned int ignoreled;
64 " quirks=vendorID:productID:quirks"
65 " where vendorID, productID, and quirks are all in"
72 static void hid_io_error(
struct hid_device *hid);
73 static int hid_submit_out(
struct hid_device *hid);
74 static int hid_submit_ctrl(
struct hid_device *hid);
75 static void hid_cancel_delayed_stuff(
struct usbhid_device *usbhid);
78 static int hid_start_in(
struct hid_device *hid)
98 spin_unlock_irqrestore(&usbhid->
lock, flags);
103 static void hid_retry_timeout(
unsigned long _hid)
108 dev_dbg(&usbhid->
intf->dev,
"retrying intr urb\n");
109 if (hid_start_in(hid))
144 hid_err(hid,
"can't reset device, %s-%s/input%d, status %d\n",
157 static void hid_io_error(
struct hid_device *hid)
194 spin_unlock_irqrestore(&usbhid->
lock, flags);
201 usb_mark_last_busy(interface_to_usbdev(intf));
204 static int usbhid_restart_out_queue(
struct usbhid_device *usbhid)
218 r = usb_autopm_get_interface_async(usbhid->
intf);
227 usb_autopm_put_interface_no_suspend(usbhid->
intf);
233 if (hid_submit_out(hid)) {
235 usb_autopm_put_interface_async(usbhid->
intf);
242 static int usbhid_restart_ctrl_queue(
struct usbhid_device *usbhid)
257 r = usb_autopm_get_interface_async(usbhid->
intf);
266 usb_autopm_put_interface_no_suspend(usbhid->
intf);
272 if (hid_submit_ctrl(hid)) {
274 usb_autopm_put_interface_async(usbhid->
intf);
285 static void hid_irq_in(
struct urb *
urb)
291 switch (urb->status) {
293 usbhid_mark_busy(usbhid);
296 urb->transfer_buffer,
297 urb->actual_length, 1);
309 usbhid_mark_busy(usbhid);
323 usbhid_mark_busy(usbhid);
328 hid_warn(urb->dev,
"input irq status %d received\n",
335 if (status != -
EPERM) {
336 hid_err(hid,
"can't resubmit intr, %s-%s/input%d, status %d\n",
339 usbhid->
ifnum, status);
345 static int hid_submit_out(
struct hid_device *hid)
353 raw_report = usbhid->
out[usbhid->
outtail].raw_report;
355 usbhid->
urbout->transfer_buffer_length = ((report->
size - 1) >> 3) +
356 1 + (report->
id > 0);
360 usbhid->
urbout->transfer_buffer_length);
365 dbg_hid(
"submitting out urb\n");
369 hid_err(hid,
"usb_submit_urb(out) failed: %d\n", r);
376 static int hid_submit_ctrl(
struct hid_device *hid)
388 len = ((report->
size - 1) >> 3) + 1 + (report->
id > 0);
391 usbhid->
urbctrl->transfer_buffer_length = len;
398 int maxpacket, padlen;
410 usbhid->
urbctrl->transfer_buffer_length = padlen;
422 dbg_hid(
"submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u\n",
425 usbhid->
cr->wValue, usbhid->
cr->wIndex, usbhid->
cr->wLength);
429 hid_err(hid,
"usb_submit_urb(ctrl) failed: %d\n", r);
440 static void hid_irq_out(
struct urb *urb)
447 switch (urb->status) {
458 hid_warn(urb->dev,
"output irq status %d received\n",
470 hid_submit_out(hid) == 0) {
472 spin_unlock_irqrestore(&usbhid->
lock, flags);
478 spin_unlock_irqrestore(&usbhid->
lock, flags);
479 usb_autopm_put_interface_async(usbhid->
intf);
487 static void hid_ctrl(
struct urb *urb)
491 int unplug = 0, status = urb->status;
493 spin_lock(&usbhid->
lock);
500 urb->transfer_buffer, urb->actual_length, 0);
511 hid_warn(urb->dev,
"ctrl urb status %d received\n", status);
520 hid_submit_ctrl(hid) == 0) {
522 spin_unlock(&usbhid->
lock);
528 spin_unlock(&usbhid->
lock);
529 usb_autopm_put_interface_async(usbhid->
intf);
538 int len = ((report->
size - 1) >> 3) + 1 + (report->
id > 0);
545 hid_warn(hid,
"output queue full\n");
550 if (!usbhid->
out[usbhid->
outhead].raw_report) {
551 hid_warn(hid,
"output queueing failed\n");
560 usbhid_restart_out_queue(usbhid);
566 usb_autopm_get_interface_no_resume(usbhid->
intf);
576 spin_unlock(&usbhid->
lock);
579 spin_lock(&usbhid->
lock);
580 usb_unblock_urb(usbhid->
urbout);
584 usbhid_restart_out_queue(usbhid);
587 usb_autopm_put_interface_async(usbhid->
intf);
593 hid_warn(hid,
"control queue full\n");
600 hid_warn(hid,
"control queueing failed\n");
611 usbhid_restart_ctrl_queue(usbhid);
617 usb_autopm_get_interface_no_resume(usbhid->
intf);
627 spin_unlock(&usbhid->
lock);
630 spin_lock(&usbhid->
lock);
631 usb_unblock_urb(usbhid->
urbctrl);
635 usbhid_restart_ctrl_queue(usbhid);
638 usb_autopm_put_interface_async(usbhid->
intf);
648 __usbhid_submit_report(hid, report, dir);
649 spin_unlock_irqrestore(&usbhid->
lock, flags);
664 hid_warn(hid,
"LED event field not found\n");
674 spin_unlock_irqrestore(&usbhid->
lock, flags);
677 static int usb_hidinput_input_event(
struct input_dev *
dev,
unsigned int type,
unsigned int code,
int value)
679 struct hid_device *hid = input_get_drvdata(dev);
686 return input_ff_event(dev, type, code, value);
692 hid_warn(dev,
"event field not found\n");
698 spin_unlock_irqrestore(&usbhid->
lock, flags);
717 dbg_hid(
"timeout waiting for ctrl or out queue to clear\n");
725 static int hid_set_idle(
struct usb_device *dev,
int ifnum,
int report,
int idle)
729 ifnum,
NULL, 0, USB_CTRL_SET_TIMEOUT);
732 static int hid_get_class_descriptor(
struct usb_device *dev,
int ifnum,
733 unsigned char type,
void *
buf,
int size)
742 (type << 8), ifnum, buf, size, USB_CTRL_GET_TIMEOUT);
744 }
while (result < size && retries);
755 res = usb_autopm_get_interface(usbhid->
intf);
762 usbhid->
intf->needs_remote_wakeup = 1;
763 res = hid_start_in(hid);
772 usbhid->
intf->needs_remote_wakeup = 0;
775 usb_autopm_put_interface(usbhid->
intf);
792 spin_lock_irq(&usbhid->
lock);
794 spin_unlock_irq(&usbhid->
lock);
795 hid_cancel_delayed_stuff(usbhid);
797 usbhid->
intf->needs_remote_wakeup = 0;
799 spin_unlock_irq(&usbhid->
lock);
832 hid_warn(hid,
"timeout initializing reports\n");
838 static int hid_find_field_early(
struct hid_device *hid,
unsigned int page,
839 unsigned int hid_code,
struct hid_field **pfield)
847 for (i = 0; i < report->
maxfield; i++) {
849 for (j = 0; j < field->
maxusage; j++) {
852 (usage->
hid & 0xFFFF) == hid_code) {
867 if ((offset = hid_find_field_early(hid,
HID_UP_LED, 0x01, &field)) != -1) {
877 static void hid_find_max_report(
struct hid_device *hid,
unsigned int type,
890 static int hid_alloc_buffers(
struct usb_device *dev,
struct hid_device *hid)
908 static int usbhid_get_raw_report(
struct hid_device *hid,
910 unsigned char report_type)
915 struct usb_host_interface *
interface = intf->cur_altsetting;
916 int skipped_report_id = 0;
921 if (report_number == 0x0) {
926 skipped_report_id = 1;
931 ((report_type + 1) << 8) | report_number,
932 interface->desc.bInterfaceNumber, buf, count,
933 USB_CTRL_SET_TIMEOUT);
936 if (ret > 0 && skipped_report_id)
942 static int usbhid_output_raw_report(
struct hid_device *hid,
__u8 *buf,
size_t count,
943 unsigned char report_type)
948 struct usb_host_interface *
interface = intf->cur_altsetting;
953 int skipped_report_id = 0;
959 skipped_report_id = 1;
962 buf, count, &actual_length,
963 USB_CTRL_SET_TIMEOUT);
968 if (skipped_report_id)
972 int skipped_report_id = 0;
973 int report_id = buf[0];
978 skipped_report_id = 1;
983 ((report_type + 1) << 8) | report_id,
984 interface->desc.bInterfaceNumber, buf, count,
985 USB_CTRL_SET_TIMEOUT);
987 if (ret > 0 && skipped_report_id)
994 static void usbhid_restart_queues(
struct usbhid_device *usbhid)
997 usbhid_restart_out_queue(usbhid);
999 usbhid_restart_ctrl_queue(usbhid);
1002 static void hid_free_buffers(
struct usb_device *dev,
struct hid_device *hid)
1012 static int usbhid_parse(
struct hid_device *hid)
1015 struct usb_host_interface *
interface = intf->cur_altsetting;
1016 struct usb_device *dev = interface_to_usbdev (intf);
1019 unsigned int rsize = 0;
1040 dbg_hid(
"class descriptor not present\n");
1052 dbg_hid(
"weird size of report descriptor (%u)\n", rsize);
1057 dbg_hid(
"couldn't allocate rdesc memory\n");
1061 hid_set_idle(dev,
interface->desc.bInterfaceNumber, 0, 0);
1063 ret = hid_get_class_descriptor(dev,
interface->desc.bInterfaceNumber,
1066 dbg_hid(
"reading report descriptor failed\n");
1074 dbg_hid(
"parsing report descriptor failed\n");
1085 static int usbhid_start(
struct hid_device *hid)
1088 struct usb_host_interface *
interface = intf->cur_altsetting;
1089 struct usb_device *dev = interface_to_usbdev(intf);
1091 unsigned int n, insize = 0;
1109 if (hid_alloc_buffers(dev, hid)) {
1114 for (n = 0; n <
interface->desc.bNumEndpoints; n++) {
1120 if (!usb_endpoint_xfer_int(endpoint))
1129 printk(
KERN_INFO "%s: Fixing fullspeed to highspeed interval: %d -> %d\n",
1135 interval = hid_mousepoll_interval;
1138 if (usb_endpoint_dir_in(endpoint)) {
1144 usb_fill_int_urb(usbhid->
urbin, dev, pipe, usbhid->
inbuf, insize,
1145 hid_irq_in, hid, interval);
1147 usbhid->
urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1154 usb_fill_int_urb(usbhid->
urbout, dev, pipe, usbhid->
outbuf, 0,
1155 hid_irq_out, hid, interval);
1157 usbhid->
urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1167 usb_fill_control_urb(usbhid->
urbctrl, dev, 0, (
void *) usbhid->
cr,
1168 usbhid->
ctrlbuf, 1, hid_ctrl, hid);
1170 usbhid->
urbctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1198 hid_free_buffers(dev, hid);
1202 static void usbhid_stop(
struct hid_device *hid)
1210 spin_lock_irq(&usbhid->
lock);
1212 spin_unlock_irq(&usbhid->
lock);
1217 hid_cancel_delayed_stuff(usbhid);
1231 static int usbhid_power(
struct hid_device *hid,
int lvl)
1247 .parse = usbhid_parse,
1248 .start = usbhid_start,
1249 .stop = usbhid_stop,
1252 .power = usbhid_power,
1253 .hidinput_input_event = usb_hidinput_input_event,
1258 struct usb_host_interface *
interface = intf->cur_altsetting;
1259 struct usb_device *dev = interface_to_usbdev(intf);
1262 unsigned int n, has_in = 0;
1266 dbg_hid(
"HID probe called for ifnum %d\n",
1267 intf->altsetting->desc.bInterfaceNumber);
1269 for (n = 0; n <
interface->desc.bNumEndpoints; n++)
1270 if (usb_endpoint_is_int_in(&
interface->endpoint[n].desc))
1273 hid_err(intf,
"couldn't find an input interrupt endpoint\n");
1279 return PTR_ERR(hid);
1281 usb_set_intfdata(intf, hid);
1286 #ifdef CONFIG_USB_HIDDEV
1292 hid->
dev.parent = &intf->dev;
1298 if (intf->cur_altsetting->desc.bInterfaceProtocol ==
1301 else if (intf->cur_altsetting->desc.bInterfaceProtocol == 0)
1304 if (dev->manufacturer)
1308 if (dev->manufacturer)
1318 usb_make_path(dev, hid->
phys,
sizeof(hid->
phys));
1321 if (len <
sizeof(hid->
phys) - 1)
1323 "%d", intf->altsetting[0].desc.bInterfaceNumber);
1325 if (
usb_string(dev, dev->descriptor.iSerialNumber, hid->
uniq, 64) <= 0)
1328 usbhid = kzalloc(
sizeof(*usbhid),
GFP_KERNEL);
1329 if (usbhid ==
NULL) {
1349 hid_err(intf,
"can't add hid device: %d\n", ret);
1363 struct hid_device *hid = usb_get_intfdata(intf);
1374 static void hid_cancel_delayed_stuff(
struct usbhid_device *usbhid)
1392 struct hid_device *hid = usb_get_intfdata(intf);
1395 spin_lock_irq(&usbhid->
lock);
1397 spin_unlock_irq(&usbhid->
lock);
1398 hid_cease_io(usbhid);
1406 struct usb_device *dev = interface_to_usbdev (intf);
1407 struct hid_device *hid = usb_get_intfdata(intf);
1409 struct usb_host_interface *
interface = intf->cur_altsetting;
1420 dbg_hid(
"couldn't allocate rdesc memory (post_reset)\n");
1423 status = hid_get_class_descriptor(dev,
1427 dbg_hid(
"reading report descriptor failed (post_reset)\n");
1434 dbg_hid(
"report descriptor changed\n");
1438 spin_lock_irq(&usbhid->
lock);
1440 spin_unlock_irq(&usbhid->
lock);
1441 hid_set_idle(dev, intf->cur_altsetting->desc.bInterfaceNumber, 0, 0);
1442 status = hid_start_in(hid);
1445 usbhid_restart_queues(usbhid);
1454 return usb_autopm_get_interface(usbhid->
intf);
1461 usb_autopm_put_interface(usbhid->
intf);
1466 static int hid_resume_common(
struct hid_device *hid,
bool driver_suspended)
1471 spin_lock_irq(&usbhid->
lock);
1473 usbhid_mark_busy(usbhid);
1480 usbhid_restart_queues(usbhid);
1481 spin_unlock_irq(&usbhid->
lock);
1483 status = hid_start_in(hid);
1487 if (driver_suspended && hid->
driver && hid->
driver->resume)
1488 status = hid->
driver->resume(hid);
1494 struct hid_device *hid = usb_get_intfdata(intf);
1497 bool driver_suspended =
false;
1500 spin_lock_irq(&usbhid->
lock);
1506 && (!usbhid->
ledcount || ignoreled))
1509 spin_unlock_irq(&usbhid->
lock);
1511 status = hid->
driver->suspend(hid, message);
1515 driver_suspended =
true;
1517 usbhid_mark_busy(usbhid);
1518 spin_unlock_irq(&usbhid->
lock);
1524 status = hid->
driver->suspend(hid, message);
1528 driver_suspended =
true;
1529 spin_lock_irq(&usbhid->
lock);
1531 spin_unlock_irq(&usbhid->
lock);
1538 hid_cancel_delayed_stuff(usbhid);
1539 hid_cease_io(usbhid);
1546 dev_dbg(&intf->dev,
"suspend\n");
1550 hid_resume_common(hid, driver_suspended);
1556 struct hid_device *hid = usb_get_intfdata (intf);
1563 status = hid_resume_common(hid,
true);
1564 dev_dbg(&intf->dev,
"resume status %d\n", status);
1570 struct hid_device *hid = usb_get_intfdata(intf);
1575 status = hid_post_reset(intf);
1576 if (status >= 0 && hid->
driver && hid->
driver->reset_resume) {
1577 int ret = hid->
driver->reset_resume(hid);
1596 .probe = usbhid_probe,
1597 .disconnect = usbhid_disconnect,
1599 .suspend = hid_suspend,
1600 .resume = hid_resume,
1601 .reset_resume = hid_reset_resume,
1603 .pre_reset = hid_pre_reset,
1604 .post_reset = hid_post_reset,
1605 .id_table = hid_usb_ids,
1606 .supports_autosuspend = 1,
1614 static int __init hid_init(
void)
1620 goto usbhid_quirks_init_fail;
1621 retval = usb_register(&hid_driver);
1623 goto usb_register_fail;
1629 usbhid_quirks_init_fail:
1633 static void __exit hid_exit(
void)