hid-core.c 39.8 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

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);
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);
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);
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);
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
}
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

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
EXPORT_SYMBOL_GPL(usbhid_wait_io);
627

628 629 630 631 632 633
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
634

635 636 637 638
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
639

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

642 643 644 645 646 647 648 649
	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;
}
650

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

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

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

679 680 681 682 683 684 685
	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);
686
	if (!--hid->open) {
687
		spin_unlock_irq(&usbhid->lock);
688
		hid_cancel_delayed_stuff(usbhid);
689
		usb_kill_urb(usbhid->urbin);
690 691 692
		usbhid->intf->needs_remote_wakeup = 0;
	} else {
		spin_unlock_irq(&usbhid->lock);
693
	}
694
	mutex_unlock(&hid_open_mut);
695
}
696

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

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

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

710 711
	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
712

713 714 715 716 717 718 719 720 721 722
	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);
	}
723

724
	if (err)
725
		dev_warn(&hid->dev, "timeout initializing reports\n");
726
}
Linus Torvalds's avatar
Linus Torvalds committed
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 754
/*
 * 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
755
void usbhid_set_leds(struct hid_device *hid)
756 757 758 759 760 761 762 763 764
{
	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
765
EXPORT_SYMBOL_GPL(usbhid_set_leds);
766

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

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

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

787
	usbhid->inbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL,
788
			&usbhid->inbuf_dma);
789
	usbhid->outbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL,
790
			&usbhid->outbuf_dma);
791
	usbhid->cr = kmalloc(sizeof(*usbhid->cr), GFP_KERNEL);
792
	usbhid->ctrlbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL,
793 794 795
			&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
{
	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;

810
	if (usbhid->urbout && report_type != HID_FEATURE_REPORT) {
811 812
		int actual_length;
		int skipped_report_id = 0;
Alan Ott's avatar
Alan Ott committed
813

814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830
		if (buf[0] == 0x0) {
			/* Don't send the Report ID */
			buf++;
			count--;
			skipped_report_id = 1;
		}
		ret = usb_interrupt_msg(dev, usbhid->urbout->pipe,
			buf, count, &actual_length,
			USB_CTRL_SET_TIMEOUT);
		/* return the number of bytes transferred */
		if (ret == 0) {
			ret = actual_length;
			/* count also the report id */
			if (skipped_report_id)
				ret++;
		}
	} else {
831
		int skipped_report_id = 0;
832
		int report_id = buf[0];
833 834 835 836 837 838
		if (buf[0] == 0x0) {
			/* Don't send the Report ID */
			buf++;
			count--;
			skipped_report_id = 1;
		}
839 840 841
		ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
			HID_REQ_SET_REPORT,
			USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
842
			((report_type + 1) << 8) | report_id,
843
			interface->desc.bInterfaceNumber, buf, count,
844
			USB_CTRL_SET_TIMEOUT);
845 846
		/* count also the report id, if this was a numbered report. */
		if (ret > 0 && skipped_report_id)
847 848
			ret++;
	}
849 850 851 852

	return ret;
}

853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
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
872 873
static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
{
874 875
	struct usbhid_device *usbhid = hid->driver_data;

876 877
	usb_free_coherent(dev, usbhid->bufsize, usbhid->inbuf, usbhid->inbuf_dma);
	usb_free_coherent(dev, usbhid->bufsize, usbhid->outbuf, usbhid->outbuf_dma);
878
	kfree(usbhid->cr);
879
	usb_free_coherent(dev, usbhid->bufsize, usbhid->ctrlbuf, usbhid->ctrlbuf_dma);
Linus Torvalds's avatar
Linus Torvalds committed
880 881
}

882 883 884
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
885 886 887
	struct usb_host_interface *interface = intf->cur_altsetting;
	struct usb_device *dev = interface_to_usbdev (intf);
	struct hid_descriptor *hdesc;
888
	u32 quirks = 0;
889
	unsigned int rsize = 0;
890
	char *rdesc;
891
	int ret, n;
Linus Torvalds's avatar
Linus Torvalds committed
892

893 894
	quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor),
			le16_to_cpu(dev->descriptor.idProduct));
Linus Torvalds's avatar
Linus Torvalds committed
895

896 897 898
	if (quirks & HID_QUIRK_IGNORE)
		return -ENODEV;

