hid-core.c 38.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4
/*
 *  USB HID support for Linux
 *
 *  Copyright (c) 1999 Andreas Gal
5 6
 *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
 *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
7
 *  Copyright (c) 2007-2008 Oliver Neukum
Jiri Kosina's avatar
Jiri Kosina committed
8
 *  Copyright (c) 2006-2010 Jiri Kosina
Linus Torvalds's avatar
Linus Torvalds committed
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 */

/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/mm.h>
24
#include <linux/mutex.h>
Linus Torvalds's avatar
Linus Torvalds committed
25 26 27 28 29
#include <linux/spinlock.h>
#include <asm/unaligned.h>
#include <asm/byteorder.h>
#include <linux/input.h>
#include <linux/wait.h>
30
#include <linux/workqueue.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33

#include <linux/usb.h>

34
#include <linux/hid.h>
Linus Torvalds's avatar
Linus Torvalds committed
35
#include <linux/hiddev.h>
36
#include <linux/hid-debug.h>
Jiri Kosina's avatar
Jiri Kosina committed
37
#include <linux/hidraw.h>
38
#include "usbhid.h"
Linus Torvalds's avatar
Linus Torvalds committed
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

/*
 * Version Information
 */

#define DRIVER_DESC "USB HID core driver"
#define DRIVER_LICENSE "GPL"

/*
 * Module parameters.
 */

static unsigned int hid_mousepoll_interval;
module_param_named(mousepoll, hid_mousepoll_interval, uint, 0644);
MODULE_PARM_DESC(mousepoll, "Polling interval of mice");

55 56 57 58
static unsigned int ignoreled;
module_param_named(ignoreled, ignoreled, uint, 0644);
MODULE_PARM_DESC(ignoreled, "Autosuspend with active leds");

59 60 61 62 63 64 65
/* Quirks specified at module load time */
static char *quirks_param[MAX_USBHID_BOOT_QUIRKS] = { [ 0 ... (MAX_USBHID_BOOT_QUIRKS - 1) ] = NULL };
module_param_array_named(quirks, quirks_param, charp, NULL, 0444);
MODULE_PARM_DESC(quirks, "Add/modify USB HID quirks by specifying "
		" quirks=vendorID:productID:quirks"
		" where vendorID, productID, and quirks are all in"
		" 0x-prefixed hex");
Linus Torvalds's avatar
Linus Torvalds committed
66
/*
67
 * Input submission and I/O error handler.
Linus Torvalds's avatar
Linus Torvalds committed
68
 */
69 70
static DEFINE_MUTEX(hid_open_mut);
static struct workqueue_struct *resumption_waker;
Linus Torvalds's avatar
Linus Torvalds committed
71

72
static void hid_io_error(struct hid_device *hid);
73 74 75
static int hid_submit_out(struct hid_device *hid);
static int hid_submit_ctrl(struct hid_device *hid);
static void hid_cancel_delayed_stuff(struct usbhid_device *usbhid);
76 77 78

/* Start up the input URB */
static int hid_start_in(struct hid_device *hid)
Linus Torvalds's avatar
Linus Torvalds committed
79 80
{
	unsigned long flags;
81 82
	int rc = 0;
	struct usbhid_device *usbhid = hid->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
83

84 85
	spin_lock_irqsave(&usbhid->lock, flags);
	if (hid->open > 0 &&
86
			!test_bit(HID_DISCONNECTED, &usbhid->iofl) &&
87
			!test_bit(HID_REPORTED_IDLE, &usbhid->iofl) &&
88 89 90 91
			!test_and_set_bit(HID_IN_RUNNING, &usbhid->iofl)) {
		rc = usb_submit_urb(usbhid->urbin, GFP_ATOMIC);
		if (rc != 0)
			clear_bit(HID_IN_RUNNING, &usbhid->iofl);
Linus Torvalds's avatar
Linus Torvalds committed
92
	}
93
	spin_unlock_irqrestore(&usbhid->lock, flags);
94
	return rc;
Linus Torvalds's avatar
Linus Torvalds committed
95 96
}

97 98
/* I/O retry timer routine */
static void hid_retry_timeout(unsigned long _hid)
Linus Torvalds's avatar
Linus Torvalds committed
99
{
100
	struct hid_device *hid = (struct hid_device *) _hid;
101
	struct usbhid_device *usbhid = hid->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
102

103 104 105
	dev_dbg(&usbhid->intf->dev, "retrying intr urb\n");
	if (hid_start_in(hid))
		hid_io_error(hid);
Linus Torvalds's avatar
Linus Torvalds committed
106 107
}

