drivers/hid/usbhid/hid-core.c

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