899 900 901 902 903 904 905 906
	/* 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;
	}

907 908 909
	if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&
	    (!interface->desc.bNumEndpoints ||
	     usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {
910
		dbg_hid("class descriptor not present\n");
911
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
912 913
	}

914 915 916
	hid->version = le16_to_cpu(hdesc->bcdHID);
	hid->country = hdesc->bCountryCode;

Linus Torvalds's avatar
Linus Torvalds committed
917 918 919 920 921
	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) {
922
		dbg_hid("weird size of report descriptor (%u)\n", rsize);
923
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
924 925 926
	}

	if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) {
927
		dbg_hid("couldn't allocate rdesc memory\n");
928
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
929 930
	}

931 932
	hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0);

933 934 935
	ret = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber,
			HID_DT_REPORT, rdesc, rsize);
	if (ret < 0) {
936
		dbg_hid("reading report descriptor failed\n");
Linus Torvalds's avatar
Linus Torvalds committed
937
		kfree(rdesc);
938
		goto err;
Linus Torvalds's avatar
Linus Torvalds committed
939 940
	}

941 942 943
	ret = hid_parse_report(hid, rdesc, rsize);
	kfree(rdesc);
	if (ret) {
944
		dbg_hid("parsing report descriptor failed\n");
945
		goto err;
Linus Torvalds's avatar
Linus Torvalds committed
946 947
	}

948
	hid->quirks |= quirks;
Linus Torvalds's avatar
Linus Torvalds committed
949

950 951 952 953 954 955 956 957 958 959
	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);
960
	struct usbhid_device *usbhid = hid->driver_data;
961 962 963
	unsigned int n, insize = 0;
	int ret;

964 965
	clear_bit(HID_DISCONNECTED, &usbhid->iofl);

966 967 968 969
	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);
970

971 972
	if (usbhid->bufsize > HID_MAX_BUFFER_SIZE)
		usbhid->bufsize = HID_MAX_BUFFER_SIZE;
973 974 975 976 977 978

	hid_find_max_report(hid, HID_INPUT_REPORT, &insize);

	if (insize > HID_MAX_BUFFER_SIZE)
		insize = HID_MAX_BUFFER_SIZE;

979 980
	if (hid_alloc_buffers(dev, hid)) {
		ret = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
981
		goto fail;
982 983
	}

Linus Torvalds's avatar
Linus Torvalds committed
984 985 986 987 988 989
	for (n = 0; n < interface->desc.bNumEndpoints; n++) {
		struct usb_endpoint_descriptor *endpoint;
		int pipe;
		int interval;

		endpoint = &interface->endpoint[n].desc;
990
		if (!usb_endpoint_xfer_int(endpoint))
Linus Torvalds's avatar
Linus Torvalds committed
991 992 993 994
			continue;

		interval = endpoint->bInterval;

995
		/* Some vendors give fullspeed interval on highspeed devides */
996
		if (hid->quirks & HID_QUIRK_FULLSPEED_INTERVAL &&
997 998 999 1000 1001 1002
		    dev->speed == USB_SPEED_HIGH) {
			interval = fls(endpoint->bInterval*8);
			printk(KERN_INFO "%s: Fixing fullspeed to highspeed interval: %d -> %d\n",
			       hid->name, endpoint->bInterval, interval);
		}

Linus Torvalds's avatar
Linus Torvalds committed
1003 1004 1005
		/* Change the polling interval of mice. */
		if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0)
			interval = hid_mousepoll_interval;
1006

1007
		ret = -ENOMEM;
1008
		if (usb_endpoint_dir_in(endpoint)) {
1009
			if (usbhid->urbin)
Linus Torvalds's avatar
Linus Torvalds committed
1010
				continue;
1011
			if (!(usbhid->urbin = usb_alloc_urb(0, GFP_KERNEL)))
Linus Torvalds's avatar
Linus Torvalds committed
1012 1013
				goto fail;
			pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
1014
			usb_fill_int_urb(usbhid->urbin, dev, pipe, usbhid->inbuf, insize,
Linus Torvalds's avatar
Linus Torvalds committed
1015
					 hid_irq_in, hid, interval);
1016 1017
			usbhid->urbin->transfer_dma = usbhid->inbuf_dma;
			usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
Linus Torvalds's avatar
Linus Torvalds committed
1018
		} else {
1019
			if (usbhid->urbout)
Linus Torvalds's avatar
Linus Torvalds committed
1020
				continue;
1021
			if (!(usbhid->urbout = usb_alloc_urb(0, GFP_KERNEL)))
Linus Torvalds's avatar
Linus Torvalds committed
1022 1023
				goto fail;
			pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress);