108 109
/* Workqueue routine to reset the device or clear a halt */
static void hid_reset(struct work_struct *work)
Linus Torvalds's avatar
Linus Torvalds committed
110
{
111 112 113
	struct usbhid_device *usbhid =
		container_of(work, struct usbhid_device, reset_work);
	struct hid_device *hid = usbhid->hid;
114
	int rc = 0;
Linus Torvalds's avatar
Linus Torvalds committed
115

116 117 118 119 120 121
	if (test_bit(HID_CLEAR_HALT, &usbhid->iofl)) {
		dev_dbg(&usbhid->intf->dev, "clear halt\n");
		rc = usb_clear_halt(hid_to_usb_dev(hid), usbhid->urbin->pipe);
		clear_bit(HID_CLEAR_HALT, &usbhid->iofl);
		hid_start_in(hid);
	}
Linus Torvalds's avatar
Linus Torvalds committed
122

123 124
	else if (test_bit(HID_RESET_PENDING, &usbhid->iofl)) {
		dev_dbg(&usbhid->intf->dev, "resetting device\n");
125 126
		rc = usb_lock_device_for_reset(hid_to_usb_dev(hid), usbhid->intf);
		if (rc == 0) {
127
			rc = usb_reset_device(hid_to_usb_dev(hid));
128
			usb_unlock_device(hid_to_usb_dev(hid));
Linus Torvalds's avatar
Linus Torvalds committed
129
		}
130
		clear_bit(HID_RESET_PENDING, &usbhid->iofl);
Linus Torvalds's avatar
Linus Torvalds committed
131 132
	}

133 134 135 136 137 138
	switch (rc) {
	case 0:
		if (!test_bit(HID_IN_RUNNING, &usbhid->iofl))
			hid_io_error(hid);
		break;
	default:
139
		err_hid("can't reset device, %s-%s/input%d, status %d",
140 141 142 143 144 145 146 147
				hid_to_usb_dev(hid)->bus->bus_name,
				hid_to_usb_dev(hid)->devpath,
				usbhid->ifnum, rc);
		/* FALLTHROUGH */
	case -EHOSTUNREACH:
	case -ENODEV:
	case -EINTR:
		break;
Linus Torvalds's avatar
Linus Torvalds committed
148 149 150
	}
}

151 152
/* Main I/O error handler */
static void hid_io_error(struct hid_device *hid)
153
{
154 155
	unsigned long flags;
	struct usbhid_device *usbhid = hid->driver_data;
156

157
	spin_lock_irqsave(&usbhid->lock, flags);
158

159
	/* Stop when disconnected */
160
	if (test_bit(HID_DISCONNECTED, &usbhid->iofl))
161
		goto done;
162

Alan Stern's avatar
Alan Stern committed
163 164 165 166 167
	/* If it has been a while since the last error, we'll assume
	 * this a brand new error and reset the retry timeout. */
	if (time_after(jiffies, usbhid->stop_retry + HZ/2))
		usbhid->retry_delay = 0;

168 169 170 171 172 173
	/* When an error occurs, retry at increasing intervals */
	if (usbhid->retry_delay == 0) {
		usbhid->retry_delay = 13;	/* Then 26, 52, 104, 104, ... */
		usbhid->stop_retry = jiffies + msecs_to_jiffies(1000);
	} else if (usbhid->retry_delay < 100)
		usbhid->retry_delay *= 2;
174

175
	if (time_after(jiffies, usbhid->stop_retry)) {
176

177 178 179 180 181
		/* Retries failed, so do a port reset */
		if (!test_and_set_bit(HID_RESET_PENDING, &usbhid->iofl)) {
			schedule_work(&usbhid->reset_work);
			goto done;
		}
Linus Torvalds's avatar
Linus Torvalds committed
182 183
	}

184 185 186
	mod_timer(&usbhid->io_retry,
			jiffies + msecs_to_jiffies(usbhid->retry_delay));
done:
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
	spin_unlock_irqrestore(&usbhid->lock, flags);
}

static void usbhid_mark_busy(struct usbhid_device *usbhid)
{
	struct usb_interface *intf = usbhid->intf;

	usb_mark_last_busy(interface_to_usbdev(intf));
}

static int usbhid_restart_out_queue(struct usbhid_device *usbhid)
{
	struct hid_device *hid = usb_get_intfdata(usbhid->intf);
	int kicked;

	if (!hid)
		return 0;

	if ((kicked = (usbhid->outhead != usbhid->outtail))) {
		dbg("Kicking head %d tail %d", usbhid->outhead, usbhid->outtail);
		if (hid_submit_out(hid)) {
			clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
			wake_up(&usbhid->wait);
		}
	}
	return kicked;
}

static int usbhid_restart_ctrl_queue(struct usbhid_device *usbhid)
{
	struct hid_device *hid = usb_get_intfdata(usbhid->intf);
	int kicked;

	WARN_ON(hid == NULL);
	if (!hid)
		return 0;

	if ((kicked = (usbhid->ctrlhead != usbhid->ctrltail))) {
		dbg("Kicking head %d tail %d", usbhid->ctrlhead, usbhid->ctrltail);
		if (hid_submit_ctrl(hid)) {
			clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
			wake_up(&usbhid->wait);
		}
	}
	return kicked;
Linus Torvalds's avatar
Linus Torvalds committed
232 233
}

234 235 236
/*
 * Input interrupt completion handler.
 */
