LCOV - code coverage report
Current view: top level - drivers/hid/usbhid - hid-core.c (source / functions) Hit Total Coverage
Test: Real Lines: 293 719 40.8 %
Date: 2020-10-17 15:46:16 Functions: 0 46 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14