1024
			usb_fill_int_urb(usbhid->urbout, dev, pipe, usbhid->outbuf, 0,
Linus Torvalds's avatar
Linus Torvalds committed
1025
					 hid_irq_out, hid, interval);
1026 1027
			usbhid->urbout->transfer_dma = usbhid->outbuf_dma;
			usbhid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
Linus Torvalds's avatar
Linus Torvalds committed
1028 1029 1030
		}
	}

1031
	usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL);
1032 1033
	if (!usbhid->urbctrl) {
		ret = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
1034
		goto fail;
1035
	}
1036

1037 1038 1039
	usb_fill_control_urb(usbhid->urbctrl, dev, 0, (void *) usbhid->cr,
			     usbhid->ctrlbuf, 1, hid_ctrl, hid);
	usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma;
1040
	usbhid->urbctrl->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1041

1042 1043
	if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS))
		usbhid_init_reports(hid);
Jiri Slaby's avatar
Jiri Slaby committed
1044

1045 1046
	set_bit(HID_STARTED, &usbhid->iofl);

1047 1048 1049
	/* Some keyboards don't work until their LEDs have been set.
	 * Since BIOSes do set the LEDs, it must be safe for any device
	 * that supports the keyboard boot protocol.
1050 1051
	 * In addition, enable remote wakeup by default for all keyboard
	 * devices supporting the boot protocol.
1052 1053 1054
	 */
	if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT &&
			interface->desc.bInterfaceProtocol ==
1055
				USB_INTERFACE_PROTOCOL_KEYBOARD) {
1056
		usbhid_set_leds(hid);
1057 1058
		device_set_wakeup_enable(&dev->dev, 1);
	}
1059
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1060 1061

fail:
1062 1063 1064
	usb_free_urb(usbhid->urbin);
	usb_free_urb(usbhid->urbout);
	usb_free_urb(usbhid->urbctrl);
1065 1066 1067
	usbhid->urbin = NULL;
	usbhid->urbout = NULL;
	usbhid->urbctrl = NULL;
1068
	hid_free_buffers(dev, hid);
1069
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1070 1071
}

1072
static void usbhid_stop(struct hid_device *hid)
Linus Torvalds's avatar
Linus Torvalds committed
1073
{
1074
	struct usbhid_device *usbhid = hid->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
1075

1076
	if (WARN_ON(!usbhid))
Linus Torvalds's avatar
Linus Torvalds committed
1077 1078
		return;

1079
	clear_bit(HID_STARTED, &usbhid->iofl);
1080
	spin_lock_irq(&usbhid->lock);	/* Sync with error handler */
1081
	set_bit(HID_DISCONNECTED, &usbhid->iofl);
1082
	spin_unlock_irq(&usbhid->lock);
1083 1084 1085
	usb_kill_urb(usbhid->urbin);
	usb_kill_urb(usbhid->urbout);
	usb_kill_urb(usbhid->urbctrl);
Linus Torvalds's avatar
Linus Torvalds committed
1086

1087
	hid_cancel_delayed_stuff(usbhid);
1088

1089 1090
	hid->claimed = 0;

1091 1092 1093
	usb_free_urb(usbhid->urbin);
	usb_free_urb(usbhid->urbctrl);
	usb_free_urb(usbhid->urbout);
1094 1095 1096
	usbhid->urbin = NULL; /* don't mess up next start */
	usbhid->urbctrl = NULL;
	usbhid->urbout = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1097

1098
	hid_free_buffers(hid_to_usb_dev(hid), hid);
Linus Torvalds's avatar
Linus Torvalds committed
1099 1100
}

1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
static int usbhid_power(struct hid_device *hid, int lvl)
{
	int r = 0;

	switch (lvl) {
	case PM_HINT_FULLON:
		r = usbhid_get_power(hid);
		break;
	case PM_HINT_NORMAL:
		usbhid_put_power(hid);
		break;
	}
	return r;
}

1116 1117 1118 1119 1120 1121
static struct hid_ll_driver usb_hid_driver = {
	.parse = usbhid_parse,
	.start = usbhid_start,
	.stop = usbhid_stop,
	.open = usbhid_open,
	.close = usbhid_close,
1122
	.power = usbhid_power,
1123 1124 1125
	.hidinput_input_event = usb_hidinput_input_event,
};