237

238
static void hid_irq_in(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
239
{
240 241 242
	struct hid_device	*hid = urb->context;
	struct usbhid_device 	*usbhid = hid->driver_data;
	int			status;
Linus Torvalds's avatar
Linus Torvalds committed
243

244
	switch (urb->status) {
Jiri Slaby's avatar
Jiri Slaby committed
245
	case 0:			/* success */
246
		usbhid_mark_busy(usbhid);
Jiri Slaby's avatar
Jiri Slaby committed
247 248 249 250
		usbhid->retry_delay = 0;
		hid_input_report(urb->context, HID_INPUT_REPORT,
				 urb->transfer_buffer,
				 urb->actual_length, 1);
251 252 253 254 255 256 257 258 259
		/*
		 * autosuspend refused while keys are pressed
		 * because most keyboards don't wake up when
		 * a key is released
		 */
		if (hid_check_keys_pressed(hid))
			set_bit(HID_KEYS_PRESSED, &usbhid->iofl);
		else
			clear_bit(HID_KEYS_PRESSED, &usbhid->iofl);
Jiri Slaby's avatar
Jiri Slaby committed
260 261
		break;
	case -EPIPE:		/* stall */
262
		usbhid_mark_busy(usbhid);
Jiri Slaby's avatar
Jiri Slaby committed
263 264 265 266 267 268 269 270 271 272 273 274 275
		clear_bit(HID_IN_RUNNING, &usbhid->iofl);
		set_bit(HID_CLEAR_HALT, &usbhid->iofl);
		schedule_work(&usbhid->reset_work);
		return;
	case -ECONNRESET:	/* unlink */
	case -ENOENT:
	case -ESHUTDOWN:	/* unplug */
		clear_bit(HID_IN_RUNNING, &usbhid->iofl);
		return;
	case -EILSEQ:		/* protocol error or unplug */
	case -EPROTO:		/* protocol error or unplug */
	case -ETIME:		/* protocol error or unplug */
	case -ETIMEDOUT:	/* Should never happen, but... */
276
		usbhid_mark_busy(usbhid);
Jiri Slaby's avatar
Jiri Slaby committed
277 278 279 280
		clear_bit(HID_IN_RUNNING, &usbhid->iofl);
		hid_io_error(hid);
		return;
	default:		/* error */
281 282
		dev_warn(&urb->dev->dev, "input irq status %d  "
				"received\n", urb->status);
283
	}
Linus Torvalds's avatar
Linus Torvalds committed
284

285 286 287 288
	status = usb_submit_urb(urb, GFP_ATOMIC);
	if (status) {
		clear_bit(HID_IN_RUNNING, &usbhid->iofl);
		if (status != -EPERM) {
289
			err_hid("can't resubmit intr, %s-%s/input%d, status %d",
290 291 292 293 294 295
					hid_to_usb_dev(hid)->bus->bus_name,
					hid_to_usb_dev(hid)->devpath,
					usbhid->ifnum, status);
			hid_io_error(hid);
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
296 297
}

298
static int hid_submit_out(struct hid_device *hid)
Linus Torvalds's avatar
Linus Torvalds committed
299
{
300
	struct hid_report *report;
301
	char *raw_report;
302 303
	struct usbhid_device *usbhid = hid->driver_data;

304 305
	report = usbhid->out[usbhid->outtail].report;
	raw_report = usbhid->out[usbhid->outtail].raw_report;
Linus Torvalds's avatar
Linus Torvalds committed
306

307 308 309 310 311
	if (!test_bit(HID_REPORTED_IDLE, &usbhid->iofl)) {
		usbhid->urbout->transfer_buffer_length = ((report->size - 1) >> 3) + 1 + (report->id > 0);
		usbhid->urbout->dev = hid_to_usb_dev(hid);
		memcpy(usbhid->outbuf, raw_report, usbhid->urbout->transfer_buffer_length);
		kfree(raw_report);
312

313
		dbg_hid("submitting out urb\n");
314

315 316 317 318
		if (usb_submit_urb(usbhid->urbout, GFP_ATOMIC)) {
			err_hid("usb_submit_urb(out) failed");
			return -1;
		}
319
		usbhid->last_out = jiffies;
320 321 322 323 324 325 326
	} else {
		/*
		 * queue work to wake up the device.
		 * as the work queue is freezeable, this is safe
		 * with respect to STD and STR
		 */
		queue_work(resumption_waker, &usbhid->restart_work);
327
	}
Linus Torvalds's avatar
Linus Torvalds committed
328

329 330 331 332
	return 0;
}

static int hid_submit_ctrl(struct hid_device *hid)
Linus Torvalds's avatar
Linus Torvalds committed
333 334
{
	struct hid_report *report;
335
	unsigned char dir;
336
	char *raw_report;
337
	int len;
338
	struct usbhid_device *usbhid = hid->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
339

340
	report = usbhid->ctrl[usbhid->ctrltail].report;
341
	raw_report = usbhid->ctrl[usbhid->ctrltail].raw_report;
342
	dir = usbhid->ctrl[usbhid->ctrltail].dir;
Linus Torvalds's avatar
Linus Torvalds committed
343

344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
	if (!test_bit(HID_REPORTED_IDLE, &usbhid->iofl)) {
		len = ((report->size - 1) >> 3) + 1 + (report->id > 0);
		if (dir == USB_DIR_OUT) {
			usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0);
			usbhid->urbctrl->transfer_buffer_length = len;
			memcpy(usbhid->ctrlbuf, raw_report, len);
			kfree(raw_report);
		} else {
			int maxpacket, padlen;

			usbhid->urbctrl->pipe = usb_rcvctrlpipe(hid_to_usb_dev(hid), 0);
			maxpacket = usb_maxpacket(hid_to_usb_dev(hid), usbhid->urbctrl->pipe, 0);
			if (maxpacket > 0) {
				padlen = DIV_ROUND_UP(len, maxpacket);
				padlen *= maxpacket;
				if (padlen > usbhid->bufsize)
					padlen = usbhid->bufsize;
			} else
				padlen = 0;
			usbhid->urbctrl->transfer_buffer_length = padlen;
		}
		usbhid->urbctrl->dev = hid_to_usb_dev(hid);
Linus Torvalds's avatar
Linus Torvalds committed
366

367 368 369 370 371
		usbhid->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE | dir;
		usbhid->cr->bRequest = (dir == USB_DIR_OUT) ? HID_REQ_SET_REPORT : HID_REQ_GET_REPORT;
		usbhid->cr->wValue = cpu_to_le16(((report->type + 1) << 8) | report->id);
		usbhid->cr->wIndex = cpu_to_le16(usbhid->ifnum);
		usbhid->cr->wLength = cpu_to_le16(len);
Linus Torvalds's avatar
Linus Torvalds committed
372

373 374 375
		dbg_hid("submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u\n",
			usbhid->cr->bRequest == HID_REQ_SET_REPORT ? "Set_Report" : "Get_Report",
			usbhid->cr->wValue, usbhid->cr->wIndex, usbhid->cr->wLength);
Linus Torvalds's avatar
Linus Torvalds committed
376

377 378 379 380
		if (usb_submit_urb(usbhid->urbctrl, GFP_ATOMIC)) {
			err_hid("usb_submit_urb(ctrl) failed");
			return -1;
		}
381
		usbhid->last_ctrl = jiffies;
382 383 384 385 386 387 388
	} else {
		/*
		 * queue work to wake up the device.
		 * as the work queue is freezeable, this is safe
		 * with respect to STD and STR
		 */
		queue_work(resumption_waker, &usbhid->restart_work);
389
	}
Linus Torvalds's avatar
Linus Torvalds committed
390

391 392
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
393

394 395 396
/*
 * Output interrupt completion handler.
 */
Linus Torvalds's avatar
Linus Torvalds committed
397

398 399 400 401 402 403
static void hid_irq_out(struct urb *urb)
{
	struct hid_device *hid = urb->context;
	struct usbhid_device *usbhid = hid->driver_data;
	unsigned long flags;
	int unplug = 0;
Linus Torvalds's avatar
Linus Torvalds committed
404

405
	switch (urb->status) {
Jiri Slaby's avatar
Jiri Slaby committed
406 407 408 409 410 411 412 413 414 415
	case 0:			/* success */
		break;
	case -ESHUTDOWN:	/* unplug */
		unplug = 1;
	case -EILSEQ:		/* protocol error or unplug */
	case -EPROTO:		/* protocol error or unplug */
	case -ECONNRESET:	/* unlink */
	case -ENOENT:
		break;
	default:		/* error */
416 417
		dev_warn(&urb->dev->dev, "output irq status %d "
				"received\n", urb->status);
418
	}
Linus Torvalds's avatar
Linus Torvalds committed
419

420
	spin_lock_irqsave(&usbhid->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
421

422 423 424 425
	if (unplug)
		usbhid->outtail = usbhid->outhead;
	else
		usbhid->outtail = (usbhid->outtail + 1) & (HID_OUTPUT_FIFO_SIZE - 1);
Linus Torvalds's avatar
Linus Torvalds committed
426

427 428 429
	if (usbhid->outhead != usbhid->outtail) {
		if (hid_submit_out(hid)) {
			clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
Jiri Slaby's avatar
Jiri Slaby committed
430
			wake_up(&usbhid->wait);
431
		}
432
		spin_unlock_irqrestore(&usbhid->lock, flags);
433 434
		return;
	}
Linus Torvalds's avatar
Linus Torvalds committed
435

436
	clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
437
	spin_unlock_irqrestore(&usbhid->lock, flags);
Jiri Slaby's avatar
Jiri Slaby committed
438
	wake_up(&usbhid->wait);
439
}
440

441 442 443
/*
 * Control pipe completion handler.
 */
Linus Torvalds's avatar
Linus Torvalds committed
444

445 446 447 448
static void hid_ctrl(struct urb *urb)
{
	struct hid_device *hid = urb->context;
	struct usbhid_device *usbhid = hid->driver_data;
449
	int unplug = 0, status = urb->status;
Linus Torvalds's avatar
Linus Torvalds committed
450

451
	spin_lock(&usbhid->lock);
Linus Torvalds's avatar
Linus Torvalds committed
452

453
	switch (status) {
Jiri Slaby's avatar
Jiri Slaby committed
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
	case 0:			/* success */
		if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN)
			hid_input_report(urb->context,
				usbhid->ctrl[usbhid->ctrltail].report->type,
				urb->transfer_buffer, urb->actual_length, 0);
		break;
	case -ESHUTDOWN:	/* unplug */
		unplug = 1;
	case -EILSEQ:		/* protocol error or unplug */
	case -EPROTO:		/* protocol error or unplug */
	case -ECONNRESET:	/* unlink */
	case -ENOENT:
	case -EPIPE:		/* report not available */
		break;
	default:		/* error */
469
		dev_warn(&urb->dev->dev, "ctrl urb status %d "
470
				"received\n", status);
471
	}
Linus Torvalds's avatar
Linus Torvalds committed
472

473 474 475 476
	if (unplug)
		usbhid->ctrltail = usbhid->ctrlhead;
	else
		usbhid->ctrltail = (usbhid->ctrltail + 1) & (HID_CONTROL_FIFO_SIZE - 1);
Linus Torvalds's avatar
Linus Torvalds committed
477

478 479 480
	if (usbhid->ctrlhead != usbhid->ctrltail) {
		if (hid_submit_ctrl(hid)) {
			clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
Jiri Slaby's avatar
Jiri Slaby committed
481
			wake_up(&usbhid->wait);
482
		}
483
		spin_unlock(&usbhid->lock);
484 485
		return;
	}
Linus Torvalds's avatar
Linus Torvalds committed
486

487
	clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
488
	spin_unlock(&usbhid->lock);
Jiri Slaby's avatar
Jiri Slaby committed
489
	wake_up(&usbhid->wait);
490
}
Linus Torvalds's avatar
Linus Torvalds committed
491

492 493
static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *report,
				   unsigned char dir)
494 495 496
{
	int head;
	struct usbhid_device *usbhid = hid->driver_data;
497
	int len = ((report->size - 1) >> 3) + 1 + (report->id > 0);
Linus Torvalds's avatar
Linus Torvalds committed
498

499 500
	if ((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN)
		return;
501

502 503
	if (usbhid->urbout && dir == USB_DIR_OUT && report->type == HID_OUTPUT_REPORT) {
		if ((head = (usbhid->outhead + 1) & (HID_OUTPUT_FIFO_SIZE - 1)) == usbhid->outtail) {
504
			dev_warn(&hid->dev, "output queue full\n");
505 506
			return;
		}
Linus Torvalds's avatar
Linus Torvalds committed
507

508 509
		usbhid->out[usbhid->outhead].raw_report = kmalloc(len, GFP_ATOMIC);
		if (!usbhid->out[usbhid->outhead].raw_report) {
510
			dev_warn(&hid->dev, "output queueing failed\n");
511 512 513 514
			return;
		}
		hid_output_report(report, usbhid->out[usbhid->outhead].raw_report);
		usbhid->out[usbhid->outhead].report = report;
515
		usbhid->outhead = head;
516

517
		if (!test_and_set_bit(HID_OUT_RUNNING, &usbhid->iofl)) {
518 519
			if (hid_submit_out(hid))
				clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
520 521 522 523 524 525 526 527 528 529 530
		} else {
			/*
			 * the queue is known to run
			 * but an earlier request may be stuck
			 * we may need to time out
			 * no race because this is called under
			 * spinlock
			 */
			if (time_after(jiffies, usbhid->last_out + HZ * 5))
				usb_unlink_urb(usbhid->urbout);
		}
531 532
		return;
	}
Linus Torvalds's avatar
Linus Torvalds committed
533

534
	if ((head = (usbhid->ctrlhead + 1) & (HID_CONTROL_FIFO_SIZE - 1)) == usbhid->ctrltail) {
535
		dev_warn(&hid->dev, "control queue full\n");
536 537
		return;
	}
538

539 540 541
	if (dir == USB_DIR_OUT) {
		usbhid->ctrl[usbhid->ctrlhead].raw_report = kmalloc(len, GFP_ATOMIC);
		if (!usbhid->ctrl[usbhid->ctrlhead].raw_report) {
542
			dev_warn(&hid->dev, "control queueing failed\n");
543 544 545 546
			return;
		}
		hid_output_report(report, usbhid->ctrl[usbhid->ctrlhead].raw_report);
	}
547 548 549
	usbhid->ctrl[usbhid->ctrlhead].report = report;
	usbhid->ctrl[usbhid->ctrlhead].dir = dir;
	usbhid->ctrlhead = head;
550

551
	if (!test_and_set_bit(HID_CTRL_RUNNING, &usbhid->iofl)) {
552 553
		if (hid_submit_ctrl(hid))
			clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
554 555 556 557 558 559 560 561 562 563 564
	} else {
		/*
		 * the queue is known to run
		 * but an earlier request may be stuck
		 * we may need to time out
		 * no race because this is called under
		 * spinlock
		 */
		if (time_after(jiffies, usbhid->last_ctrl + HZ * 5))
			usb_unlink_urb(usbhid->urbctrl);
	}
565
}
566

567 568 569 570
void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir)
{
	struct usbhid_device *usbhid = hid->driver_data;
	unsigned long flags;
571

572 573 574
	spin_lock_irqsave(&usbhid->lock, flags);
	__usbhid_submit_report(hid, report, dir);
	spin_unlock_irqrestore(&usbhid->lock, flags);
575
}
Jiri Slaby's avatar
Jiri Slaby committed
576
EXPORT_SYMBOL_GPL(usbhid_submit_report);
577

578 579
static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
580
	struct hid_device *hid = input_get_drvdata(dev);
581
	struct usbhid_device *usbhid = hid->driver_data;
582
	struct hid_field *field;
583
	unsigned long flags;
584
	int offset;
585

586 587
	if (type == EV_FF)
		return input_ff_event(dev, type, code, value);
588

589 590
	if (type != EV_LED)
		return -1;
591

592
	if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
593
		dev_warn(&dev->dev, "event field not found\n");
594 595
		return -1;
	}
Geoff Levand's avatar
Geoff Levand committed
596

597
	hid_set_field(field, offset, value);
598 599 600 601 602 603 604 605 606
	if (value) {
		spin_lock_irqsave(&usbhid->lock, flags);
		usbhid->ledcount++;
		spin_unlock_irqrestore(&usbhid->lock, flags);
	} else {
		spin_lock_irqsave(&usbhid->lock, flags);
		usbhid->ledcount--;
		spin_unlock_irqrestore(&usbhid->lock, flags);
	}
607
	usbhid_submit_report(hid, field->report, USB_DIR_OUT);
Linus Torvalds's avatar
Linus Torvalds committed
608

609 610
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
611

612 613 614
int usbhid_wait_io(struct hid_device *hid)
{
	struct usbhid_device *usbhid = hid->driver_data;
615

Jiri Slaby's avatar
Jiri Slaby committed
616 617 618
	if (!wait_event_timeout(usbhid->wait,
				(!test_bit(HID_CTRL_RUNNING, &usbhid->iofl) &&
				!test_bit(HID_OUT_RUNNING, &usbhid->iofl)),
619
					10*HZ)) {
620
		dbg_hid("timeout waiting for ctrl or out queue to clear\n");
621 622
		return -1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
623

624 625
	return 0;
}
626

627 628 629 630 631 632
static int hid_set_idle(struct usb_device *dev, int ifnum, int report, int idle)
{
	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
		HID_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE, (idle << 8) | report,
		ifnum, NULL, 0, USB_CTRL_SET_TIMEOUT);
}
Linus Torvalds's avatar
Linus Torvalds committed
633

634 635 636 637
static int hid_get_class_descriptor(struct usb_device *dev, int ifnum,
		unsigned char type, void *buf, int size)
{
	int result, retries = 4;
Linus Torvalds's avatar
Linus Torvalds committed
638

639
	memset(buf, 0, size);
Linus Torvalds's avatar
Linus Torvalds committed
640

641 642 643 644 645 646 647 648
	do {
		result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
				USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
				(type << 8), ifnum, buf, size, USB_CTRL_GET_TIMEOUT);
		retries--;
	} while (result < size && retries);
	return result;
}
649

