1 /* 2 * USB HID support for Linux 3 * 4 * Copyright (c) 1999 Andreas Gal 5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz> 6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc 7 * Copyright (c) 2007-2008 Oliver Neukum 8 * Copyright (c) 2006-2010 Jiri Kosina 9 */ 10 11 /* 12 * This program is free software; you can redistribute it and/or modify it 13 * under the terms of the GNU General Public License as published by the Free 14 * Software Foundation; either version 2 of the License, or (at your option) 15 * any later version. 16 */ 17 18 #include <linux/module.h> 19 #include <linux/slab.h> 20 #include <linux/init.h> 21 #include <linux/kernel.h> 22 #include <linux/list.h> 23 #include <linux/mm.h> 24 #include <linux/mutex.h> 25 #include <linux/spinlock.h> 26 #include <asm/unaligned.h> 27 #include <asm/byteorder.h> 28 #include <linux/input.h> 29 #include <linux/wait.h> 30 #include <linux/workqueue.h> 31 #include <linux/string.h> 32 33 #include <linux/usb.h> 34 35 #include <linux/hid.h> 36 #include <linux/hiddev.h> 37 #include <linux/hid-debug.h> 38 #include <linux/hidraw.h> 39 #include "usbhid.h" 40 41 /* 42 * Version Information 43 */ 44 45 #define DRIVER_DESC "USB HID core driver" 46 #define DRIVER_LICENSE "GPL" 47 48 /* 49 * Module parameters. 50 */ 51 52 static unsigned int hid_mousepoll_interval; 53 module_param_named(mousepoll, hid_mousepoll_interval, uint, 0644); 54 MODULE_PARM_DESC(mousepoll, "Polling interval of mice"); 55 56 static unsigned int ignoreled; 57 module_param_named(ignoreled, ignoreled, uint, 0644); 58 MODULE_PARM_DESC(ignoreled, "Autosuspend with active leds"); 59 60 /* Quirks specified at module load time */ 61 static char *quirks_param[MAX_USBHID_BOOT_QUIRKS]; 62 module_param_array_named(quirks, quirks_param, charp, NULL, 0444); 63 MODULE_PARM_DESC(quirks, "Add/modify USB HID quirks by specifying " 64 " quirks=vendorID:productID:quirks" 65 " where vendorID, productID, and quirks are all in" 66 " 0x-prefixed hex"); 67 /* 68 * Input submission and I/O error handler. 69 */ 70 static DEFINE_MUTEX(hid_open_mut); 71 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); 76 77 /* Start up the input URB */ 78 static int hid_start_in(struct hid_device *hid) 79 { 80 unsigned long flags; 81 int rc = 0; 82 struct usbhid_device *usbhid = hid->driver_data; 83 84 spin_lock_irqsave(&usbhid->lock, flags); 85 if ((hid->open > 0 || hid->quirks & HID_QUIRK_ALWAYS_POLL) && 86 !test_bit(HID_DISCONNECTED, &usbhid->iofl) && 87 !test_bit(HID_SUSPENDED, &usbhid->iofl) && 88 !test_and_set_bit(HID_IN_RUNNING, &usbhid->iofl)) { 89 rc = usb_submit_urb(usbhid->urbin, GFP_ATOMIC); 90 if (rc != 0) { 91 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 92 if (rc == -ENOSPC) 93 set_bit(HID_NO_BANDWIDTH, &usbhid->iofl); 94 } else { 95 clear_bit(HID_NO_BANDWIDTH, &usbhid->iofl); 96 } 97 } 98 spin_unlock_irqrestore(&usbhid->lock, flags); 99 return rc; 100 } 101 102 /* I/O retry timer routine */ 103 static void hid_retry_timeout(unsigned long _hid) 104 { 105 struct hid_device *hid = (struct hid_device *) _hid; 106 struct usbhid_device *usbhid = hid->driver_data; 107 108 dev_dbg(&usbhid->intf->dev, "retrying intr urb\n"); 109 if (hid_start_in(hid)) 110 hid_io_error(hid); 111 } 112 113 /* Workqueue routine to reset the device or clear a halt */ 114 static void hid_reset(struct work_struct *work) 115 { 116 struct usbhid_device *usbhid = 117 container_of(work, struct usbhid_device, reset_work); 118 struct hid_device *hid = usbhid->hid; 119 int rc; 120 121 if (test_bit(HID_CLEAR_HALT, &usbhid->iofl)) { 122 dev_dbg(&usbhid->intf->dev, "clear halt\n"); 123 rc = usb_clear_halt(hid_to_usb_dev(hid), usbhid->urbin->pipe); 124 clear_bit(HID_CLEAR_HALT, &usbhid->iofl); 125 if (rc == 0) { 126 hid_start_in(hid); 127 } else { 128 dev_dbg(&usbhid->intf->dev, 129 "clear-halt failed: %d\n", rc); 130 set_bit(HID_RESET_PENDING, &usbhid->iofl); 131 } 132 } 133 134 if (test_bit(HID_RESET_PENDING, &usbhid->iofl)) { 135 dev_dbg(&usbhid->intf->dev, "resetting device\n"); 136 usb_queue_reset_device(usbhid->intf); 137 } 138 } 139 140 /* Main I/O error handler */ 141 static void hid_io_error(struct hid_device *hid) 142 { 143 unsigned long flags; 144 struct usbhid_device *usbhid = hid->driver_data; 145 146 spin_lock_irqsave(&usbhid->lock, flags); 147 148 /* Stop when disconnected */ 149 if (test_bit(HID_DISCONNECTED, &usbhid->iofl)) 150 goto done; 151 152 /* If it has been a while since the last error, we'll assume 153 * this a brand new error and reset the retry timeout. */ 154 if (time_after(jiffies, usbhid->stop_retry + HZ/2)) 155 usbhid->retry_delay = 0; 156 157 /* When an error occurs, retry at increasing intervals */ 158 if (usbhid->retry_delay == 0) { 159 usbhid->retry_delay = 13; /* Then 26, 52, 104, 104, ... */ 160 usbhid->stop_retry = jiffies + msecs_to_jiffies(1000); 161 } else if (usbhid->retry_delay < 100) 162 usbhid->retry_delay *= 2; 163 164 if (time_after(jiffies, usbhid->stop_retry)) { 165 166 /* Retries failed, so do a port reset unless we lack bandwidth*/ 167 if (!test_bit(HID_NO_BANDWIDTH, &usbhid->iofl) 168 && !test_and_set_bit(HID_RESET_PENDING, &usbhid->iofl)) { 169 170 schedule_work(&usbhid->reset_work); 171 goto done; 172 } 173 } 174 175 mod_timer(&usbhid->io_retry, 176 jiffies + msecs_to_jiffies(usbhid->retry_delay)); 177 done: 178 spin_unlock_irqrestore(&usbhid->lock, flags); 179 } 180 181 static void usbhid_mark_busy(struct usbhid_device *usbhid) 182 { 183 struct usb_interface *intf = usbhid->intf; 184 185 usb_mark_last_busy(interface_to_usbdev(intf)); 186 } 187 188 static int usbhid_restart_out_queue(struct usbhid_device *usbhid) 189 { 190 struct hid_device *hid = usb_get_intfdata(usbhid->intf); 191 int kicked; 192 int r; 193 194 if (!hid || test_bit(HID_RESET_PENDING, &usbhid->iofl) || 195 test_bit(HID_SUSPENDED, &usbhid->iofl)) 196 return 0; 197 198 if ((kicked = (usbhid->outhead != usbhid->outtail))) { 199 hid_dbg(hid, "Kicking head %d tail %d", usbhid->outhead, usbhid->outtail); 200 201 /* Try to wake up from autosuspend... */ 202 r = usb_autopm_get_interface_async(usbhid->intf); 203 if (r < 0) 204 return r; 205 206 /* 207 * If still suspended, don't submit. Submission will 208 * occur if/when resume drains the queue. 209 */ 210 if (test_bit(HID_SUSPENDED, &usbhid->iofl)) { 211 usb_autopm_put_interface_no_suspend(usbhid->intf); 212 return r; 213 } 214 215 /* Asynchronously flush queue. */ 216 set_bit(HID_OUT_RUNNING, &usbhid->iofl); 217 if (hid_submit_out(hid)) { 218 clear_bit(HID_OUT_RUNNING, &usbhid->iofl); 219 usb_autopm_put_interface_async(usbhid->intf); 220 } 221 wake_up(&usbhid->wait); 222 } 223 return kicked; 224 } 225 226 static int usbhid_restart_ctrl_queue(struct usbhid_device *usbhid) 227 { 228 struct hid_device *hid = usb_get_intfdata(usbhid->intf); 229 int kicked; 230 int r; 231 232 WARN_ON(hid == NULL); 233 if (!hid || test_bit(HID_RESET_PENDING, &usbhid->iofl) || 234 test_bit(HID_SUSPENDED, &usbhid->iofl)) 235 return 0; 236 237 if ((kicked = (usbhid->ctrlhead != usbhid->ctrltail))) { 238 hid_dbg(hid, "Kicking head %d tail %d", usbhid->ctrlhead, usbhid->ctrltail); 239 240 /* Try to wake up from autosuspend... */ 241 r = usb_autopm_get_interface_async(usbhid->intf); 242 if (r < 0) 243 return r; 244 245 /* 246 * If still suspended, don't submit. Submission will 247 * occur if/when resume drains the queue. 248 */ 249 if (test_bit(HID_SUSPENDED, &usbhid->iofl)) { 250 usb_autopm_put_interface_no_suspend(usbhid->intf); 251 return r; 252 } 253 254 /* Asynchronously flush queue. */ 255 set_bit(HID_CTRL_RUNNING, &usbhid->iofl); 256 if (hid_submit_ctrl(hid)) { 257 clear_bit(HID_CTRL_RUNNING, &usbhid->iofl); 258 usb_autopm_put_interface_async(usbhid->intf); 259 } 260 wake_up(&usbhid->wait); 261 } 262 return kicked; 263 } 264 265 /* 266 * Input interrupt completion handler. 267 */ 268 269 static void hid_irq_in(struct urb *urb) 270 { 271 struct hid_device *hid = urb->context; 272 struct usbhid_device *usbhid = hid->driver_data; 273 int status; 274 275 switch (urb->status) { 276 case 0: /* success */ 277 usbhid_mark_busy(usbhid); 278 usbhid->retry_delay = 0; 279 if ((hid->quirks & HID_QUIRK_ALWAYS_POLL) && !hid->open) 280 break; 281 if (!test_bit(HID_RESUME_RUNNING, &usbhid->iofl)) { 282 hid_input_report(urb->context, HID_INPUT_REPORT, 283 urb->transfer_buffer, 284 urb->actual_length, 1); 285 /* 286 * autosuspend refused while keys are pressed 287 * because most keyboards don't wake up when 288 * a key is released 289 */ 290 if (hid_check_keys_pressed(hid)) 291 set_bit(HID_KEYS_PRESSED, &usbhid->iofl); 292 else 293 clear_bit(HID_KEYS_PRESSED, &usbhid->iofl); 294 } 295 break; 296 case -EPIPE: /* stall */ 297 usbhid_mark_busy(usbhid); 298 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 299 set_bit(HID_CLEAR_HALT, &usbhid->iofl); 300 schedule_work(&usbhid->reset_work); 301 return; 302 case -ECONNRESET: /* unlink */ 303 case -ENOENT: 304 case -ESHUTDOWN: /* unplug */ 305 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 306 return; 307 case -EILSEQ: /* protocol error or unplug */ 308 case -EPROTO: /* protocol error or unplug */ 309 case -ETIME: /* protocol error or unplug */ 310 case -ETIMEDOUT: /* Should never happen, but... */ 311 usbhid_mark_busy(usbhid); 312 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 313 hid_io_error(hid); 314 return; 315 default: /* error */ 316 hid_warn(urb->dev, "input irq status %d received\n", 317 urb->status); 318 } 319 320 status = usb_submit_urb(urb, GFP_ATOMIC); 321 if (status) { 322 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 323 if (status != -EPERM) { 324 hid_err(hid, "can't resubmit intr, %s-%s/input%d, status %d\n", 325 hid_to_usb_dev(hid)->bus->bus_name, 326 hid_to_usb_dev(hid)->devpath, 327 usbhid->ifnum, status); 328 hid_io_error(hid); 329 } 330 } 331 } 332 333 static int hid_submit_out(struct hid_device *hid) 334 { 335 struct hid_report *report; 336 char *raw_report; 337 struct usbhid_device *usbhid = hid->driver_data; 338 int r; 339 340 report = usbhid->out[usbhid->outtail].report; 341 raw_report = usbhid->out[usbhid->outtail].raw_report; 342 343 usbhid->urbout->transfer_buffer_length = hid_report_len(report); 344 usbhid->urbout->dev = hid_to_usb_dev(hid); 345 if (raw_report) { 346 memcpy(usbhid->outbuf, raw_report, 347 usbhid->urbout->transfer_buffer_length); 348 kfree(raw_report); 349 usbhid->out[usbhid->outtail].raw_report = NULL; 350 } 351 352 dbg_hid("submitting out urb\n"); 353 354 r = usb_submit_urb(usbhid->urbout, GFP_ATOMIC); 355 if (r < 0) { 356 hid_err(hid, "usb_submit_urb(out) failed: %d\n", r); 357 return r; 358 } 359 usbhid->last_out = jiffies; 360 return 0; 361 } 362 363 static int hid_submit_ctrl(struct hid_device *hid) 364 { 365 struct hid_report *report; 366 unsigned char dir; 367 char *raw_report; 368 int len, r; 369 struct usbhid_device *usbhid = hid->driver_data; 370 371 report = usbhid->ctrl[usbhid->ctrltail].report; 372 raw_report = usbhid->ctrl[usbhid->ctrltail].raw_report; 373 dir = usbhid->ctrl[usbhid->ctrltail].dir; 374 375 len = ((report->size - 1) >> 3) + 1 + (report->id > 0); 376 if (dir == USB_DIR_OUT) { 377 usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0); 378 usbhid->urbctrl->transfer_buffer_length = len; 379 if (raw_report) { 380 memcpy(usbhid->ctrlbuf, raw_report, len); 381 kfree(raw_report); 382 usbhid->ctrl[usbhid->ctrltail].raw_report = NULL; 383 } 384 } else { 385 int maxpacket, padlen; 386 387 usbhid->urbctrl->pipe = usb_rcvctrlpipe(hid_to_usb_dev(hid), 0); 388 maxpacket = usb_maxpacket(hid_to_usb_dev(hid), 389 usbhid->urbctrl->pipe, 0); 390 if (maxpacket > 0) { 391 padlen = DIV_ROUND_UP(len, maxpacket); 392 padlen *= maxpacket; 393 if (padlen > usbhid->bufsize) 394 padlen = usbhid->bufsize; 395 } else 396 padlen = 0; 397 usbhid->urbctrl->transfer_buffer_length = padlen; 398 } 399 usbhid->urbctrl->dev = hid_to_usb_dev(hid); 400 401 usbhid->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE | dir; 402 usbhid->cr->bRequest = (dir == USB_DIR_OUT) ? HID_REQ_SET_REPORT : 403 HID_REQ_GET_REPORT; 404 usbhid->cr->wValue = cpu_to_le16(((report->type + 1) << 8) | 405 report->id); 406 usbhid->cr->wIndex = cpu_to_le16(usbhid->ifnum); 407 usbhid->cr->wLength = cpu_to_le16(len); 408 409 dbg_hid("submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u\n", 410 usbhid->cr->bRequest == HID_REQ_SET_REPORT ? "Set_Report" : 411 "Get_Report", 412 usbhid->cr->wValue, usbhid->cr->wIndex, usbhid->cr->wLength); 413 414 r = usb_submit_urb(usbhid->urbctrl, GFP_ATOMIC); 415 if (r < 0) { 416 hid_err(hid, "usb_submit_urb(ctrl) failed: %d\n", r); 417 return r; 418 } 419 usbhid->last_ctrl = jiffies; 420 return 0; 421 } 422 423 /* 424 * Output interrupt completion handler. 425 */ 426 427 static void hid_irq_out(struct urb *urb) 428 { 429 struct hid_device *hid = urb->context; 430 struct usbhid_device *usbhid = hid->driver_data; 431 unsigned long flags; 432 int unplug = 0; 433 434 switch (urb->status) { 435 case 0: /* success */ 436 break; 437 case -ESHUTDOWN: /* unplug */ 438 unplug = 1; 439 case -EILSEQ: /* protocol error or unplug */ 440 case -EPROTO: /* protocol error or unplug */ 441 case -ECONNRESET: /* unlink */ 442 case -ENOENT: 443 break; 444 default: /* error */ 445 hid_warn(urb->dev, "output irq status %d received\n", 446 urb->status); 447 } 448 449 spin_lock_irqsave(&usbhid->lock, flags); 450 451 if (unplug) { 452 usbhid->outtail = usbhid->outhead; 453 } else { 454 usbhid->outtail = (usbhid->outtail + 1) & (HID_OUTPUT_FIFO_SIZE - 1); 455 456 if (usbhid->outhead != usbhid->outtail && 457 hid_submit_out(hid) == 0) { 458 /* Successfully submitted next urb in queue */ 459 spin_unlock_irqrestore(&usbhid->lock, flags); 460 return; 461 } 462 } 463 464 clear_bit(HID_OUT_RUNNING, &usbhid->iofl); 465 spin_unlock_irqrestore(&usbhid->lock, flags); 466 usb_autopm_put_interface_async(usbhid->intf); 467 wake_up(&usbhid->wait); 468 } 469 470 /* 471 * Control pipe completion handler. 472 */ 473 474 static void hid_ctrl(struct urb *urb) 475 { 476 struct hid_device *hid = urb->context; 477 struct usbhid_device *usbhid = hid->driver_data; 478 int unplug = 0, status = urb->status; 479 480 spin_lock(&usbhid->lock); 481 482 switch (status) { 483 case 0: /* success */ 484 if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN) 485 hid_input_report(urb->context, 486 usbhid->ctrl[usbhid->ctrltail].report->type, 487 urb->transfer_buffer, urb->actual_length, 0); 488 break; 489 case -ESHUTDOWN: /* unplug */ 490 unplug = 1; 491 case -EILSEQ: /* protocol error or unplug */ 492 case -EPROTO: /* protocol error or unplug */ 493 case -ECONNRESET: /* unlink */ 494 case -ENOENT: 495 case -EPIPE: /* report not available */ 496 break; 497 default: /* error */ 498 hid_warn(urb->dev, "ctrl urb status %d received\n", status); 499 } 500 501 if (unplug) { 502 usbhid->ctrltail = usbhid->ctrlhead; 503 } else { 504 usbhid->ctrltail = (usbhid->ctrltail + 1) & (HID_CONTROL_FIFO_SIZE - 1); 505 506 if (usbhid->ctrlhead != usbhid->ctrltail && 507 hid_submit_ctrl(hid) == 0) { 508 /* Successfully submitted next urb in queue */ 509 spin_unlock(&usbhid->lock); 510 return; 511 } 512 } 513 514 clear_bit(HID_CTRL_RUNNING, &usbhid->iofl); 515 spin_unlock(&usbhid->lock); 516 usb_autopm_put_interface_async(usbhid->intf); 517 wake_up(&usbhid->wait); 518 } 519 520 static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *report, 521 unsigned char dir) 522 { 523 int head; 524 struct usbhid_device *usbhid = hid->driver_data; 525 526 if (((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN) || 527 test_bit(HID_DISCONNECTED, &usbhid->iofl)) 528 return; 529 530 if (usbhid->urbout && dir == USB_DIR_OUT && report->type == HID_OUTPUT_REPORT) { 531 if ((head = (usbhid->outhead + 1) & (HID_OUTPUT_FIFO_SIZE - 1)) == usbhid->outtail) { 532 hid_warn(hid, "output queue full\n"); 533 return; 534 } 535 536 usbhid->out[usbhid->outhead].raw_report = hid_alloc_report_buf(report, GFP_ATOMIC); 537 if (!usbhid->out[usbhid->outhead].raw_report) { 538 hid_warn(hid, "output queueing failed\n"); 539 return; 540 } 541 hid_output_report(report, usbhid->out[usbhid->outhead].raw_report); 542 usbhid->out[usbhid->outhead].report = report; 543 usbhid->outhead = head; 544 545 /* If the queue isn't running, restart it */ 546 if (!test_bit(HID_OUT_RUNNING, &usbhid->iofl)) { 547 usbhid_restart_out_queue(usbhid); 548 549 /* Otherwise see if an earlier request has timed out */ 550 } else if (time_after(jiffies, usbhid->last_out + HZ * 5)) { 551 552 /* Prevent autosuspend following the unlink */ 553 usb_autopm_get_interface_no_resume(usbhid->intf); 554 555 /* 556 * Prevent resubmission in case the URB completes 557 * before we can unlink it. We don't want to cancel 558 * the wrong transfer! 559 */ 560 usb_block_urb(usbhid->urbout); 561 562 /* Drop lock to avoid deadlock if the callback runs */ 563 spin_unlock(&usbhid->lock); 564 565 usb_unlink_urb(usbhid->urbout); 566 spin_lock(&usbhid->lock); 567 usb_unblock_urb(usbhid->urbout); 568 569 /* Unlink might have stopped the queue */ 570 if (!test_bit(HID_OUT_RUNNING, &usbhid->iofl)) 571 usbhid_restart_out_queue(usbhid); 572 573 /* Now we can allow autosuspend again */ 574 usb_autopm_put_interface_async(usbhid->intf); 575 } 576 return; 577 } 578 579 if ((head = (usbhid->ctrlhead + 1) & (HID_CONTROL_FIFO_SIZE - 1)) == usbhid->ctrltail) { 580 hid_warn(hid, "control queue full\n"); 581 return; 582 } 583 584 if (dir == USB_DIR_OUT) { 585 usbhid->ctrl[usbhid->ctrlhead].raw_report = hid_alloc_report_buf(report, GFP_ATOMIC); 586 if (!usbhid->ctrl[usbhid->ctrlhead].raw_report) { 587 hid_warn(hid, "control queueing failed\n"); 588 return; 589 } 590 hid_output_report(report, usbhid->ctrl[usbhid->ctrlhead].raw_report); 591 } 592 usbhid->ctrl[usbhid->ctrlhead].report = report; 593 usbhid->ctrl[usbhid->ctrlhead].dir = dir; 594 usbhid->ctrlhead = head; 595 596 /* If the queue isn't running, restart it */ 597 if (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl)) { 598 usbhid_restart_ctrl_queue(usbhid); 599 600 /* Otherwise see if an earlier request has timed out */ 601 } else if (time_after(jiffies, usbhid->last_ctrl + HZ * 5)) { 602 603 /* Prevent autosuspend following the unlink */ 604 usb_autopm_get_interface_no_resume(usbhid->intf); 605 606 /* 607 * Prevent resubmission in case the URB completes 608 * before we can unlink it. We don't want to cancel 609 * the wrong transfer! 610 */ 611 usb_block_urb(usbhid->urbctrl); 612 613 /* Drop lock to avoid deadlock if the callback runs */ 614 spin_unlock(&usbhid->lock); 615 616 usb_unlink_urb(usbhid->urbctrl); 617 spin_lock(&usbhid->lock); 618 usb_unblock_urb(usbhid->urbctrl); 619 620 /* Unlink might have stopped the queue */ 621 if (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl)) 622 usbhid_restart_ctrl_queue(usbhid); 623 624 /* Now we can allow autosuspend again */ 625 usb_autopm_put_interface_async(usbhid->intf); 626 } 627 } 628 629 static void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir) 630 { 631 struct usbhid_device *usbhid = hid->driver_data; 632 unsigned long flags; 633 634 spin_lock_irqsave(&usbhid->lock, flags); 635 __usbhid_submit_report(hid, report, dir); 636 spin_unlock_irqrestore(&usbhid->lock, flags); 637 } 638 639 static int usbhid_wait_io(struct hid_device *hid) 640 { 641 struct usbhid_device *usbhid = hid->driver_data; 642 643 if (!wait_event_timeout(usbhid->wait, 644 (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl) && 645 !test_bit(HID_OUT_RUNNING, &usbhid->iofl)), 646 10*HZ)) { 647 dbg_hid("timeout waiting for ctrl or out queue to clear\n"); 648 return -1; 649 } 650 651 return 0; 652 } 653 654 static int hid_set_idle(struct usb_device *dev, int ifnum, int report, int idle) 655 { 656 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 657 HID_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE, (idle << 8) | report, 658 ifnum, NULL, 0, USB_CTRL_SET_TIMEOUT); 659 } 660 661 static int hid_get_class_descriptor(struct usb_device *dev, int ifnum, 662 unsigned char type, void *buf, int size) 663 { 664 int result, retries = 4; 665 666 memset(buf, 0, size); 667 668 do { 669 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 670 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN, 671 (type << 8), ifnum, buf, size, USB_CTRL_GET_TIMEOUT); 672 retries--; 673 } while (result < size && retries); 674 return result; 675 } 676 677 int usbhid_open(struct hid_device *hid) 678 { 679 struct usbhid_device *usbhid = hid->driver_data; 680 int res = 0; 681 682 mutex_lock(&hid_open_mut); 683 if (!hid->open++) { 684 res = usb_autopm_get_interface(usbhid->intf); 685 /* the device must be awake to reliably request remote wakeup */ 686 if (res < 0) { 687 hid->open--; 688 res = -EIO; 689 goto done; 690 } 691 usbhid->intf->needs_remote_wakeup = 1; 692 set_bit(HID_RESUME_RUNNING, &usbhid->iofl); 693 res = hid_start_in(hid); 694 if (res) { 695 if (res != -ENOSPC) { 696 hid_io_error(hid); 697 res = 0; 698 } else { 699 /* no use opening if resources are insufficient */ 700 hid->open--; 701 res = -EBUSY; 702 usbhid->intf->needs_remote_wakeup = 0; 703 } 704 } 705 usb_autopm_put_interface(usbhid->intf); 706 707 /* 708 * In case events are generated while nobody was listening, 709 * some are released when the device is re-opened. 710 * Wait 50 msec for the queue to empty before allowing events 711 * to go through hid. 712 */ 713 if (res == 0 && !(hid->quirks & HID_QUIRK_ALWAYS_POLL)) 714 msleep(50); 715 clear_bit(HID_RESUME_RUNNING, &usbhid->iofl); 716 } 717 done: 718 mutex_unlock(&hid_open_mut); 719 return res; 720 } 721 722 void usbhid_close(struct hid_device *hid) 723 { 724 struct usbhid_device *usbhid = hid->driver_data; 725 726 mutex_lock(&hid_open_mut); 727 728 /* protecting hid->open to make sure we don't restart 729 * data acquistion due to a resumption we no longer 730 * care about 731 */ 732 spin_lock_irq(&usbhid->lock); 733 if (!--hid->open) { 734 spin_unlock_irq(&usbhid->lock); 735 hid_cancel_delayed_stuff(usbhid); 736 if (!(hid->quirks & HID_QUIRK_ALWAYS_POLL)) { 737 usb_kill_urb(usbhid->urbin); 738 usbhid->intf->needs_remote_wakeup = 0; 739 } 740 } else { 741 spin_unlock_irq(&usbhid->lock); 742 } 743 mutex_unlock(&hid_open_mut); 744 } 745 746 /* 747 * Initialize all reports 748 */ 749 750 void usbhid_init_reports(struct hid_device *hid) 751 { 752 struct hid_report *report; 753 struct usbhid_device *usbhid = hid->driver_data; 754 struct hid_report_enum *report_enum; 755 int err, ret; 756 757 if (!(hid->quirks & HID_QUIRK_NO_INIT_INPUT_REPORTS)) { 758 report_enum = &hid->report_enum[HID_INPUT_REPORT]; 759 list_for_each_entry(report, &report_enum->report_list, list) 760 usbhid_submit_report(hid, report, USB_DIR_IN); 761 } 762 763 report_enum = &hid->report_enum[HID_FEATURE_REPORT]; 764 list_for_each_entry(report, &report_enum->report_list, list) 765 usbhid_submit_report(hid, report, USB_DIR_IN); 766 767 err = 0; 768 ret = usbhid_wait_io(hid); 769 while (ret) { 770 err |= ret; 771 if (test_bit(HID_CTRL_RUNNING, &usbhid->iofl)) 772 usb_kill_urb(usbhid->urbctrl); 773 if (test_bit(HID_OUT_RUNNING, &usbhid->iofl)) 774 usb_kill_urb(usbhid->urbout); 775 ret = usbhid_wait_io(hid); 776 } 777 778 if (err) 779 hid_warn(hid, "timeout initializing reports\n"); 780 } 781 782 /* 783 * Reset LEDs which BIOS might have left on. For now, just NumLock (0x01). 784 */ 785 static int hid_find_field_early(struct hid_device *hid, unsigned int page, 786 unsigned int hid_code, struct hid_field **pfield) 787 { 788 struct hid_report *report; 789 struct hid_field *field; 790 struct hid_usage *usage; 791 int i, j; 792 793 list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) { 794 for (i = 0; i < report->maxfield; i++) { 795 field = report->field[i]; 796 for (j = 0; j < field->maxusage; j++) { 797 usage = &field->usage[j]; 798 if ((usage->hid & HID_USAGE_PAGE) == page && 799 (usage->hid & 0xFFFF) == hid_code) { 800 *pfield = field; 801 return j; 802 } 803 } 804 } 805 } 806 return -1; 807 } 808 809 static void usbhid_set_leds(struct hid_device *hid) 810 { 811 struct hid_field *field; 812 int offset; 813 814 if ((offset = hid_find_field_early(hid, HID_UP_LED, 0x01, &field)) != -1) { 815 hid_set_field(field, offset, 0); 816 usbhid_submit_report(hid, field->report, USB_DIR_OUT); 817 } 818 } 819 820 /* 821 * Traverse the supplied list of reports and find the longest 822 */ 823 static void hid_find_max_report(struct hid_device *hid, unsigned int type, 824 unsigned int *max) 825 { 826 struct hid_report *report; 827 unsigned int size; 828 829 list_for_each_entry(report, &hid->report_enum[type].report_list, list) { 830 size = ((report->size - 1) >> 3) + 1 + hid->report_enum[type].numbered; 831 if (*max < size) 832 *max = size; 833 } 834 } 835 836 static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid) 837 { 838 struct usbhid_device *usbhid = hid->driver_data; 839 840 usbhid->inbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL, 841 &usbhid->inbuf_dma); 842 usbhid->outbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL, 843 &usbhid->outbuf_dma); 844 usbhid->cr = kmalloc(sizeof(*usbhid->cr), GFP_KERNEL); 845 usbhid->ctrlbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL, 846 &usbhid->ctrlbuf_dma); 847 if (!usbhid->inbuf || !usbhid->outbuf || !usbhid->cr || 848 !usbhid->ctrlbuf) 849 return -1; 850 851 return 0; 852 } 853 854 static int usbhid_get_raw_report(struct hid_device *hid, 855 unsigned char report_number, __u8 *buf, size_t count, 856 unsigned char report_type) 857 { 858 struct usbhid_device *usbhid = hid->driver_data; 859 struct usb_device *dev = hid_to_usb_dev(hid); 860 struct usb_interface *intf = usbhid->intf; 861 struct usb_host_interface *interface = intf->cur_altsetting; 862 int skipped_report_id = 0; 863 int ret; 864 865 /* Byte 0 is the report number. Report data starts at byte 1.*/ 866 buf[0] = report_number; 867 if (report_number == 0x0) { 868 /* Offset the return buffer by 1, so that the report ID 869 will remain in byte 0. */ 870 buf++; 871 count--; 872 skipped_report_id = 1; 873 } 874 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 875 HID_REQ_GET_REPORT, 876 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 877 ((report_type + 1) << 8) | report_number, 878 interface->desc.bInterfaceNumber, buf, count, 879 USB_CTRL_SET_TIMEOUT); 880 881 /* count also the report id */ 882 if (ret > 0 && skipped_report_id) 883 ret++; 884 885 return ret; 886 } 887 888 static int usbhid_set_raw_report(struct hid_device *hid, unsigned int reportnum, 889 __u8 *buf, size_t count, unsigned char rtype) 890 { 891 struct usbhid_device *usbhid = hid->driver_data; 892 struct usb_device *dev = hid_to_usb_dev(hid); 893 struct usb_interface *intf = usbhid->intf; 894 struct usb_host_interface *interface = intf->cur_altsetting; 895 int ret, skipped_report_id = 0; 896 897 /* Byte 0 is the report number. Report data starts at byte 1.*/ 898 if ((rtype == HID_OUTPUT_REPORT) && 899 (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORT_ID)) 900 buf[0] = 0; 901 else 902 buf[0] = reportnum; 903 904 if (buf[0] == 0x0) { 905 /* Don't send the Report ID */ 906 buf++; 907 count--; 908 skipped_report_id = 1; 909 } 910 911 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 912 HID_REQ_SET_REPORT, 913 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 914 ((rtype + 1) << 8) | reportnum, 915 interface->desc.bInterfaceNumber, buf, count, 916 USB_CTRL_SET_TIMEOUT); 917 /* count also the report id, if this was a numbered report. */ 918 if (ret > 0 && skipped_report_id) 919 ret++; 920 921 return ret; 922 } 923 924 static int usbhid_output_report(struct hid_device *hid, __u8 *buf, size_t count) 925 { 926 struct usbhid_device *usbhid = hid->driver_data; 927 struct usb_device *dev = hid_to_usb_dev(hid); 928 int actual_length, skipped_report_id = 0, ret; 929 930 if (!usbhid->urbout) 931 return -ENOSYS; 932 933 if (buf[0] == 0x0) { 934 /* Don't send the Report ID */ 935 buf++; 936 count--; 937 skipped_report_id = 1; 938 } 939 940 ret = usb_interrupt_msg(dev, usbhid->urbout->pipe, 941 buf, count, &actual_length, 942 USB_CTRL_SET_TIMEOUT); 943 /* return the number of bytes transferred */ 944 if (ret == 0) { 945 ret = actual_length; 946 /* count also the report id */ 947 if (skipped_report_id) 948 ret++; 949 } 950 951 return ret; 952 } 953 954 static void usbhid_restart_queues(struct usbhid_device *usbhid) 955 { 956 if (usbhid->urbout && !test_bit(HID_OUT_RUNNING, &usbhid->iofl)) 957 usbhid_restart_out_queue(usbhid); 958 if (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl)) 959 usbhid_restart_ctrl_queue(usbhid); 960 } 961 962 static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid) 963 { 964 struct usbhid_device *usbhid = hid->driver_data; 965 966 usb_free_coherent(dev, usbhid->bufsize, usbhid->inbuf, usbhid->inbuf_dma); 967 usb_free_coherent(dev, usbhid->bufsize, usbhid->outbuf, usbhid->outbuf_dma); 968 kfree(usbhid->cr); 969 usb_free_coherent(dev, usbhid->bufsize, usbhid->ctrlbuf, usbhid->ctrlbuf_dma); 970 } 971 972 static int usbhid_parse(struct hid_device *hid) 973 { 974 struct usb_interface *intf = to_usb_interface(hid->dev.parent); 975 struct usb_host_interface *interface = intf->cur_altsetting; 976 struct usb_device *dev = interface_to_usbdev (intf); 977 struct hid_descriptor *hdesc; 978 u32 quirks = 0; 979 unsigned int rsize = 0; 980 char *rdesc; 981 int ret, n; 982 983 quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor), 984 le16_to_cpu(dev->descriptor.idProduct)); 985 986 if (quirks & HID_QUIRK_IGNORE) 987 return -ENODEV; 988 989 /* Many keyboards and mice don't like to be polled for reports, 990 * so we will always set the HID_QUIRK_NOGET flag for them. */ 991 if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT) { 992 if (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_KEYBOARD || 993 interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE) 994 quirks |= HID_QUIRK_NOGET; 995 } 996 997 if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) && 998 (!interface->desc.bNumEndpoints || 999 usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) { 1000 dbg_hid("class descriptor not present\n"); 1001 return -ENODEV; 1002 } 1003 1004 hid->version = le16_to_cpu(hdesc->bcdHID); 1005 hid->country = hdesc->bCountryCode; 1006 1007 for (n = 0; n < hdesc->bNumDescriptors; n++) 1008 if (hdesc->desc[n].bDescriptorType == HID_DT_REPORT) 1009 rsize = le16_to_cpu(hdesc->desc[n].wDescriptorLength); 1010 1011 if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) { 1012 dbg_hid("weird size of report descriptor (%u)\n", rsize); 1013 return -EINVAL; 1014 } 1015 1016 if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) { 1017 dbg_hid("couldn't allocate rdesc memory\n"); 1018 return -ENOMEM; 1019 } 1020 1021 hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0); 1022 1023 ret = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber, 1024 HID_DT_REPORT, rdesc, rsize); 1025 if (ret < 0) { 1026 dbg_hid("reading report descriptor failed\n"); 1027 kfree(rdesc); 1028 goto err; 1029 } 1030 1031 ret = hid_parse_report(hid, rdesc, rsize); 1032 kfree(rdesc); 1033 if (ret) { 1034 dbg_hid("parsing report descriptor failed\n"); 1035 goto err; 1036 } 1037 1038 hid->quirks |= quirks; 1039 1040 return 0; 1041 err: 1042 return ret; 1043 } 1044 1045 static int usbhid_start(struct hid_device *hid) 1046 { 1047 struct usb_interface *intf = to_usb_interface(hid->dev.parent); 1048 struct usb_host_interface *interface = intf->cur_altsetting; 1049 struct usb_device *dev = interface_to_usbdev(intf); 1050 struct usbhid_device *usbhid = hid->driver_data; 1051 unsigned int n, insize = 0; 1052 int ret; 1053 1054 clear_bit(HID_DISCONNECTED, &usbhid->iofl); 1055 1056 usbhid->bufsize = HID_MIN_BUFFER_SIZE; 1057 hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize); 1058 hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize); 1059 hid_find_max_report(hid, HID_FEATURE_REPORT, &usbhid->bufsize); 1060 1061 if (usbhid->bufsize > HID_MAX_BUFFER_SIZE) 1062 usbhid->bufsize = HID_MAX_BUFFER_SIZE; 1063 1064 hid_find_max_report(hid, HID_INPUT_REPORT, &insize); 1065 1066 if (insize > HID_MAX_BUFFER_SIZE) 1067 insize = HID_MAX_BUFFER_SIZE; 1068 1069 if (hid_alloc_buffers(dev, hid)) { 1070 ret = -ENOMEM; 1071 goto fail; 1072 } 1073 1074 for (n = 0; n < interface->desc.bNumEndpoints; n++) { 1075 struct usb_endpoint_descriptor *endpoint; 1076 int pipe; 1077 int interval; 1078 1079 endpoint = &interface->endpoint[n].desc; 1080 if (!usb_endpoint_xfer_int(endpoint)) 1081 continue; 1082 1083 interval = endpoint->bInterval; 1084 1085 /* Some vendors give fullspeed interval on highspeed devides */ 1086 if (hid->quirks & HID_QUIRK_FULLSPEED_INTERVAL && 1087 dev->speed == USB_SPEED_HIGH) { 1088 interval = fls(endpoint->bInterval*8); 1089 printk(KERN_INFO "%s: Fixing fullspeed to highspeed interval: %d -> %d\n", 1090 hid->name, endpoint->bInterval, interval); 1091 } 1092 1093 /* Change the polling interval of mice. */ 1094 if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0) 1095 interval = hid_mousepoll_interval; 1096 1097 ret = -ENOMEM; 1098 if (usb_endpoint_dir_in(endpoint)) { 1099 if (usbhid->urbin) 1100 continue; 1101 if (!(usbhid->urbin = usb_alloc_urb(0, GFP_KERNEL))) 1102 goto fail; 1103 pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress); 1104 usb_fill_int_urb(usbhid->urbin, dev, pipe, usbhid->inbuf, insize, 1105 hid_irq_in, hid, interval); 1106 usbhid->urbin->transfer_dma = usbhid->inbuf_dma; 1107 usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1108 } else { 1109 if (usbhid->urbout) 1110 continue; 1111 if (!(usbhid->urbout = usb_alloc_urb(0, GFP_KERNEL))) 1112 goto fail; 1113 pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress); 1114 usb_fill_int_urb(usbhid->urbout, dev, pipe, usbhid->outbuf, 0, 1115 hid_irq_out, hid, interval); 1116 usbhid->urbout->transfer_dma = usbhid->outbuf_dma; 1117 usbhid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1118 } 1119 } 1120 1121 usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL); 1122 if (!usbhid->urbctrl) { 1123 ret = -ENOMEM; 1124 goto fail; 1125 } 1126 1127 usb_fill_control_urb(usbhid->urbctrl, dev, 0, (void *) usbhid->cr, 1128 usbhid->ctrlbuf, 1, hid_ctrl, hid); 1129 usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma; 1130 usbhid->urbctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1131 1132 if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS)) 1133 usbhid_init_reports(hid); 1134 1135 set_bit(HID_STARTED, &usbhid->iofl); 1136 1137 if (hid->quirks & HID_QUIRK_ALWAYS_POLL) { 1138 ret = usb_autopm_get_interface(usbhid->intf); 1139 if (ret) 1140 goto fail; 1141 usbhid->intf->needs_remote_wakeup = 1; 1142 ret = hid_start_in(hid); 1143 if (ret) { 1144 dev_err(&hid->dev, 1145 "failed to start in urb: %d\n", ret); 1146 } 1147 usb_autopm_put_interface(usbhid->intf); 1148 } 1149 1150 /* Some keyboards don't work until their LEDs have been set. 1151 * Since BIOSes do set the LEDs, it must be safe for any device 1152 * that supports the keyboard boot protocol. 1153 * In addition, enable remote wakeup by default for all keyboard 1154 * devices supporting the boot protocol. 1155 */ 1156 if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT && 1157 interface->desc.bInterfaceProtocol == 1158 USB_INTERFACE_PROTOCOL_KEYBOARD) { 1159 usbhid_set_leds(hid); 1160 device_set_wakeup_enable(&dev->dev, 1); 1161 } 1162 return 0; 1163 1164 fail: 1165 usb_free_urb(usbhid->urbin); 1166 usb_free_urb(usbhid->urbout); 1167 usb_free_urb(usbhid->urbctrl); 1168 usbhid->urbin = NULL; 1169 usbhid->urbout = NULL; 1170 usbhid->urbctrl = NULL; 1171 hid_free_buffers(dev, hid); 1172 return ret; 1173 } 1174 1175 static void usbhid_stop(struct hid_device *hid) 1176 { 1177 struct usbhid_device *usbhid = hid->driver_data; 1178 1179 if (WARN_ON(!usbhid)) 1180 return; 1181 1182 if (hid->quirks & HID_QUIRK_ALWAYS_POLL) 1183 usbhid->intf->needs_remote_wakeup = 0; 1184 1185 clear_bit(HID_STARTED, &usbhid->iofl); 1186 spin_lock_irq(&usbhid->lock); /* Sync with error and led handlers */ 1187 set_bit(HID_DISCONNECTED, &usbhid->iofl); 1188 spin_unlock_irq(&usbhid->lock); 1189 usb_kill_urb(usbhid->urbin); 1190 usb_kill_urb(usbhid->urbout); 1191 usb_kill_urb(usbhid->urbctrl); 1192 1193 hid_cancel_delayed_stuff(usbhid); 1194 1195 hid->claimed = 0; 1196 1197 usb_free_urb(usbhid->urbin); 1198 usb_free_urb(usbhid->urbctrl); 1199 usb_free_urb(usbhid->urbout); 1200 usbhid->urbin = NULL; /* don't mess up next start */ 1201 usbhid->urbctrl = NULL; 1202 usbhid->urbout = NULL; 1203 1204 hid_free_buffers(hid_to_usb_dev(hid), hid); 1205 } 1206 1207 static int usbhid_power(struct hid_device *hid, int lvl) 1208 { 1209 int r = 0; 1210 1211 switch (lvl) { 1212 case PM_HINT_FULLON: 1213 r = usbhid_get_power(hid); 1214 break; 1215 case PM_HINT_NORMAL: 1216 usbhid_put_power(hid); 1217 break; 1218 } 1219 return r; 1220 } 1221 1222 static void usbhid_request(struct hid_device *hid, struct hid_report *rep, int reqtype) 1223 { 1224 switch (reqtype) { 1225 case HID_REQ_GET_REPORT: 1226 usbhid_submit_report(hid, rep, USB_DIR_IN); 1227 break; 1228 case HID_REQ_SET_REPORT: 1229 usbhid_submit_report(hid, rep, USB_DIR_OUT); 1230 break; 1231 } 1232 } 1233 1234 static int usbhid_raw_request(struct hid_device *hid, unsigned char reportnum, 1235 __u8 *buf, size_t len, unsigned char rtype, 1236 int reqtype) 1237 { 1238 switch (reqtype) { 1239 case HID_REQ_GET_REPORT: 1240 return usbhid_get_raw_report(hid, reportnum, buf, len, rtype); 1241 case HID_REQ_SET_REPORT: 1242 return usbhid_set_raw_report(hid, reportnum, buf, len, rtype); 1243 default: 1244 return -EIO; 1245 } 1246 } 1247 1248 static int usbhid_idle(struct hid_device *hid, int report, int idle, 1249 int reqtype) 1250 { 1251 struct usb_device *dev = hid_to_usb_dev(hid); 1252 struct usb_interface *intf = to_usb_interface(hid->dev.parent); 1253 struct usb_host_interface *interface = intf->cur_altsetting; 1254 int ifnum = interface->desc.bInterfaceNumber; 1255 1256 if (reqtype != HID_REQ_SET_IDLE) 1257 return -EINVAL; 1258 1259 return hid_set_idle(dev, ifnum, report, idle); 1260 } 1261 1262 static struct hid_ll_driver usb_hid_driver = { 1263 .parse = usbhid_parse, 1264 .start = usbhid_start, 1265 .stop = usbhid_stop, 1266 .open = usbhid_open, 1267 .close = usbhid_close, 1268 .power = usbhid_power, 1269 .request = usbhid_request, 1270 .wait = usbhid_wait_io, 1271 .raw_request = usbhid_raw_request, 1272 .output_report = usbhid_output_report, 1273 .idle = usbhid_idle, 1274 }; 1275 1276 static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *id) 1277 { 1278 struct usb_host_interface *interface = intf->cur_altsetting; 1279 struct usb_device *dev = interface_to_usbdev(intf); 1280 struct usbhid_device *usbhid; 1281 struct hid_device *hid; 1282 unsigned int n, has_in = 0; 1283 size_t len; 1284 int ret; 1285 1286 dbg_hid("HID probe called for ifnum %d\n", 1287 intf->altsetting->desc.bInterfaceNumber); 1288 1289 for (n = 0; n < interface->desc.bNumEndpoints; n++) 1290 if (usb_endpoint_is_int_in(&interface->endpoint[n].desc)) 1291 has_in++; 1292 if (!has_in) { 1293 hid_err(intf, "couldn't find an input interrupt endpoint\n"); 1294 return -ENODEV; 1295 } 1296 1297 hid = hid_allocate_device(); 1298 if (IS_ERR(hid)) 1299 return PTR_ERR(hid); 1300 1301 usb_set_intfdata(intf, hid); 1302 hid->ll_driver = &usb_hid_driver; 1303 hid->ff_init = hid_pidff_init; 1304 #ifdef CONFIG_USB_HIDDEV 1305 hid->hiddev_connect = hiddev_connect; 1306 hid->hiddev_disconnect = hiddev_disconnect; 1307 hid->hiddev_hid_event = hiddev_hid_event; 1308 hid->hiddev_report_event = hiddev_report_event; 1309 #endif 1310 hid->dev.parent = &intf->dev; 1311 hid->bus = BUS_USB; 1312 hid->vendor = le16_to_cpu(dev->descriptor.idVendor); 1313 hid->product = le16_to_cpu(dev->descriptor.idProduct); 1314 hid->name[0] = 0; 1315 hid->quirks = usbhid_lookup_quirk(hid->vendor, hid->product); 1316 if (intf->cur_altsetting->desc.bInterfaceProtocol == 1317 USB_INTERFACE_PROTOCOL_MOUSE) 1318 hid->type = HID_TYPE_USBMOUSE; 1319 else if (intf->cur_altsetting->desc.bInterfaceProtocol == 0) 1320 hid->type = HID_TYPE_USBNONE; 1321 1322 if (dev->manufacturer) 1323 strlcpy(hid->name, dev->manufacturer, sizeof(hid->name)); 1324 1325 if (dev->product) { 1326 if (dev->manufacturer) 1327 strlcat(hid->name, " ", sizeof(hid->name)); 1328 strlcat(hid->name, dev->product, sizeof(hid->name)); 1329 } 1330 1331 if (!strlen(hid->name)) 1332 snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x", 1333 le16_to_cpu(dev->descriptor.idVendor), 1334 le16_to_cpu(dev->descriptor.idProduct)); 1335 1336 usb_make_path(dev, hid->phys, sizeof(hid->phys)); 1337 strlcat(hid->phys, "/input", sizeof(hid->phys)); 1338 len = strlen(hid->phys); 1339 if (len < sizeof(hid->phys) - 1) 1340 snprintf(hid->phys + len, sizeof(hid->phys) - len, 1341 "%d", intf->altsetting[0].desc.bInterfaceNumber); 1342 1343 if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0) 1344 hid->uniq[0] = 0; 1345 1346 usbhid = kzalloc(sizeof(*usbhid), GFP_KERNEL); 1347 if (usbhid == NULL) { 1348 ret = -ENOMEM; 1349 goto err; 1350 } 1351 1352 hid->driver_data = usbhid; 1353 usbhid->hid = hid; 1354 usbhid->intf = intf; 1355 usbhid->ifnum = interface->desc.bInterfaceNumber; 1356 1357 init_waitqueue_head(&usbhid->wait); 1358 INIT_WORK(&usbhid->reset_work, hid_reset); 1359 setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid); 1360 spin_lock_init(&usbhid->lock); 1361 1362 ret = hid_add_device(hid); 1363 if (ret) { 1364 if (ret != -ENODEV) 1365 hid_err(intf, "can't add hid device: %d\n", ret); 1366 goto err_free; 1367 } 1368 1369 return 0; 1370 err_free: 1371 kfree(usbhid); 1372 err: 1373 hid_destroy_device(hid); 1374 return ret; 1375 } 1376 1377 static void usbhid_disconnect(struct usb_interface *intf) 1378 { 1379 struct hid_device *hid = usb_get_intfdata(intf); 1380 struct usbhid_device *usbhid; 1381 1382 if (WARN_ON(!hid)) 1383 return; 1384 1385 usbhid = hid->driver_data; 1386 spin_lock_irq(&usbhid->lock); /* Sync with error and led handlers */ 1387 set_bit(HID_DISCONNECTED, &usbhid->iofl); 1388 spin_unlock_irq(&usbhid->lock); 1389 hid_destroy_device(hid); 1390 kfree(usbhid); 1391 } 1392 1393 static void hid_cancel_delayed_stuff(struct usbhid_device *usbhid) 1394 { 1395 del_timer_sync(&usbhid->io_retry); 1396 cancel_work_sync(&usbhid->reset_work); 1397 } 1398 1399 static void hid_cease_io(struct usbhid_device *usbhid) 1400 { 1401 del_timer_sync(&usbhid->io_retry); 1402 usb_kill_urb(usbhid->urbin); 1403 usb_kill_urb(usbhid->urbctrl); 1404 usb_kill_urb(usbhid->urbout); 1405 } 1406 1407 /* Treat USB reset pretty much the same as suspend/resume */ 1408 static int hid_pre_reset(struct usb_interface *intf) 1409 { 1410 struct hid_device *hid = usb_get_intfdata(intf); 1411 struct usbhid_device *usbhid = hid->driver_data; 1412 1413 spin_lock_irq(&usbhid->lock); 1414 set_bit(HID_RESET_PENDING, &usbhid->iofl); 1415 spin_unlock_irq(&usbhid->lock); 1416 hid_cease_io(usbhid); 1417 1418 return 0; 1419 } 1420 1421 /* Same routine used for post_reset and reset_resume */ 1422 static int hid_post_reset(struct usb_interface *intf) 1423 { 1424 struct usb_device *dev = interface_to_usbdev (intf); 1425 struct hid_device *hid = usb_get_intfdata(intf); 1426 struct usbhid_device *usbhid = hid->driver_data; 1427 struct usb_host_interface *interface = intf->cur_altsetting; 1428 int status; 1429 char *rdesc; 1430 1431 /* Fetch and examine the HID report descriptor. If this 1432 * has changed, then rebind. Since usbcore's check of the 1433 * configuration descriptors passed, we already know that 1434 * the size of the HID report descriptor has not changed. 1435 */ 1436 rdesc = kmalloc(hid->dev_rsize, GFP_KERNEL); 1437 if (!rdesc) { 1438 dbg_hid("couldn't allocate rdesc memory (post_reset)\n"); 1439 return 1; 1440 } 1441 status = hid_get_class_descriptor(dev, 1442 interface->desc.bInterfaceNumber, 1443 HID_DT_REPORT, rdesc, hid->dev_rsize); 1444 if (status < 0) { 1445 dbg_hid("reading report descriptor failed (post_reset)\n"); 1446 kfree(rdesc); 1447 return 1; 1448 } 1449 status = memcmp(rdesc, hid->dev_rdesc, hid->dev_rsize); 1450 kfree(rdesc); 1451 if (status != 0) { 1452 dbg_hid("report descriptor changed\n"); 1453 return 1; 1454 } 1455 1456 spin_lock_irq(&usbhid->lock); 1457 clear_bit(HID_RESET_PENDING, &usbhid->iofl); 1458 spin_unlock_irq(&usbhid->lock); 1459 hid_set_idle(dev, intf->cur_altsetting->desc.bInterfaceNumber, 0, 0); 1460 status = hid_start_in(hid); 1461 if (status < 0) 1462 hid_io_error(hid); 1463 usbhid_restart_queues(usbhid); 1464 1465 return 0; 1466 } 1467 1468 int usbhid_get_power(struct hid_device *hid) 1469 { 1470 struct usbhid_device *usbhid = hid->driver_data; 1471 1472 return usb_autopm_get_interface(usbhid->intf); 1473 } 1474 1475 void usbhid_put_power(struct hid_device *hid) 1476 { 1477 struct usbhid_device *usbhid = hid->driver_data; 1478 1479 usb_autopm_put_interface(usbhid->intf); 1480 } 1481 1482 1483 #ifdef CONFIG_PM 1484 static int hid_resume_common(struct hid_device *hid, bool driver_suspended) 1485 { 1486 struct usbhid_device *usbhid = hid->driver_data; 1487 int status; 1488 1489 spin_lock_irq(&usbhid->lock); 1490 clear_bit(HID_SUSPENDED, &usbhid->iofl); 1491 usbhid_mark_busy(usbhid); 1492 1493 if (test_bit(HID_CLEAR_HALT, &usbhid->iofl) || 1494 test_bit(HID_RESET_PENDING, &usbhid->iofl)) 1495 schedule_work(&usbhid->reset_work); 1496 usbhid->retry_delay = 0; 1497 1498 usbhid_restart_queues(usbhid); 1499 spin_unlock_irq(&usbhid->lock); 1500 1501 status = hid_start_in(hid); 1502 if (status < 0) 1503 hid_io_error(hid); 1504 1505 if (driver_suspended && hid->driver && hid->driver->resume) 1506 status = hid->driver->resume(hid); 1507 return status; 1508 } 1509 1510 static int hid_suspend(struct usb_interface *intf, pm_message_t message) 1511 { 1512 struct hid_device *hid = usb_get_intfdata(intf); 1513 struct usbhid_device *usbhid = hid->driver_data; 1514 int status = 0; 1515 bool driver_suspended = false; 1516 unsigned int ledcount; 1517 1518 if (PMSG_IS_AUTO(message)) { 1519 ledcount = hidinput_count_leds(hid); 1520 spin_lock_irq(&usbhid->lock); /* Sync with error handler */ 1521 if (!test_bit(HID_RESET_PENDING, &usbhid->iofl) 1522 && !test_bit(HID_CLEAR_HALT, &usbhid->iofl) 1523 && !test_bit(HID_OUT_RUNNING, &usbhid->iofl) 1524 && !test_bit(HID_CTRL_RUNNING, &usbhid->iofl) 1525 && !test_bit(HID_KEYS_PRESSED, &usbhid->iofl) 1526 && (!ledcount || ignoreled)) 1527 { 1528 set_bit(HID_SUSPENDED, &usbhid->iofl); 1529 spin_unlock_irq(&usbhid->lock); 1530 if (hid->driver && hid->driver->suspend) { 1531 status = hid->driver->suspend(hid, message); 1532 if (status < 0) 1533 goto failed; 1534 } 1535 driver_suspended = true; 1536 } else { 1537 usbhid_mark_busy(usbhid); 1538 spin_unlock_irq(&usbhid->lock); 1539 return -EBUSY; 1540 } 1541 1542 } else { 1543 /* TODO: resume() might need to handle suspend failure */ 1544 if (hid->driver && hid->driver->suspend) 1545 status = hid->driver->suspend(hid, message); 1546 driver_suspended = true; 1547 spin_lock_irq(&usbhid->lock); 1548 set_bit(HID_SUSPENDED, &usbhid->iofl); 1549 spin_unlock_irq(&usbhid->lock); 1550 if (usbhid_wait_io(hid) < 0) 1551 status = -EIO; 1552 } 1553 1554 hid_cancel_delayed_stuff(usbhid); 1555 hid_cease_io(usbhid); 1556 1557 if (PMSG_IS_AUTO(message) && test_bit(HID_KEYS_PRESSED, &usbhid->iofl)) { 1558 /* lost race against keypresses */ 1559 status = -EBUSY; 1560 goto failed; 1561 } 1562 dev_dbg(&intf->dev, "suspend\n"); 1563 return status; 1564 1565 failed: 1566 hid_resume_common(hid, driver_suspended); 1567 return status; 1568 } 1569 1570 static int hid_resume(struct usb_interface *intf) 1571 { 1572 struct hid_device *hid = usb_get_intfdata (intf); 1573 struct usbhid_device *usbhid = hid->driver_data; 1574 int status; 1575 1576 if (!test_bit(HID_STARTED, &usbhid->iofl)) 1577 return 0; 1578 1579 status = hid_resume_common(hid, true); 1580 dev_dbg(&intf->dev, "resume status %d\n", status); 1581 return 0; 1582 } 1583 1584 static int hid_reset_resume(struct usb_interface *intf) 1585 { 1586 struct hid_device *hid = usb_get_intfdata(intf); 1587 struct usbhid_device *usbhid = hid->driver_data; 1588 int status; 1589 1590 clear_bit(HID_SUSPENDED, &usbhid->iofl); 1591 status = hid_post_reset(intf); 1592 if (status >= 0 && hid->driver && hid->driver->reset_resume) { 1593 int ret = hid->driver->reset_resume(hid); 1594 if (ret < 0) 1595 status = ret; 1596 } 1597 return status; 1598 } 1599 1600 #endif /* CONFIG_PM */ 1601 1602 static const struct usb_device_id hid_usb_ids[] = { 1603 { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS, 1604 .bInterfaceClass = USB_INTERFACE_CLASS_HID }, 1605 { } /* Terminating entry */ 1606 }; 1607 1608 MODULE_DEVICE_TABLE (usb, hid_usb_ids); 1609 1610 static struct usb_driver hid_driver = { 1611 .name = "usbhid", 1612 .probe = usbhid_probe, 1613 .disconnect = usbhid_disconnect, 1614 #ifdef CONFIG_PM 1615 .suspend = hid_suspend, 1616 .resume = hid_resume, 1617 .reset_resume = hid_reset_resume, 1618 #endif 1619 .pre_reset = hid_pre_reset, 1620 .post_reset = hid_post_reset, 1621 .id_table = hid_usb_ids, 1622 .supports_autosuspend = 1, 1623 }; 1624 1625 struct usb_interface *usbhid_find_interface(int minor) 1626 { 1627 return usb_find_interface(&hid_driver, minor); 1628 } 1629 1630 static int __init hid_init(void) 1631 { 1632 int retval = -ENOMEM; 1633 1634 retval = usbhid_quirks_init(quirks_param); 1635 if (retval) 1636 goto usbhid_quirks_init_fail; 1637 retval = usb_register(&hid_driver); 1638 if (retval) 1639 goto usb_register_fail; 1640 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 1641 1642 return 0; 1643 usb_register_fail: 1644 usbhid_quirks_exit(); 1645 usbhid_quirks_init_fail: 1646 return retval; 1647 } 1648 1649 static void __exit hid_exit(void) 1650 { 1651 usb_deregister(&hid_driver); 1652 usbhid_quirks_exit(); 1653 } 1654 1655 module_init(hid_init); 1656 module_exit(hid_exit); 1657 1658 MODULE_AUTHOR("Andreas Gal"); 1659 MODULE_AUTHOR("Vojtech Pavlik"); 1660 MODULE_AUTHOR("Jiri Kosina"); 1661 MODULE_DESCRIPTION(DRIVER_DESC); 1662 MODULE_LICENSE(DRIVER_LICENSE); 1663