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