650 651
int usbhid_open(struct hid_device *hid)
{
652 653 654
	struct usbhid_device *usbhid = hid->driver_data;
	int res;

655
	mutex_lock(&hid_open_mut);
656 657
	if (!hid->open++) {
		res = usb_autopm_get_interface(usbhid->intf);
658
		/* the device must be awake to reliable request remote wakeup */
659 660
		if (res < 0) {
			hid->open--;
661
			mutex_unlock(&hid_open_mut);
662 663
			return -EIO;
		}
664 665 666 667 668
		usbhid->intf->needs_remote_wakeup = 1;
		if (hid_start_in(hid))
			hid_io_error(hid);
 
		usb_autopm_put_interface(usbhid->intf);
669
	}
670
	mutex_unlock(&hid_open_mut);
671 672
	return 0;
}
673

674 675 676
void usbhid_close(struct hid_device *hid)
{
	struct usbhid_device *usbhid = hid->driver_data;
677

678 679 680 681 682 683 684
	mutex_lock(&hid_open_mut);

	/* protecting hid->open to make sure we don't restart
	 * data acquistion due to a resumption we no longer
	 * care about
	 */
	spin_lock_irq(&usbhid->lock);
685
	if (!--hid->open) {
686
		spin_unlock_irq(&usbhid->lock);
687
		hid_cancel_delayed_stuff(usbhid);
688
		usb_kill_urb(usbhid->urbin);
689 690 691
		usbhid->intf->needs_remote_wakeup = 0;
	} else {
		spin_unlock_irq(&usbhid->lock);
692
	}
693
	mutex_unlock(&hid_open_mut);
694
}
695