1126
static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *id)
Linus Torvalds's avatar
Linus Torvalds committed
1127
{
1128
	struct usb_host_interface *interface = intf->cur_altsetting;
1129
	struct usb_device *dev = interface_to_usbdev(intf);
1130
	struct usbhid_device *usbhid;
Linus Torvalds's avatar
Linus Torvalds committed
1131
	struct hid_device *hid;
1132
	unsigned int n, has_in = 0;
1133 1134
	size_t len;
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
1135

1136
	dbg_hid("HID probe called for ifnum %d\n",
Linus Torvalds's avatar
Linus Torvalds committed
1137 1138
			intf->altsetting->desc.bInterfaceNumber);

1139 1140 1141 1142 1143 1144 1145 1146 1147
	for (n = 0; n < interface->desc.bNumEndpoints; n++)
		if (usb_endpoint_is_int_in(&interface->endpoint[n].desc))
			has_in++;
	if (!has_in) {
		dev_err(&intf->dev, "couldn't find an input interrupt "
				"endpoint\n");
		return -ENODEV;
	}

1148 1149 1150
	hid = hid_allocate_device();
	if (IS_ERR(hid))
		return PTR_ERR(hid);
Linus Torvalds's avatar
Linus Torvalds committed
1151 1152

	usb_set_intfdata(intf, hid);
1153 1154
	hid->ll_driver = &usb_hid_driver;
	hid->hid_output_raw_report = usbhid_output_raw_report;
Jiri Slaby's avatar
Jiri Slaby committed
1155
	hid->ff_init = hid_pidff_init;
1156
#ifdef CONFIG_USB_HIDDEV
Jiri Slaby's avatar
Jiri Slaby committed
1157
	hid->hiddev_connect = hiddev_connect;
1158
	hid->hiddev_disconnect = hiddev_disconnect;
1159 1160 1161 1162 1163 1164 1165 1166
	hid->hiddev_hid_event = hiddev_hid_event;
	hid->hiddev_report_event = hiddev_report_event;
#endif
	hid->dev.parent = &intf->dev;
	hid->bus = BUS_USB;
	hid->vendor = le16_to_cpu(dev->descriptor.idVendor);
	hid->product = le16_to_cpu(dev->descriptor.idProduct);
	hid->name[0] = 0;
1167
	hid->quirks = usbhid_lookup_quirk(hid->vendor, hid->product);
1168 1169 1170
	if (intf->cur_altsetting->desc.bInterfaceProtocol ==
			USB_INTERFACE_PROTOCOL_MOUSE)
		hid->type = HID_TYPE_USBMOUSE;
Linus Torvalds's avatar
Linus Torvalds committed
1171

1172 1173
	if (dev->manufacturer)
		strlcpy(hid->name, dev->manufacturer, sizeof(hid->name));
Linus Torvalds's avatar
Linus Torvalds committed
1174

1175 1176 1177 1178
	if (dev->product) {
		if (dev->manufacturer)
			strlcat(hid->name, " ", sizeof(hid->name));
		strlcat(hid->name, dev->product, sizeof(hid->name));
Linus Torvalds's avatar
Linus Torvalds committed
1179 1180
	}

1181 1182 1183 1184
	if (!strlen(hid->name))
		snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x",
			 le16_to_cpu(dev->descriptor.idVendor),
			 le16_to_cpu(dev->descriptor.idProduct));
Linus Torvalds's avatar
Linus Torvalds committed
1185

1186 1187 1188 1189 1190 1191 1192 1193 1194
	usb_make_path(dev, hid->phys, sizeof(hid->phys));
	strlcat(hid->phys, "/input", sizeof(hid->phys));
	len = strlen(hid->phys);
	if (len < sizeof(hid->phys) - 1)
		snprintf(hid->phys + len, sizeof(hid->phys) - len,
			 "%d", intf->altsetting[0].desc.bInterfaceNumber);

	if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
		hid->uniq[0] = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1195

1196 1197 1198 1199 1200 1201 1202 1203
	usbhid = kzalloc(sizeof(*usbhid), GFP_KERNEL);
	if (usbhid == NULL) {
		ret = -ENOMEM;
		goto err;
	}

	hid->driver_data = usbhid;
	usbhid->hid = hid;
