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