696 697 698
/*
 * Initialize all reports
 */
699

700 701 702 703 704
void usbhid_init_reports(struct hid_device *hid)
{
	struct hid_report *report;
	struct usbhid_device *usbhid = hid->driver_data;
	int err, ret;
705

706 707
	list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list)
		usbhid_submit_report(hid, report, USB_DIR_IN);
708

709 710
	list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].report_list, list)
		usbhid_submit_report(hid, report, USB_DIR_IN);
Geoff Levand's avatar
Geoff Levand committed
711

712 713 714 715 716 717 718 719 720 721
	err = 0;
	ret = usbhid_wait_io(hid);
	while (ret) {
		err |= ret;
		if (test_bit(HID_CTRL_RUNNING, &usbhid->iofl))
			usb_kill_urb(usbhid->urbctrl);
		if (test_bit(HID_OUT_RUNNING, &usbhid->iofl))
			usb_kill_urb(usbhid->urbout);
		ret = usbhid_wait_io(hid);
	}
722

723
	if (err)
724
		dev_warn(&hid->dev, "timeout initializing reports\n");
725
}
Linus Torvalds's avatar
Linus Torvalds committed
726

727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
/*
 * Reset LEDs which BIOS might have left on. For now, just NumLock (0x01).
 */
static int hid_find_field_early(struct hid_device *hid, unsigned int page,
    unsigned int hid_code, struct hid_field **pfield)
{
	struct hid_report *report;
	struct hid_field *field;
	struct hid_usage *usage;
	int i, j;

	list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {
		for (i = 0; i < report->maxfield; i++) {
			field = report->field[i];
			for (j = 0; j < field->maxusage; j++) {
				usage = &field->usage[j];
				if ((usage->hid & HID_USAGE_PAGE) == page &&
				    (usage->hid & 0xFFFF) == hid_code) {
					*pfield = field;
					return j;
				}
			}
		}
	}
	return -1;
}