1204 1205
	usbhid->intf = intf;
	usbhid->ifnum = interface->desc.bInterfaceNumber;
1206

1207 1208 1209 1210 1211 1212
	init_waitqueue_head(&usbhid->wait);
	INIT_WORK(&usbhid->reset_work, hid_reset);
	INIT_WORK(&usbhid->restart_work, __usbhid_restart_queues);
	setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid);
	spin_lock_init(&usbhid->lock);

Jiri Slaby's avatar
Jiri Slaby committed
1213 1214
	ret = hid_add_device(hid);
	if (ret) {
Jiri Slaby's avatar
Jiri Slaby committed
1215 1216
		if (ret != -ENODEV)
			dev_err(&intf->dev, "can't add hid device: %d\n", ret);
1217
		goto err_free;
Jiri Slaby's avatar
Jiri Slaby committed
1218
	}
1219 1220

	return 0;
1221 1222
err_free:
	kfree(usbhid);
1223 1224
err:
	hid_destroy_device(hid);
Jiri Slaby's avatar
Jiri Slaby committed
1225
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1226 1227
}

1228
static void usbhid_disconnect(struct usb_interface *intf)
1229 1230
{
	struct hid_device *hid = usb_get_intfdata(intf);
1231
	struct usbhid_device *usbhid;
1232 1233 1234 1235

	if (WARN_ON(!hid))
		return;

1236
	usbhid = hid->driver_data;
1237
	hid_destroy_device(hid);
1238
	kfree(usbhid);
1239 1240
}

1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255
static void hid_cancel_delayed_stuff(struct usbhid_device *usbhid)
{
	del_timer_sync(&usbhid->io_retry);
	cancel_work_sync(&usbhid->restart_work);
	cancel_work_sync(&usbhid->reset_work);
}

static void hid_cease_io(struct usbhid_device *usbhid)
{
	del_timer(&usbhid->io_retry);
	usb_kill_urb(usbhid->urbin);
	usb_kill_urb(usbhid->urbctrl);
	usb_kill_urb(usbhid->urbout);
}

1256 1257 1258 1259 1260 1261 1262 1263 1264
/* Treat USB reset pretty much the same as suspend/resume */
static int hid_pre_reset(struct usb_interface *intf)
{
	struct hid_device *hid = usb_get_intfdata(intf);
	struct usbhid_device *usbhid = hid->driver_data;

	spin_lock_irq(&usbhid->lock);
	set_bit(HID_RESET_PENDING, &usbhid->iofl);
	spin_unlock_irq(&usbhid->lock);
1265
	cancel_work_sync(&usbhid->restart_work);
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
	hid_cease_io(usbhid);

	return 0;
}

/* Same routine used for post_reset and reset_resume */
static int hid_post_reset(struct usb_interface *intf)
{
	struct usb_device *dev = interface_to_usbdev (intf);
	struct hid_device *hid = usb_get_intfdata(intf);
	struct usbhid_device *usbhid = hid->driver_data;
	int status;
1278

1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
	spin_lock_irq(&usbhid->lock);
	clear_bit(HID_RESET_PENDING, &usbhid->iofl);
	spin_unlock_irq(&usbhid->lock);
	hid_set_idle(dev, intf->cur_altsetting->desc.bInterfaceNumber, 0, 0);
	status = hid_start_in(hid);
	if (status < 0)
		hid_io_error(hid);
	usbhid_restart_queues(usbhid);

	return 0;
}

int usbhid_get_power(struct hid_device *hid)
{
	struct usbhid_device *usbhid = hid->driver_data;
1294

1295 1296 1297 1298 1299 1300
	return usb_autopm_get_interface(usbhid->intf);
}

void usbhid_put_power(struct hid_device *hid)
{
	struct usbhid_device *usbhid = hid->driver_data;
1301

1302 1303 1304 1305
	usb_autopm_put_interface(usbhid->intf);
}


