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