Jiri Slaby's avatar
Jiri Slaby committed
754
void usbhid_set_leds(struct hid_device *hid)
755 756 757 758 759 760 761 762 763
{
	struct hid_field *field;
	int offset;

	if ((offset = hid_find_field_early(hid, HID_UP_LED, 0x01, &field)) != -1) {
		hid_set_field(field, offset, 0);
		usbhid_submit_report(hid, field->report, USB_DIR_OUT);
	}
}
Jiri Slaby's avatar
Jiri Slaby committed
764
EXPORT_SYMBOL_GPL(usbhid_set_leds);
765

766 767 768
/*
 * Traverse the supplied list of reports and find the longest
 */
Jiri Slaby's avatar
Jiri Slaby committed
769 770
static void hid_find_max_report(struct hid_device *hid, unsigned int type,
		unsigned int *max)
771 772
{
	struct hid_report *report;
Jiri Slaby's avatar
Jiri Slaby committed
773
	unsigned int size;
774 775

	list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
776
		size = ((report->size - 1) >> 3) + 1 + hid->report_enum[type].numbered;
777 778 779 780 781
		if (*max < size)
			*max = size;
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
782 783
static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid)
{
784 785
	struct usbhid_device *usbhid = hid->driver_data;

786 787 788 789 790 791 792 793 794 795
	usbhid->inbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL,
			&usbhid->inbuf_dma);
	usbhid->outbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL,
			&usbhid->outbuf_dma);
	usbhid->cr = usb_buffer_alloc(dev, sizeof(*usbhid->cr), GFP_KERNEL,
			&usbhid->cr_dma);
	usbhid->ctrlbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL,
			&usbhid->ctrlbuf_dma);
	if (!usbhid->inbuf || !usbhid->outbuf || !usbhid->cr ||
			!usbhid->ctrlbuf)
