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