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