LCOV - code coverage report
Current view: top level - drivers/hid/usbhid - hid-core.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 627 793 79.1 %
Date: 2017-01-25 Functions: 35 43 81.4 %

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

Generated by: LCOV version 1.10