1306
#ifdef CONFIG_PM
1307
static int hid_suspend(struct usb_interface *intf, pm_message_t message)
Linus Torvalds's avatar
Linus Torvalds committed
1308
{
1309
	struct hid_device *hid = usb_get_intfdata(intf);
1310
	struct usbhid_device *usbhid = hid->driver_data;
1311
	int status;
Linus Torvalds's avatar
Linus Torvalds committed
1312

Alan Stern's avatar
Alan Stern committed
1313
	if (message.event & PM_EVENT_AUTO) {
1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
		spin_lock_irq(&usbhid->lock);	/* Sync with error handler */
		if (!test_bit(HID_RESET_PENDING, &usbhid->iofl)
		    && !test_bit(HID_CLEAR_HALT, &usbhid->iofl)
		    && !test_bit(HID_OUT_RUNNING, &usbhid->iofl)
		    && !test_bit(HID_CTRL_RUNNING, &usbhid->iofl)
		    && !test_bit(HID_KEYS_PRESSED, &usbhid->iofl)
		    && (!usbhid->ledcount || ignoreled))
		{
			set_bit(HID_REPORTED_IDLE, &usbhid->iofl);
			spin_unlock_irq(&usbhid->lock);
1324 1325 1326 1327 1328
			if (hid->driver && hid->driver->suspend) {
				status = hid->driver->suspend(hid, message);
				if (status < 0)
					return status;
			}
1329 1330 1331 1332 1333
		} else {
			usbhid_mark_busy(usbhid);
			spin_unlock_irq(&usbhid->lock);
			return -EBUSY;
		}
1334

1335
	} else {
1336 1337 1338 1339 1340
		if (hid->driver && hid->driver->suspend) {
			status = hid->driver->suspend(hid, message);
			if (status < 0)
				return status;
		}
1341 1342 1343 1344 1345 1346 1347
		spin_lock_irq(&usbhid->lock);
		set_bit(HID_REPORTED_IDLE, &usbhid->iofl);
		spin_unlock_irq(&usbhid->lock);
		if (usbhid_wait_io(hid) < 0)
			return -EIO;
	}

Alan Stern's avatar
Alan Stern committed
1348
	if (!ignoreled && (message.event & PM_EVENT_AUTO)) {
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
		spin_lock_irq(&usbhid->lock);
		if (test_bit(HID_LED_ON, &usbhid->iofl)) {
			spin_unlock_irq(&usbhid->lock);
			usbhid_mark_busy(usbhid);
			return -EBUSY;
		}
		spin_unlock_irq(&usbhid->lock);
	}

	hid_cancel_delayed_stuff(usbhid);
	hid_cease_io(usbhid);

Alan Stern's avatar
Alan Stern committed
1361 1362
	if ((message.event & PM_EVENT_AUTO) &&
			test_bit(HID_KEYS_PRESSED, &usbhid->iofl)) {
1363 1364 1365 1366 1367 1368 1369
		/* lost race against keypresses */
		status = hid_start_in(hid);
		if (status < 0)
			hid_io_error(hid);
		usbhid_mark_busy(usbhid);
		return -EBUSY;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1370 1371 1372 1373 1374 1375 1376
	dev_dbg(&intf->dev, "suspend\n");
	return 0;
}

static int hid_resume(struct usb_interface *intf)
{
	struct hid_device *hid = usb_get_intfdata (intf);
1377
	struct usbhid_device *usbhid = hid->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
1378 1379
	int status;

1380
	if (!test_bit(HID_STARTED, &usbhid->iofl))
1381 1382
		return 0;

1383 1384 1385 1386 1387 1388
	clear_bit(HID_REPORTED_IDLE, &usbhid->iofl);
	usbhid_mark_busy(usbhid);

	if (test_bit(HID_CLEAR_HALT, &usbhid->iofl) ||
	    test_bit(HID_RESET_PENDING, &usbhid->iofl))
		schedule_work(&usbhid->reset_work);
1389
	usbhid->retry_delay = 0;
1390
	status = hid_start_in(hid);
1391 1392 1393
	if (status < 0)
		hid_io_error(hid);
	usbhid_restart_queues(usbhid);
Linus Torvalds's avatar
Linus Torvalds committed
1394

1395 1396 1397 1398 1399
	if (status >= 0 && hid->driver && hid->driver->resume) {
		int ret = hid->driver->resume(hid);
		if (ret < 0)
			status = ret;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1400
	dev_dbg(&intf->dev, "resume status %d\n", status);
Alan Stern's avatar
Alan Stern committed
1401
	return 0;
1402 1403
}

1404
static int hid_reset_resume(struct usb_interface *intf)
1405
{
1406 1407
	struct hid_device *hid = usb_get_intfdata(intf);
	struct usbhid_device *usbhid = hid->driver_data;
1408
	int status;
1409

1410
	clear_bit(HID_REPORTED_IDLE, &usbhid->iofl);
1411 1412 1413 1414 1415 1416 1417
	status = hid_post_reset(intf);
	if (status >= 0 && hid->driver && hid->driver->reset_resume) {
		int ret = hid->driver->reset_resume(hid);
		if (ret < 0)
			status = ret;
	}
	return status;
1418 1419
}

1420
#endif /* CONFIG_PM */
1421

1422
static const struct usb_device_id hid_usb_ids[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1423 1424 1425 1426 1427 1428 1429 1430 1431
	{ .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
		.bInterfaceClass = USB_INTERFACE_CLASS_HID },
	{ }						/* Terminating entry */
};

MODULE_DEVICE_TABLE (usb, hid_usb_ids);

static struct usb_driver hid_driver = {
	.name =		"usbhid",
1432 1433
	.probe =	usbhid_probe,
	.disconnect =	usbhid_disconnect,
1434
#ifdef CONFIG_PM
Linus Torvalds's avatar
Linus Torvalds committed
1435 1436
	.suspend =	hid_suspend,
	.resume =	hid_resume,
1437
	.reset_resume =	hid_reset_resume,
1438
#endif
1439 1440
	.pre_reset =	hid_pre_reset,
	.post_reset =	hid_post_reset,
Linus Torvalds's avatar
Linus Torvalds committed
1441
	.id_table =	hid_usb_ids,
1442
	.supports_autosuspend = 1,
Linus Torvalds's avatar
Linus Torvalds committed
1443 1444
};

Jiri Slaby's avatar
Jiri Slaby committed
1445 1446 1447 1448 1449
static const struct hid_device_id hid_usb_table[] = {
	{ HID_USB_DEVICE(HID_ANY_ID, HID_ANY_ID) },
	{ }
};

1450 1451 1452 1453 1454
struct usb_interface *usbhid_find_interface(int minor)
{
	return usb_find_interface(&hid_driver, minor);
}

Jiri Slaby's avatar
Jiri Slaby committed
1455 1456 1457 1458 1459
static struct hid_driver hid_usb_driver = {
	.name = "generic-usb",
	.id_table = hid_usb_table,
};

Linus Torvalds's avatar
Linus Torvalds committed
1460 1461
static int __init hid_init(void)
{
1462 1463 1464 1465 1466
	int retval = -ENOMEM;

	resumption_waker = create_freezeable_workqueue("usbhid_resumer");
	if (!resumption_waker)
		goto no_queue;
Jiri Slaby's avatar
Jiri Slaby committed
1467 1468 1469
	retval = hid_register_driver(&hid_usb_driver);
	if (retval)
		goto hid_register_fail;
1470 1471 1472
	retval = usbhid_quirks_init(quirks_param);
	if (retval)
		goto usbhid_quirks_init_fail;
Linus Torvalds's avatar
Linus Torvalds committed
1473 1474 1475
	retval = usb_register(&hid_driver);
	if (retval)
		goto usb_register_fail;
1476
	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
Linus Torvalds's avatar
Linus Torvalds committed
1477 1478 1479

	return 0;
usb_register_fail:
1480 1481
	usbhid_quirks_exit();
usbhid_quirks_init_fail:
Jiri Slaby's avatar
Jiri Slaby committed
1482 1483
	hid_unregister_driver(&hid_usb_driver);
hid_register_fail:
1484 1485
	destroy_workqueue(resumption_waker);
no_queue:
Linus Torvalds's avatar
Linus Torvalds committed
1486 1487 1488 1489 1490 1491
	return retval;
}

static void __exit hid_exit(void)
{
	usb_deregister(&hid_driver);
1492
	usbhid_quirks_exit();
Jiri Slaby's avatar
Jiri Slaby committed
1493
	hid_unregister_driver(&hid_usb_driver);
1494
	destroy_workqueue(resumption_waker);
Linus Torvalds's avatar
Linus Torvalds committed
1495 1496 1497 1498 1499
}

module_init(hid_init);
module_exit(hid_exit);

1500 1501 1502
MODULE_AUTHOR("Andreas Gal");
MODULE_AUTHOR("Vojtech Pavlik");
MODULE_AUTHOR("Jiri Kosina");
Linus Torvalds's avatar
Linus Torvalds committed
1503 1504
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE(DRIVER_LICENSE);