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 52static unsigned int hid_mousepoll_interval; 53module_param_named(mousepoll, hid_mousepoll_interval, uint, 0644); 54MODULE_PARM_DESC(mousepoll, "Polling interval of mice"); 55 56static unsigned int ignoreled; 57module_param_named(ignoreled, ignoreled, uint, 0644); 58MODULE_PARM_DESC(ignoreled, "Autosuspend with active leds"); 59 60/* Quirks specified at module load time */ 61static char *quirks_param[MAX_USBHID_BOOT_QUIRKS]; 62module_param_array_named(quirks, quirks_param, charp, NULL, 0444); 63MODULE_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 */ 70static DEFINE_MUTEX(hid_open_mut); 71 72static void hid_io_error(struct hid_device *hid); 73static int hid_submit_out(struct hid_device *hid); 74static int hid_submit_ctrl(struct hid_device *hid); 75static void hid_cancel_delayed_stuff(struct usbhid_device *usbhid); 76 77/* Start up the input URB */ 78static 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 */ 103static 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 */ 114static 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 */ 141static 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)); 177done: 178 spin_unlock_irqrestore(&usbhid->lock, flags); 179} 180 181static 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 188static 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 226static 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 269static 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 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 break; 294 case -EPIPE: /* stall */ 295 usbhid_mark_busy(usbhid); 296 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 297 set_bit(HID_CLEAR_HALT, &usbhid->iofl); 298 schedule_work(&usbhid->reset_work); 299 return; 300 case -ECONNRESET: /* unlink */ 301 case -ENOENT: 302 case -ESHUTDOWN: /* unplug */ 303 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 304 return; 305 case -EILSEQ: /* protocol error or unplug */ 306 case -EPROTO: /* protocol error or unplug */ 307 case -ETIME: /* protocol error or unplug */ 308 case -ETIMEDOUT: /* Should never happen, but... */ 309 usbhid_mark_busy(usbhid); 310 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 311 hid_io_error(hid); 312 return; 313 default: /* error */ 314 hid_warn(urb->dev, "input irq status %d received\n", 315 urb->status); 316 } 317 318 status = usb_submit_urb(urb, GFP_ATOMIC); 319 if (status) { 320 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 321 if (status != -EPERM) { 322 hid_err(hid, "can't resubmit intr, %s-%s/input%d, status %d\n", 323 hid_to_usb_dev(hid)->bus->bus_name, 324 hid_to_usb_dev(hid)->devpath, 325 usbhid->ifnum, status); 326 hid_io_error(hid); 327 } 328 } 329} 330 331static int hid_submit_out(struct hid_device *hid) 332{ 333 struct hid_report *report; 334 char *raw_report; 335 struct usbhid_device *usbhid = hid->driver_data; 336 int r; 337 338 report = usbhid->out[usbhid->outtail].report; 339 raw_report = usbhid->out[usbhid->outtail].raw_report; 340 341 usbhid->urbout->transfer_buffer_length = ((report->size - 1) >> 3) + 342 1 + (report->id > 0); 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 362static 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 426static 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 473static 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 spin_lock(&usbhid->lock); 480 481 switch (status) { 482 case 0: /* success */ 483 if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN) 484 hid_input_report(urb->context, 485 usbhid->ctrl[usbhid->ctrltail].report->type, 486 urb->transfer_buffer, urb->actual_length, 0); 487 break; 488 case -ESHUTDOWN: /* unplug */ 489 unplug = 1; 490 case -EILSEQ: /* protocol error or unplug */ 491 case -EPROTO: /* protocol error or unplug */ 492 case -ECONNRESET: /* unlink */ 493 case -ENOENT: 494 case -EPIPE: /* report not available */ 495 break; 496 default: /* error */ 497 hid_warn(urb->dev, "ctrl urb status %d received\n", status); 498 } 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 519static 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 628static 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 638static 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 653static 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 660static 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 676int 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 res = hid_start_in(hid); 692 if (res) { 693 if (res != -ENOSPC) { 694 hid_io_error(hid); 695 res = 0; 696 } else { 697 /* no use opening if resources are insufficient */ 698 hid->open--; 699 res = -EBUSY; 700 usbhid->intf->needs_remote_wakeup = 0; 701 } 702 } 703 usb_autopm_put_interface(usbhid->intf); 704 } 705done: 706 mutex_unlock(&hid_open_mut); 707 return res; 708} 709 710void usbhid_close(struct hid_device *hid) 711{ 712 struct usbhid_device *usbhid = hid->driver_data; 713 714 mutex_lock(&hid_open_mut); 715 716 /* protecting hid->open to make sure we don't restart 717 * data acquistion due to a resumption we no longer 718 * care about 719 */ 720 spin_lock_irq(&usbhid->lock); 721 if (!--hid->open) { 722 spin_unlock_irq(&usbhid->lock); 723 hid_cancel_delayed_stuff(usbhid); 724 if (!(hid->quirks & HID_QUIRK_ALWAYS_POLL)) { 725 usb_kill_urb(usbhid->urbin); 726 usbhid->intf->needs_remote_wakeup = 0; 727 } 728 } else { 729 spin_unlock_irq(&usbhid->lock); 730 } 731 mutex_unlock(&hid_open_mut); 732} 733 734/* 735 * Initialize all reports 736 */ 737 738void usbhid_init_reports(struct hid_device *hid) 739{ 740 struct hid_report *report; 741 struct usbhid_device *usbhid = hid->driver_data; 742 struct hid_report_enum *report_enum; 743 int err, ret; 744 745 if (!(hid->quirks & HID_QUIRK_NO_INIT_INPUT_REPORTS)) { 746 report_enum = &hid->report_enum[HID_INPUT_REPORT]; 747 list_for_each_entry(report, &report_enum->report_list, list) 748 usbhid_submit_report(hid, report, USB_DIR_IN); 749 } 750 751 report_enum = &hid->report_enum[HID_FEATURE_REPORT]; 752 list_for_each_entry(report, &report_enum->report_list, list) 753 usbhid_submit_report(hid, report, USB_DIR_IN); 754 755 err = 0; 756 ret = usbhid_wait_io(hid); 757 while (ret) { 758 err |= ret; 759 if (test_bit(HID_CTRL_RUNNING, &usbhid->iofl)) 760 usb_kill_urb(usbhid->urbctrl); 761 if (test_bit(HID_OUT_RUNNING, &usbhid->iofl)) 762 usb_kill_urb(usbhid->urbout); 763 ret = usbhid_wait_io(hid); 764 } 765 766 if (err) 767 hid_warn(hid, "timeout initializing reports\n"); 768} 769 770/* 771 * Reset LEDs which BIOS might have left on. For now, just NumLock (0x01). 772 */ 773static int hid_find_field_early(struct hid_device *hid, unsigned int page, 774 unsigned int hid_code, struct hid_field **pfield) 775{ 776 struct hid_report *report; 777 struct hid_field *field; 778 struct hid_usage *usage; 779 int i, j; 780 781 list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) { 782 for (i = 0; i < report->maxfield; i++) { 783 field = report->field[i]; 784 for (j = 0; j < field->maxusage; j++) { 785 usage = &field->usage[j]; 786 if ((usage->hid & HID_USAGE_PAGE) == page && 787 (usage->hid & 0xFFFF) == hid_code) { 788 *pfield = field; 789 return j; 790 } 791 } 792 } 793 } 794 return -1; 795} 796 797static void usbhid_set_leds(struct hid_device *hid) 798{ 799 struct hid_field *field; 800 int offset; 801 802 if ((offset = hid_find_field_early(hid, HID_UP_LED, 0x01, &field)) != -1) { 803 hid_set_field(field, offset, 0); 804 usbhid_submit_report(hid, field->report, USB_DIR_OUT); 805 } 806} 807 808/* 809 * Traverse the supplied list of reports and find the longest 810 */ 811static void hid_find_max_report(struct hid_device *hid, unsigned int type, 812 unsigned int *max) 813{ 814 struct hid_report *report; 815 unsigned int size; 816 817 list_for_each_entry(report, &hid->report_enum[type].report_list, list) { 818 size = ((report->size - 1) >> 3) + 1 + hid->report_enum[type].numbered; 819 if (*max < size) 820 *max = size; 821 } 822} 823 824static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid) 825{ 826 struct usbhid_device *usbhid = hid->driver_data; 827 828 usbhid->inbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL, 829 &usbhid->inbuf_dma); 830 usbhid->outbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL, 831 &usbhid->outbuf_dma); 832 usbhid->cr = kmalloc(sizeof(*usbhid->cr), GFP_KERNEL); 833 usbhid->ctrlbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL, 834 &usbhid->ctrlbuf_dma); 835 if (!usbhid->inbuf || !usbhid->outbuf || !usbhid->cr || 836 !usbhid->ctrlbuf) 837 return -1; 838 839 return 0; 840} 841 842static int usbhid_get_raw_report(struct hid_device *hid, 843 unsigned char report_number, __u8 *buf, size_t count, 844 unsigned char report_type) 845{ 846 struct usbhid_device *usbhid = hid->driver_data; 847 struct usb_device *dev = hid_to_usb_dev(hid); 848 struct usb_interface *intf = usbhid->intf; 849 struct usb_host_interface *interface = intf->cur_altsetting; 850 int skipped_report_id = 0; 851 int ret; 852 853 /* Byte 0 is the report number. Report data starts at byte 1.*/ 854 buf[0] = report_number; 855 if (report_number == 0x0) { 856 /* Offset the return buffer by 1, so that the report ID 857 will remain in byte 0. */ 858 buf++; 859 count--; 860 skipped_report_id = 1; 861 } 862 ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 863 HID_REQ_GET_REPORT, 864 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 865 ((report_type + 1) << 8) | report_number, 866 interface->desc.bInterfaceNumber, buf, count, 867 USB_CTRL_SET_TIMEOUT); 868 869 /* count also the report id */ 870 if (ret > 0 && skipped_report_id) 871 ret++; 872 873 return ret; 874} 875 876static int usbhid_set_raw_report(struct hid_device *hid, unsigned int reportnum, 877 __u8 *buf, size_t count, unsigned char rtype) 878{ 879 struct usbhid_device *usbhid = hid->driver_data; 880 struct usb_device *dev = hid_to_usb_dev(hid); 881 struct usb_interface *intf = usbhid->intf; 882 struct usb_host_interface *interface = intf->cur_altsetting; 883 int ret, skipped_report_id = 0; 884 885 /* Byte 0 is the report number. Report data starts at byte 1.*/ 886 if ((rtype == HID_OUTPUT_REPORT) && 887 (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORT_ID)) 888 buf[0] = 0; 889 else 890 buf[0] = reportnum; 891 892 if (buf[0] == 0x0) { 893 /* Don't send the Report ID */ 894 buf++; 895 count--; 896 skipped_report_id = 1; 897 } 898 899 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 900 HID_REQ_SET_REPORT, 901 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 902 ((rtype + 1) << 8) | reportnum, 903 interface->desc.bInterfaceNumber, buf, count, 904 USB_CTRL_SET_TIMEOUT); 905 /* count also the report id, if this was a numbered report. */ 906 if (ret > 0 && skipped_report_id) 907 ret++; 908 909 return ret; 910} 911 912static int usbhid_output_report(struct hid_device *hid, __u8 *buf, size_t count) 913{ 914 struct usbhid_device *usbhid = hid->driver_data; 915 struct usb_device *dev = hid_to_usb_dev(hid); 916 int actual_length, skipped_report_id = 0, ret; 917 918 if (!usbhid->urbout) 919 return -ENOSYS; 920 921 if (buf[0] == 0x0) { 922 /* Don't send the Report ID */ 923 buf++; 924 count--; 925 skipped_report_id = 1; 926 } 927 928 ret = usb_interrupt_msg(dev, usbhid->urbout->pipe, 929 buf, count, &actual_length, 930 USB_CTRL_SET_TIMEOUT); 931 /* return the number of bytes transferred */ 932 if (ret == 0) { 933 ret = actual_length; 934 /* count also the report id */ 935 if (skipped_report_id) 936 ret++; 937 } 938 939 return ret; 940} 941 942static void usbhid_restart_queues(struct usbhid_device *usbhid) 943{ 944 if (usbhid->urbout && !test_bit(HID_OUT_RUNNING, &usbhid->iofl)) 945 usbhid_restart_out_queue(usbhid); 946 if (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl)) 947 usbhid_restart_ctrl_queue(usbhid); 948} 949 950static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid) 951{ 952 struct usbhid_device *usbhid = hid->driver_data; 953 954 usb_free_coherent(dev, usbhid->bufsize, usbhid->inbuf, usbhid->inbuf_dma); 955 usb_free_coherent(dev, usbhid->bufsize, usbhid->outbuf, usbhid->outbuf_dma); 956 kfree(usbhid->cr); 957 usb_free_coherent(dev, usbhid->bufsize, usbhid->ctrlbuf, usbhid->ctrlbuf_dma); 958} 959 960static int usbhid_parse(struct hid_device *hid) 961{ 962 struct usb_interface *intf = to_usb_interface(hid->dev.parent); 963 struct usb_host_interface *interface = intf->cur_altsetting; 964 struct usb_device *dev = interface_to_usbdev (intf); 965 struct hid_descriptor *hdesc; 966 u32 quirks = 0; 967 unsigned int rsize = 0; 968 char *rdesc; 969 int ret, n; 970 971 quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor), 972 le16_to_cpu(dev->descriptor.idProduct)); 973 974 if (quirks & HID_QUIRK_IGNORE) 975 return -ENODEV; 976 977 /* Many keyboards and mice don't like to be polled for reports, 978 * so we will always set the HID_QUIRK_NOGET flag for them. */ 979 if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT) { 980 if (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_KEYBOARD || 981 interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE) 982 quirks |= HID_QUIRK_NOGET; 983 } 984 985 if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) && 986 (!interface->desc.bNumEndpoints || 987 usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) { 988 dbg_hid("class descriptor not present\n"); 989 return -ENODEV; 990 } 991 992 hid->version = le16_to_cpu(hdesc->bcdHID); 993 hid->country = hdesc->bCountryCode; 994 995 for (n = 0; n < hdesc->bNumDescriptors; n++) 996 if (hdesc->desc[n].bDescriptorType == HID_DT_REPORT) 997 rsize = le16_to_cpu(hdesc->desc[n].wDescriptorLength); 998 999 if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) { 1000 dbg_hid("weird size of report descriptor (%u)\n", rsize); 1001 return -EINVAL; 1002 } 1003 1004 if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) { 1005 dbg_hid("couldn't allocate rdesc memory\n"); 1006 return -ENOMEM; 1007 } 1008 1009 hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0); 1010 1011 ret = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber, 1012 HID_DT_REPORT, rdesc, rsize); 1013 if (ret < 0) { 1014 dbg_hid("reading report descriptor failed\n"); 1015 kfree(rdesc); 1016 goto err; 1017 } 1018 1019 ret = hid_parse_report(hid, rdesc, rsize); 1020 kfree(rdesc); 1021 if (ret) { 1022 dbg_hid("parsing report descriptor failed\n"); 1023 goto err; 1024 } 1025 1026 hid->quirks |= quirks; 1027 1028 return 0; 1029err: 1030 return ret; 1031} 1032 1033static int usbhid_start(struct hid_device *hid) 1034{ 1035 struct usb_interface *intf = to_usb_interface(hid->dev.parent); 1036 struct usb_host_interface *interface = intf->cur_altsetting; 1037 struct usb_device *dev = interface_to_usbdev(intf); 1038 struct usbhid_device *usbhid = hid->driver_data; 1039 unsigned int n, insize = 0; 1040 int ret; 1041 1042 clear_bit(HID_DISCONNECTED, &usbhid->iofl); 1043 1044 usbhid->bufsize = HID_MIN_BUFFER_SIZE; 1045 hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize); 1046 hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize); 1047 hid_find_max_report(hid, HID_FEATURE_REPORT, &usbhid->bufsize); 1048 1049 if (usbhid->bufsize > HID_MAX_BUFFER_SIZE) 1050 usbhid->bufsize = HID_MAX_BUFFER_SIZE; 1051 1052 hid_find_max_report(hid, HID_INPUT_REPORT, &insize); 1053 1054 if (insize > HID_MAX_BUFFER_SIZE) 1055 insize = HID_MAX_BUFFER_SIZE; 1056 1057 if (hid_alloc_buffers(dev, hid)) { 1058 ret = -ENOMEM; 1059 goto fail; 1060 } 1061 1062 for (n = 0; n < interface->desc.bNumEndpoints; n++) { 1063 struct usb_endpoint_descriptor *endpoint; 1064 int pipe; 1065 int interval; 1066 1067 endpoint = &interface->endpoint[n].desc; 1068 if (!usb_endpoint_xfer_int(endpoint)) 1069 continue; 1070 1071 interval = endpoint->bInterval; 1072 1073 /* Some vendors give fullspeed interval on highspeed devides */ 1074 if (hid->quirks & HID_QUIRK_FULLSPEED_INTERVAL && 1075 dev->speed == USB_SPEED_HIGH) { 1076 interval = fls(endpoint->bInterval*8); 1077 printk(KERN_INFO "%s: Fixing fullspeed to highspeed interval: %d -> %d\n", 1078 hid->name, endpoint->bInterval, interval); 1079 } 1080 1081 /* Change the polling interval of mice. */ 1082 if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0) 1083 interval = hid_mousepoll_interval; 1084 1085 ret = -ENOMEM; 1086 if (usb_endpoint_dir_in(endpoint)) { 1087 if (usbhid->urbin) 1088 continue; 1089 if (!(usbhid->urbin = usb_alloc_urb(0, GFP_KERNEL))) 1090 goto fail; 1091 pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress); 1092 usb_fill_int_urb(usbhid->urbin, dev, pipe, usbhid->inbuf, insize, 1093 hid_irq_in, hid, interval); 1094 usbhid->urbin->transfer_dma = usbhid->inbuf_dma; 1095 usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1096 } else { 1097 if (usbhid->urbout) 1098 continue; 1099 if (!(usbhid->urbout = usb_alloc_urb(0, GFP_KERNEL))) 1100 goto fail; 1101 pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress); 1102 usb_fill_int_urb(usbhid->urbout, dev, pipe, usbhid->outbuf, 0, 1103 hid_irq_out, hid, interval); 1104 usbhid->urbout->transfer_dma = usbhid->outbuf_dma; 1105 usbhid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1106 } 1107 } 1108 1109 usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL); 1110 if (!usbhid->urbctrl) { 1111 ret = -ENOMEM; 1112 goto fail; 1113 } 1114 1115 usb_fill_control_urb(usbhid->urbctrl, dev, 0, (void *) usbhid->cr, 1116 usbhid->ctrlbuf, 1, hid_ctrl, hid); 1117 usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma; 1118 usbhid->urbctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1119 1120 if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS)) 1121 usbhid_init_reports(hid); 1122 1123 set_bit(HID_STARTED, &usbhid->iofl); 1124 1125 if (hid->quirks & HID_QUIRK_ALWAYS_POLL) { 1126 ret = usb_autopm_get_interface(usbhid->intf); 1127 if (ret) 1128 goto fail; 1129 usbhid->intf->needs_remote_wakeup = 1; 1130 ret = hid_start_in(hid); 1131 if (ret) { 1132 dev_err(&hid->dev, 1133 "failed to start in urb: %d\n", ret); 1134 } 1135 usb_autopm_put_interface(usbhid->intf); 1136 } 1137 1138 /* Some keyboards don't work until their LEDs have been set. 1139 * Since BIOSes do set the LEDs, it must be safe for any device 1140 * that supports the keyboard boot protocol. 1141 * In addition, enable remote wakeup by default for all keyboard 1142 * devices supporting the boot protocol. 1143 */ 1144 if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT && 1145 interface->desc.bInterfaceProtocol == 1146 USB_INTERFACE_PROTOCOL_KEYBOARD) { 1147 usbhid_set_leds(hid); 1148 device_set_wakeup_enable(&dev->dev, 1); 1149 } 1150 return 0; 1151 1152fail: 1153 usb_free_urb(usbhid->urbin); 1154 usb_free_urb(usbhid->urbout); 1155 usb_free_urb(usbhid->urbctrl); 1156 usbhid->urbin = NULL; 1157 usbhid->urbout = NULL; 1158 usbhid->urbctrl = NULL; 1159 hid_free_buffers(dev, hid); 1160 return ret; 1161} 1162 1163static void usbhid_stop(struct hid_device *hid) 1164{ 1165 struct usbhid_device *usbhid = hid->driver_data; 1166 1167 if (WARN_ON(!usbhid)) 1168 return; 1169 1170 if (hid->quirks & HID_QUIRK_ALWAYS_POLL) 1171 usbhid->intf->needs_remote_wakeup = 0; 1172 1173 clear_bit(HID_STARTED, &usbhid->iofl); 1174 spin_lock_irq(&usbhid->lock); /* Sync with error and led handlers */ 1175 set_bit(HID_DISCONNECTED, &usbhid->iofl); 1176 spin_unlock_irq(&usbhid->lock); 1177 usb_kill_urb(usbhid->urbin); 1178 usb_kill_urb(usbhid->urbout); 1179 usb_kill_urb(usbhid->urbctrl); 1180 1181 hid_cancel_delayed_stuff(usbhid); 1182 1183 hid->claimed = 0; 1184 1185 usb_free_urb(usbhid->urbin); 1186 usb_free_urb(usbhid->urbctrl); 1187 usb_free_urb(usbhid->urbout); 1188 usbhid->urbin = NULL; /* don't mess up next start */ 1189 usbhid->urbctrl = NULL; 1190 usbhid->urbout = NULL; 1191 1192 hid_free_buffers(hid_to_usb_dev(hid), hid); 1193} 1194 1195static int usbhid_power(struct hid_device *hid, int lvl) 1196{ 1197 int r = 0; 1198 1199 switch (lvl) { 1200 case PM_HINT_FULLON: 1201 r = usbhid_get_power(hid); 1202 break; 1203 case PM_HINT_NORMAL: 1204 usbhid_put_power(hid); 1205 break; 1206 } 1207 return r; 1208} 1209 1210static void usbhid_request(struct hid_device *hid, struct hid_report *rep, int reqtype) 1211{ 1212 switch (reqtype) { 1213 case HID_REQ_GET_REPORT: 1214 usbhid_submit_report(hid, rep, USB_DIR_IN); 1215 break; 1216 case HID_REQ_SET_REPORT: 1217 usbhid_submit_report(hid, rep, USB_DIR_OUT); 1218 break; 1219 } 1220} 1221 1222static int usbhid_raw_request(struct hid_device *hid, unsigned char reportnum, 1223 __u8 *buf, size_t len, unsigned char rtype, 1224 int reqtype) 1225{ 1226 switch (reqtype) { 1227 case HID_REQ_GET_REPORT: 1228 return usbhid_get_raw_report(hid, reportnum, buf, len, rtype); 1229 case HID_REQ_SET_REPORT: 1230 return usbhid_set_raw_report(hid, reportnum, buf, len, rtype); 1231 default: 1232 return -EIO; 1233 } 1234} 1235 1236static int usbhid_idle(struct hid_device *hid, int report, int idle, 1237 int reqtype) 1238{ 1239 struct usb_device *dev = hid_to_usb_dev(hid); 1240 struct usb_interface *intf = to_usb_interface(hid->dev.parent); 1241 struct usb_host_interface *interface = intf->cur_altsetting; 1242 int ifnum = interface->desc.bInterfaceNumber; 1243 1244 if (reqtype != HID_REQ_SET_IDLE) 1245 return -EINVAL; 1246 1247 return hid_set_idle(dev, ifnum, report, idle); 1248} 1249 1250static struct hid_ll_driver usb_hid_driver = { 1251 .parse = usbhid_parse, 1252 .start = usbhid_start, 1253 .stop = usbhid_stop, 1254 .open = usbhid_open, 1255 .close = usbhid_close, 1256 .power = usbhid_power, 1257 .request = usbhid_request, 1258 .wait = usbhid_wait_io, 1259 .raw_request = usbhid_raw_request, 1260 .output_report = usbhid_output_report, 1261 .idle = usbhid_idle, 1262}; 1263 1264static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *id) 1265{ 1266 struct usb_host_interface *interface = intf->cur_altsetting; 1267 struct usb_device *dev = interface_to_usbdev(intf); 1268 struct usbhid_device *usbhid; 1269 struct hid_device *hid; 1270 unsigned int n, has_in = 0; 1271 size_t len; 1272 int ret; 1273 1274 dbg_hid("HID probe called for ifnum %d\n", 1275 intf->altsetting->desc.bInterfaceNumber); 1276 1277 for (n = 0; n < interface->desc.bNumEndpoints; n++) 1278 if (usb_endpoint_is_int_in(&interface->endpoint[n].desc)) 1279 has_in++; 1280 if (!has_in) { 1281 hid_err(intf, "couldn't find an input interrupt endpoint\n"); 1282 return -ENODEV; 1283 } 1284 1285 hid = hid_allocate_device(); 1286 if (IS_ERR(hid)) 1287 return PTR_ERR(hid); 1288 1289 usb_set_intfdata(intf, hid); 1290 hid->ll_driver = &usb_hid_driver; 1291 hid->ff_init = hid_pidff_init; 1292#ifdef CONFIG_USB_HIDDEV 1293 hid->hiddev_connect = hiddev_connect; 1294 hid->hiddev_disconnect = hiddev_disconnect; 1295 hid->hiddev_hid_event = hiddev_hid_event; 1296 hid->hiddev_report_event = hiddev_report_event; 1297#endif 1298 hid->dev.parent = &intf->dev; 1299 hid->bus = BUS_USB; 1300 hid->vendor = le16_to_cpu(dev->descriptor.idVendor); 1301 hid->product = le16_to_cpu(dev->descriptor.idProduct); 1302 hid->name[0] = 0; 1303 hid->quirks = usbhid_lookup_quirk(hid->vendor, hid->product); 1304 if (intf->cur_altsetting->desc.bInterfaceProtocol == 1305 USB_INTERFACE_PROTOCOL_MOUSE) 1306 hid->type = HID_TYPE_USBMOUSE; 1307 else if (intf->cur_altsetting->desc.bInterfaceProtocol == 0) 1308 hid->type = HID_TYPE_USBNONE; 1309 1310 if (dev->manufacturer) 1311 strlcpy(hid->name, dev->manufacturer, sizeof(hid->name)); 1312 1313 if (dev->product) { 1314 if (dev->manufacturer) 1315 strlcat(hid->name, " ", sizeof(hid->name)); 1316 strlcat(hid->name, dev->product, sizeof(hid->name)); 1317 } 1318 1319 if (!strlen(hid->name)) 1320 snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x", 1321 le16_to_cpu(dev->descriptor.idVendor), 1322 le16_to_cpu(dev->descriptor.idProduct)); 1323 1324 usb_make_path(dev, hid->phys, sizeof(hid->phys)); 1325 strlcat(hid->phys, "/input", sizeof(hid->phys)); 1326 len = strlen(hid->phys); 1327 if (len < sizeof(hid->phys) - 1) 1328 snprintf(hid->phys + len, sizeof(hid->phys) - len, 1329 "%d", intf->altsetting[0].desc.bInterfaceNumber); 1330 1331 if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0) 1332 hid->uniq[0] = 0; 1333 1334 usbhid = kzalloc(sizeof(*usbhid), GFP_KERNEL); 1335 if (usbhid == NULL) { 1336 ret = -ENOMEM; 1337 goto err; 1338 } 1339 1340 hid->driver_data = usbhid; 1341 usbhid->hid = hid; 1342 usbhid->intf = intf; 1343 usbhid->ifnum = interface->desc.bInterfaceNumber; 1344 1345 init_waitqueue_head(&usbhid->wait); 1346 INIT_WORK(&usbhid->reset_work, hid_reset); 1347 setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid); 1348 spin_lock_init(&usbhid->lock); 1349 1350 ret = hid_add_device(hid); 1351 if (ret) { 1352 if (ret != -ENODEV) 1353 hid_err(intf, "can't add hid device: %d\n", ret); 1354 goto err_free; 1355 } 1356 1357 return 0; 1358err_free: 1359 kfree(usbhid); 1360err: 1361 hid_destroy_device(hid); 1362 return ret; 1363} 1364 1365static void usbhid_disconnect(struct usb_interface *intf) 1366{ 1367 struct hid_device *hid = usb_get_intfdata(intf); 1368 struct usbhid_device *usbhid; 1369 1370 if (WARN_ON(!hid)) 1371 return; 1372 1373 usbhid = hid->driver_data; 1374 spin_lock_irq(&usbhid->lock); /* Sync with error and led handlers */ 1375 set_bit(HID_DISCONNECTED, &usbhid->iofl); 1376 spin_unlock_irq(&usbhid->lock); 1377 hid_destroy_device(hid); 1378 kfree(usbhid); 1379} 1380 1381static void hid_cancel_delayed_stuff(struct usbhid_device *usbhid) 1382{ 1383 del_timer_sync(&usbhid->io_retry); 1384 cancel_work_sync(&usbhid->reset_work); 1385} 1386 1387static void hid_cease_io(struct usbhid_device *usbhid) 1388{ 1389 del_timer_sync(&usbhid->io_retry); 1390 usb_kill_urb(usbhid->urbin); 1391 usb_kill_urb(usbhid->urbctrl); 1392 usb_kill_urb(usbhid->urbout); 1393} 1394 1395/* Treat USB reset pretty much the same as suspend/resume */ 1396static int hid_pre_reset(struct usb_interface *intf) 1397{ 1398 struct hid_device *hid = usb_get_intfdata(intf); 1399 struct usbhid_device *usbhid = hid->driver_data; 1400 1401 spin_lock_irq(&usbhid->lock); 1402 set_bit(HID_RESET_PENDING, &usbhid->iofl); 1403 spin_unlock_irq(&usbhid->lock); 1404 hid_cease_io(usbhid); 1405 1406 return 0; 1407} 1408 1409/* Same routine used for post_reset and reset_resume */ 1410static int hid_post_reset(struct usb_interface *intf) 1411{ 1412 struct usb_device *dev = interface_to_usbdev (intf); 1413 struct hid_device *hid = usb_get_intfdata(intf); 1414 struct usbhid_device *usbhid = hid->driver_data; 1415 struct usb_host_interface *interface = intf->cur_altsetting; 1416 int status; 1417 char *rdesc; 1418 1419 /* Fetch and examine the HID report descriptor. If this 1420 * has changed, then rebind. Since usbcore's check of the 1421 * configuration descriptors passed, we already know that 1422 * the size of the HID report descriptor has not changed. 1423 */ 1424 rdesc = kmalloc(hid->dev_rsize, GFP_KERNEL); 1425 if (!rdesc) { 1426 dbg_hid("couldn't allocate rdesc memory (post_reset)\n"); 1427 return 1; 1428 } 1429 status = hid_get_class_descriptor(dev, 1430 interface->desc.bInterfaceNumber, 1431 HID_DT_REPORT, rdesc, hid->dev_rsize); 1432 if (status < 0) { 1433 dbg_hid("reading report descriptor failed (post_reset)\n"); 1434 kfree(rdesc); 1435 return 1; 1436 } 1437 status = memcmp(rdesc, hid->dev_rdesc, hid->dev_rsize); 1438 kfree(rdesc); 1439 if (status != 0) { 1440 dbg_hid("report descriptor changed\n"); 1441 return 1; 1442 } 1443 1444 spin_lock_irq(&usbhid->lock); 1445 clear_bit(HID_RESET_PENDING, &usbhid->iofl); 1446 spin_unlock_irq(&usbhid->lock); 1447 hid_set_idle(dev, intf->cur_altsetting->desc.bInterfaceNumber, 0, 0); 1448 status = hid_start_in(hid); 1449 if (status < 0) 1450 hid_io_error(hid); 1451 usbhid_restart_queues(usbhid); 1452 1453 return 0; 1454} 1455 1456int usbhid_get_power(struct hid_device *hid) 1457{ 1458 struct usbhid_device *usbhid = hid->driver_data; 1459 1460 return usb_autopm_get_interface(usbhid->intf); 1461} 1462 1463void usbhid_put_power(struct hid_device *hid) 1464{ 1465 struct usbhid_device *usbhid = hid->driver_data; 1466 1467 usb_autopm_put_interface(usbhid->intf); 1468} 1469 1470 1471#ifdef CONFIG_PM 1472static int hid_resume_common(struct hid_device *hid, bool driver_suspended) 1473{ 1474 struct usbhid_device *usbhid = hid->driver_data; 1475 int status; 1476 1477 spin_lock_irq(&usbhid->lock); 1478 clear_bit(HID_SUSPENDED, &usbhid->iofl); 1479 usbhid_mark_busy(usbhid); 1480 1481 if (test_bit(HID_CLEAR_HALT, &usbhid->iofl) || 1482 test_bit(HID_RESET_PENDING, &usbhid->iofl)) 1483 schedule_work(&usbhid->reset_work); 1484 usbhid->retry_delay = 0; 1485 1486 usbhid_restart_queues(usbhid); 1487 spin_unlock_irq(&usbhid->lock); 1488 1489 status = hid_start_in(hid); 1490 if (status < 0) 1491 hid_io_error(hid); 1492 1493 if (driver_suspended && hid->driver && hid->driver->resume) 1494 status = hid->driver->resume(hid); 1495 return status; 1496} 1497 1498static int hid_suspend(struct usb_interface *intf, pm_message_t message) 1499{ 1500 struct hid_device *hid = usb_get_intfdata(intf); 1501 struct usbhid_device *usbhid = hid->driver_data; 1502 int status = 0; 1503 bool driver_suspended = false; 1504 unsigned int ledcount; 1505 1506 if (PMSG_IS_AUTO(message)) { 1507 ledcount = hidinput_count_leds(hid); 1508 spin_lock_irq(&usbhid->lock); /* Sync with error handler */ 1509 if (!test_bit(HID_RESET_PENDING, &usbhid->iofl) 1510 && !test_bit(HID_CLEAR_HALT, &usbhid->iofl) 1511 && !test_bit(HID_OUT_RUNNING, &usbhid->iofl) 1512 && !test_bit(HID_CTRL_RUNNING, &usbhid->iofl) 1513 && !test_bit(HID_KEYS_PRESSED, &usbhid->iofl) 1514 && (!ledcount || ignoreled)) 1515 { 1516 set_bit(HID_SUSPENDED, &usbhid->iofl); 1517 spin_unlock_irq(&usbhid->lock); 1518 if (hid->driver && hid->driver->suspend) { 1519 status = hid->driver->suspend(hid, message); 1520 if (status < 0) 1521 goto failed; 1522 } 1523 driver_suspended = true; 1524 } else { 1525 usbhid_mark_busy(usbhid); 1526 spin_unlock_irq(&usbhid->lock); 1527 return -EBUSY; 1528 } 1529 1530 } else { 1531 /* TODO: resume() might need to handle suspend failure */ 1532 if (hid->driver && hid->driver->suspend) 1533 status = hid->driver->suspend(hid, message); 1534 driver_suspended = true; 1535 spin_lock_irq(&usbhid->lock); 1536 set_bit(HID_SUSPENDED, &usbhid->iofl); 1537 spin_unlock_irq(&usbhid->lock); 1538 if (usbhid_wait_io(hid) < 0) 1539 status = -EIO; 1540 } 1541 1542 hid_cancel_delayed_stuff(usbhid); 1543 hid_cease_io(usbhid); 1544 1545 if (PMSG_IS_AUTO(message) && test_bit(HID_KEYS_PRESSED, &usbhid->iofl)) { 1546 /* lost race against keypresses */ 1547 status = -EBUSY; 1548 goto failed; 1549 } 1550 dev_dbg(&intf->dev, "suspend\n"); 1551 return status; 1552 1553 failed: 1554 hid_resume_common(hid, driver_suspended); 1555 return status; 1556} 1557 1558static int hid_resume(struct usb_interface *intf) 1559{ 1560 struct hid_device *hid = usb_get_intfdata (intf); 1561 struct usbhid_device *usbhid = hid->driver_data; 1562 int status; 1563 1564 if (!test_bit(HID_STARTED, &usbhid->iofl)) 1565 return 0; 1566 1567 status = hid_resume_common(hid, true); 1568 dev_dbg(&intf->dev, "resume status %d\n", status); 1569 return 0; 1570} 1571 1572static int hid_reset_resume(struct usb_interface *intf) 1573{ 1574 struct hid_device *hid = usb_get_intfdata(intf); 1575 struct usbhid_device *usbhid = hid->driver_data; 1576 int status; 1577 1578 clear_bit(HID_SUSPENDED, &usbhid->iofl); 1579 status = hid_post_reset(intf); 1580 if (status >= 0 && hid->driver && hid->driver->reset_resume) { 1581 int ret = hid->driver->reset_resume(hid); 1582 if (ret < 0) 1583 status = ret; 1584 } 1585 return status; 1586} 1587 1588#endif /* CONFIG_PM */ 1589 1590static const struct usb_device_id hid_usb_ids[] = { 1591 { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS, 1592 .bInterfaceClass = USB_INTERFACE_CLASS_HID }, 1593 { } /* Terminating entry */ 1594}; 1595 1596MODULE_DEVICE_TABLE (usb, hid_usb_ids); 1597 1598static struct usb_driver hid_driver = { 1599 .name = "usbhid", 1600 .probe = usbhid_probe, 1601 .disconnect = usbhid_disconnect, 1602#ifdef CONFIG_PM 1603 .suspend = hid_suspend, 1604 .resume = hid_resume, 1605 .reset_resume = hid_reset_resume, 1606#endif 1607 .pre_reset = hid_pre_reset, 1608 .post_reset = hid_post_reset, 1609 .id_table = hid_usb_ids, 1610 .supports_autosuspend = 1, 1611}; 1612 1613struct usb_interface *usbhid_find_interface(int minor) 1614{ 1615 return usb_find_interface(&hid_driver, minor); 1616} 1617 1618static int __init hid_init(void) 1619{ 1620 int retval = -ENOMEM; 1621 1622 retval = usbhid_quirks_init(quirks_param); 1623 if (retval) 1624 goto usbhid_quirks_init_fail; 1625 retval = usb_register(&hid_driver); 1626 if (retval) 1627 goto usb_register_fail; 1628 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 1629 1630 return 0; 1631usb_register_fail: 1632 usbhid_quirks_exit(); 1633usbhid_quirks_init_fail: 1634 return retval; 1635} 1636 1637static void __exit hid_exit(void) 1638{ 1639 usb_deregister(&hid_driver); 1640 usbhid_quirks_exit(); 1641} 1642 1643module_init(hid_init); 1644module_exit(hid_exit); 1645 1646MODULE_AUTHOR("Andreas Gal"); 1647MODULE_AUTHOR("Vojtech Pavlik"); 1648MODULE_AUTHOR("Jiri Kosina"); 1649MODULE_DESCRIPTION(DRIVER_DESC); 1650MODULE_LICENSE(DRIVER_LICENSE); 1651