Linus Torvalds's avatar
Linus Torvalds committed
796 797 798 799 800
		return -1;

	return 0;
}

801 802
static int usbhid_output_raw_report(struct hid_device *hid, __u8 *buf, size_t count,
		unsigned char report_type)
803 804 805 806 807 808 809 810 811 812
{
	struct usbhid_device *usbhid = hid->driver_data;
	struct usb_device *dev = hid_to_usb_dev(hid);
	struct usb_interface *intf = usbhid->intf;
	struct usb_host_interface *interface = intf->cur_altsetting;
	int ret;

	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
		HID_REQ_SET_REPORT,
		USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
813
		((report_type + 1) << 8) | *buf,
814 815 816 817 818 819 820 821 822 823
		interface->desc.bInterfaceNumber, buf + 1, count - 1,
		USB_CTRL_SET_TIMEOUT);

	/* count also the report id */
	if (ret > 0)
		ret++;

	return ret;
}

824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
static void usbhid_restart_queues(struct usbhid_device *usbhid)
{
	if (usbhid->urbout)
		usbhid_restart_out_queue(usbhid);
	usbhid_restart_ctrl_queue(usbhid);
}

static void __usbhid_restart_queues(struct work_struct *work)
{
	struct usbhid_device *usbhid =
		container_of(work, struct usbhid_device, restart_work);
	int r;

	r = usb_autopm_get_interface(usbhid->intf);
	if (r < 0)
		return;
	usb_autopm_put_interface(usbhid->intf);
}

Linus Torvalds's avatar
Linus Torvalds committed
843 844
static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
{
845 846
	struct usbhid_device *usbhid = hid->driver_data;

847 848 849 850
	usb_buffer_free(dev, usbhid->bufsize, usbhid->inbuf, usbhid->inbuf_dma);
	usb_buffer_free(dev, usbhid->bufsize, usbhid->outbuf, usbhid->outbuf_dma);
	usb_buffer_free(dev, sizeof(*(usbhid->cr)), usbhid->cr, usbhid->cr_dma);
	usb_buffer_free(dev, usbhid->bufsize, usbhid->ctrlbuf, usbhid->ctrlbuf_dma);
Linus Torvalds's avatar
Linus Torvalds committed
851 852
}

853 854 855
static int usbhid_parse(struct hid_device *hid)
{
	struct usb_interface *intf = to_usb_interface(hid->dev.parent);
Linus Torvalds's avatar
Linus Torvalds committed
856 857 858
	struct usb_host_interface *interface = intf->cur_altsetting;
	struct usb_device *dev = interface_to_usbdev (intf);
	struct hid_descriptor *hdesc;
859
	u32 quirks = 0;
860
	unsigned int rsize = 0;
861
	char *rdesc;
862
	int ret, n;
Linus Torvalds's avatar
Linus Torvalds committed
863

864 865
	quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor),
			le16_to_cpu(dev->descriptor.idProduct));
Linus Torvalds's avatar
Linus Torvalds committed
866

867 868 869
	if (quirks & HID_QUIRK_IGNORE)
		return -ENODEV;

870 871 872 873 874 875 876 877
	/* Many keyboards and mice don't like to be polled for reports,
	 * so we will always set the HID_QUIRK_NOGET flag for them. */
	if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT) {
		if (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_KEYBOARD ||
			interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE)
				quirks |= HID_QUIRK_NOGET;
	}

878 879 880
	if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&
	    (!interface->desc.bNumEndpoints ||
	     usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {
881
		dbg_hid("class descriptor not present\n");
882
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
883 884
	}

885 886 887
	hid->version = le16_to_cpu(hdesc->bcdHID);
	hid->country = hdesc->bCountryCode;

Linus Torvalds's avatar
Linus Torvalds committed
888 889 890 891 892
	for (n = 0; n < hdesc->bNumDescriptors; n++)
		if (hdesc->desc[n].bDescriptorType == HID_DT_REPORT)
			rsize = le16_to_cpu(hdesc->desc[n].wDescriptorLength);

	if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
893
		dbg_hid("weird size of report descriptor (%u)\n", rsize);
894
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
895 896 897
	}

	if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) {
898
		dbg_hid("couldn't allocate rdesc memory\n");
899
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
900 901
	}

902 903
	hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0);

904 905 906
	ret = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber,
			HID_DT_REPORT, rdesc, rsize);
	if (ret < 0) {
907
		dbg_hid("reading report descriptor failed\n");
Linus Torvalds's avatar
Linus Torvalds committed
908
		kfree(rdesc);
909
		goto err;
Linus Torvalds's avatar
Linus Torvalds committed
910 911
	}

912 913 914
	ret = hid_parse_report(hid, rdesc, rsize);
	kfree(rdesc);
	if (ret) {
915
		dbg_hid("parsing report descriptor failed\n");
916
		goto err;
Linus Torvalds's avatar
Linus Torvalds committed
917 918
	}

919
	hid->quirks |= quirks;
Linus Torvalds's avatar
Linus Torvalds committed
920

921 922 923 924 925 926 927 928 929 930
	return 0;
err:
	return ret;
}

static int usbhid_start(struct hid_device *hid)
{
	struct usb_interface *intf = to_usb_interface(hid->dev.parent);
	struct usb_host_interface *interface = intf->cur_altsetting;
	struct usb_device *dev = interface_to_usbdev(intf);
931
	struct usbhid_device *usbhid = hid->driver_data;
932 933 934
	unsigned int n, insize = 0;
	int ret;

935 936
	clear_bit(HID_DISCONNECTED, &usbhid->iofl);

937 938 939 940
	usbhid->bufsize = HID_MIN_BUFFER_SIZE;
	hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize);
	hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize);
	hid_find_max_report(hid, HID_FEATURE_REPORT, &usbhid->bufsize);
941