hid-core.c 37.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
8
 *  Copyright (c) 2006-2009 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
319
320
321
322
323
324
325
		if (usb_submit_urb(usbhid->urbout, GFP_ATOMIC)) {
			err_hid("usb_submit_urb(out) failed");
			return -1;
		}
	} 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);
326
	}
Linus Torvalds's avatar
Linus Torvalds committed
327

328
329
330
331
	return 0;
}

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

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

343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
	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
365

366
367
368
369
370
		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
371

372
373
374
		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
375

376
377
378
379
380
381
382
383
384
385
386
		if (usb_submit_urb(usbhid->urbctrl, GFP_ATOMIC)) {
			err_hid("usb_submit_urb(ctrl) failed");
			return -1;
		}
	} 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);
387
	}
Linus Torvalds's avatar
Linus Torvalds committed
388

389
390
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
391

392
393
394
/*
 * Output interrupt completion handler.
 */
Linus Torvalds's avatar
Linus Torvalds committed
395

396
397
398
399
400
401
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
402

403
	switch (urb->status) {
Jiri Slaby's avatar
Jiri Slaby committed
404
405
406
407
408
409
410
411
412
413
	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 */
414
415
		dev_warn(&urb->dev->dev, "output irq status %d "
				"received\n", urb->status);
416
	}
Linus Torvalds's avatar
Linus Torvalds committed
417

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

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

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

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

439
440
441
/*
 * Control pipe completion handler.
 */
Linus Torvalds's avatar
Linus Torvalds committed
442

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

449
	spin_lock(&usbhid->lock);
Linus Torvalds's avatar
Linus Torvalds committed
450

451
	switch (status) {
Jiri Slaby's avatar
Jiri Slaby committed
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
	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 */
467
		dev_warn(&urb->dev->dev, "ctrl urb status %d "
468
				"received\n", status);
469
	}
Linus Torvalds's avatar
Linus Torvalds committed
470

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

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

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

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

497
498
	if ((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN)
		return;
499

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

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

515
516
517
518
519
		if (!test_and_set_bit(HID_OUT_RUNNING, &usbhid->iofl))
			if (hid_submit_out(hid))
				clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
		return;
	}
Linus Torvalds's avatar
Linus Torvalds committed
520

521
	if ((head = (usbhid->ctrlhead + 1) & (HID_CONTROL_FIFO_SIZE - 1)) == usbhid->ctrltail) {
522
		dev_warn(&hid->dev, "control queue full\n");
523
524
		return;
	}
525

526
527
528
	if (dir == USB_DIR_OUT) {
		usbhid->ctrl[usbhid->ctrlhead].raw_report = kmalloc(len, GFP_ATOMIC);
		if (!usbhid->ctrl[usbhid->ctrlhead].raw_report) {
529
			dev_warn(&hid->dev, "control queueing failed\n");
530
531
532
533
			return;
		}
		hid_output_report(report, usbhid->ctrl[usbhid->ctrlhead].raw_report);
	}
534
535
536
	usbhid->ctrl[usbhid->ctrlhead].report = report;
	usbhid->ctrl[usbhid->ctrlhead].dir = dir;
	usbhid->ctrlhead = head;
537

538
539
540
	if (!test_and_set_bit(HID_CTRL_RUNNING, &usbhid->iofl))
		if (hid_submit_ctrl(hid))
			clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
541
}
542

543
544
545
546
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;
547

548
549
550
	spin_lock_irqsave(&usbhid->lock, flags);
	__usbhid_submit_report(hid, report, dir);
	spin_unlock_irqrestore(&usbhid->lock, flags);
551
}
Jiri Slaby's avatar
Jiri Slaby committed
552
EXPORT_SYMBOL_GPL(usbhid_submit_report);
553

554
555
static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
556
	struct hid_device *hid = input_get_drvdata(dev);
557
	struct usbhid_device *usbhid = hid->driver_data;
558
	struct hid_field *field;
559
	unsigned long flags;
560
	int offset;
561

562
563
	if (type == EV_FF)
		return input_ff_event(dev, type, code, value);
564

565
566
	if (type != EV_LED)
		return -1;
567

568
	if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
569
		dev_warn(&dev->dev, "event field not found\n");
570
571
		return -1;
	}
Geoff Levand's avatar
Geoff Levand committed
572

573
	hid_set_field(field, offset, value);
574
575
576
577
578
579
580
581
582
	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);
	}
583
	usbhid_submit_report(hid, field->report, USB_DIR_OUT);
Linus Torvalds's avatar
Linus Torvalds committed
584

585
586
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
587

588
589
590
int usbhid_wait_io(struct hid_device *hid)
{
	struct usbhid_device *usbhid = hid->driver_data;
591

Jiri Slaby's avatar
Jiri Slaby committed
592
593
594
	if (!wait_event_timeout(usbhid->wait,
				(!test_bit(HID_CTRL_RUNNING, &usbhid->iofl) &&
				!test_bit(HID_OUT_RUNNING, &usbhid->iofl)),
595
					10*HZ)) {
596
		dbg_hid("timeout waiting for ctrl or out queue to clear\n");
597
598
		return -1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
599

600
601
	return 0;
}
602

603
604
605
606
607
608
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
609

610
611
612
613
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
614

615
	memset(buf, 0, size);
Linus Torvalds's avatar
Linus Torvalds committed
616

617
618
619
620
621
622
623
624
	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;
}
625

626
627
int usbhid_open(struct hid_device *hid)
{
628
629
630
	struct usbhid_device *usbhid = hid->driver_data;
	int res;

631
	mutex_lock(&hid_open_mut);
632
633
	if (!hid->open++) {
		res = usb_autopm_get_interface(usbhid->intf);
634
		/* the device must be awake to reliable request remote wakeup */
635
636
		if (res < 0) {
			hid->open--;
637
			mutex_unlock(&hid_open_mut);
638
639
			return -EIO;
		}
640
641
642
643
644
		usbhid->intf->needs_remote_wakeup = 1;
		if (hid_start_in(hid))
			hid_io_error(hid);
 
		usb_autopm_put_interface(usbhid->intf);
645
	}
646
	mutex_unlock(&hid_open_mut);
647
648
	return 0;
}
649

650
651
652
void usbhid_close(struct hid_device *hid)
{
	struct usbhid_device *usbhid = hid->driver_data;
653

654
655
656
657
658
659
660
	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);
661
	if (!--hid->open) {
662
		spin_unlock_irq(&usbhid->lock);
663
		hid_cancel_delayed_stuff(usbhid);
664
		usb_kill_urb(usbhid->urbin);
665
666
667
		usbhid->intf->needs_remote_wakeup = 0;
	} else {
		spin_unlock_irq(&usbhid->lock);
668
	}
669
	mutex_unlock(&hid_open_mut);
670
}
671

672
673
674
/*
 * Initialize all reports
 */
675

676
677
678
679
680
void usbhid_init_reports(struct hid_device *hid)
{
	struct hid_report *report;
	struct usbhid_device *usbhid = hid->driver_data;
	int err, ret;
681

682
683
	list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list)
		usbhid_submit_report(hid, report, USB_DIR_IN);
684

685
686
	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
687

688
689
690
691
692
693
694
695
696
697
	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);
	}
698

699
	if (err)
700
		dev_warn(&hid->dev, "timeout initializing reports\n");
701
}
Linus Torvalds's avatar
Linus Torvalds committed
702

703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
/*
 * 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
730
void usbhid_set_leds(struct hid_device *hid)
731
732
733
734
735
736
737
738
739
{
	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
740
EXPORT_SYMBOL_GPL(usbhid_set_leds);
741

742
743
744
/*
 * Traverse the supplied list of reports and find the longest
 */
Jiri Slaby's avatar
Jiri Slaby committed
745
746
static void hid_find_max_report(struct hid_device *hid, unsigned int type,
		unsigned int *max)
747
748
{
	struct hid_report *report;
Jiri Slaby's avatar
Jiri Slaby committed
749
	unsigned int size;
750
751

	list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
752
		size = ((report->size - 1) >> 3) + 1 + hid->report_enum[type].numbered;
753
754
755
756
757
		if (*max < size)
			*max = size;
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
758
759
static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid)
{
760
761
	struct usbhid_device *usbhid = hid->driver_data;

762
763
764
765
766
767
768
769
770
771
	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
772
773
774
775
776
		return -1;

	return 0;
}

777
778
779
780
781
782
783
784
785
786
787
static int usbhid_output_raw_report(struct hid_device *hid, __u8 *buf, size_t count)
{
	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,
788
		((HID_OUTPUT_REPORT + 1) << 8) | *buf,
789
790
791
792
793
794
795
796
797
798
		interface->desc.bInterfaceNumber, buf + 1, count - 1,
		USB_CTRL_SET_TIMEOUT);

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

	return ret;
}

799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
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
818
819
static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
{
820
821
	struct usbhid_device *usbhid = hid->driver_data;

822
823
824
825
	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
826
827
}

828
829
830
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
831
832
833
	struct usb_host_interface *interface = intf->cur_altsetting;
	struct usb_device *dev = interface_to_usbdev (intf);
	struct hid_descriptor *hdesc;
834
	u32 quirks = 0;
835
	unsigned int rsize = 0;
836
	char *rdesc;
837
	int ret, n;
Linus Torvalds's avatar
Linus Torvalds committed
838

839
840
	quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor),
			le16_to_cpu(dev->descriptor.idProduct));
Linus Torvalds's avatar
Linus Torvalds committed
841

842
843
844
	if (quirks & HID_QUIRK_IGNORE)
		return -ENODEV;

845
846
847
848
849
850
851
852
	/* 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;
	}

853
854
855
	if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&
	    (!interface->desc.bNumEndpoints ||
	     usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {
856
		dbg_hid("class descriptor not present\n");
857
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
858
859
	}

860
861
862
	hid->version = le16_to_cpu(hdesc->bcdHID);
	hid->country = hdesc->bCountryCode;

Linus Torvalds's avatar
Linus Torvalds committed
863
864
865
866
867
	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) {
868
		dbg_hid("weird size of report descriptor (%u)\n", rsize);
869
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
870
871
872
	}

	if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) {
873
		dbg_hid("couldn't allocate rdesc memory\n");
874
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
875
876
	}

877
878
	hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0);

879
880
881
	ret = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber,
			HID_DT_REPORT, rdesc, rsize);
	if (ret < 0) {
882
		dbg_hid("reading report descriptor failed\n");
Linus Torvalds's avatar
Linus Torvalds committed
883
		kfree(rdesc);
884
		goto err;
Linus Torvalds's avatar
Linus Torvalds committed
885
886
	}

887
888
889
	ret = hid_parse_report(hid, rdesc, rsize);
	kfree(rdesc);
	if (ret) {
890
		dbg_hid("parsing report descriptor failed\n");
891
		goto err;
Linus Torvalds's avatar
Linus Torvalds committed
892
893
	}

894
	hid->quirks |= quirks;
Linus Torvalds's avatar
Linus Torvalds committed
895

896
897
898
899
900
901
902
903
904
905
	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);
906
	struct usbhid_device *usbhid = hid->driver_data;
907
908
909
	unsigned int n, insize = 0;
	int ret;

910
911
	clear_bit(HID_DISCONNECTED, &usbhid->iofl);

912
913
914
915
	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);
916

917
918
	if (usbhid->bufsize > HID_MAX_BUFFER_SIZE)
		usbhid->bufsize = HID_MAX_BUFFER_SIZE;
919
920
921
922
923
924

	hid_find_max_report(hid, HID_INPUT_REPORT, &insize);

	if (insize > HID_MAX_BUFFER_SIZE)
		insize = HID_MAX_BUFFER_SIZE;

925
926
	if (hid_alloc_buffers(dev, hid)) {
		ret = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
927
		goto fail;
928
929
	}

Linus Torvalds's avatar
Linus Torvalds committed
930
931
932
933
934
935
	for (n = 0; n < interface->desc.bNumEndpoints; n++) {
		struct usb_endpoint_descriptor *endpoint;
		int pipe;
		int interval;

		endpoint = &interface->endpoint[n].desc;
936
		if (!usb_endpoint_xfer_int(endpoint))
Linus Torvalds's avatar
Linus Torvalds committed
937
938
939
940
			continue;

		interval = endpoint->bInterval;

941
		/* Some vendors give fullspeed interval on highspeed devides */
942
		if (hid->quirks & HID_QUIRK_FULLSPEED_INTERVAL &&
943
944
945
946
947
948
		    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
949
950
951
		/* Change the polling interval of mice. */
		if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0)
			interval = hid_mousepoll_interval;
952

953
		ret = -ENOMEM;
954
		if (usb_endpoint_dir_in(endpoint)) {
955
			if (usbhid->urbin)
Linus Torvalds's avatar
Linus Torvalds committed
956
				continue;
957
			if (!(usbhid->urbin = usb_alloc_urb(0, GFP_KERNEL)))
Linus Torvalds's avatar
Linus Torvalds committed
958
959
				goto fail;
			pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
960
			usb_fill_int_urb(usbhid->urbin, dev, pipe, usbhid->inbuf, insize,
Linus Torvalds's avatar
Linus Torvalds committed
961
					 hid_irq_in, hid, interval);
962
963
			usbhid->urbin->transfer_dma = usbhid->inbuf_dma;
			usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
Linus Torvalds's avatar
Linus Torvalds committed
964
		} else {
965
			if (usbhid->urbout)
Linus Torvalds's avatar
Linus Torvalds committed
966
				continue;
967
			if (!(usbhid->urbout = usb_alloc_urb(0, GFP_KERNEL)))
Linus Torvalds's avatar
Linus Torvalds committed
968
969
				goto fail;
			pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress);
970
			usb_fill_int_urb(usbhid->urbout, dev, pipe, usbhid->outbuf, 0,
Linus Torvalds's avatar
Linus Torvalds committed
971
					 hid_irq_out, hid, interval);
972
973
			usbhid->urbout->transfer_dma = usbhid->outbuf_dma;
			usbhid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
Linus Torvalds's avatar
Linus Torvalds committed
974
975
976
		}
	}

Jiri Slaby's avatar
Jiri Slaby committed
977
	init_waitqueue_head(&usbhid->wait);
978
	INIT_WORK(&usbhid->reset_work, hid_reset);
979
	INIT_WORK(&usbhid->restart_work, __usbhid_restart_queues);
980
	setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid);
981

982
	spin_lock_init(&usbhid->lock);
Linus Torvalds's avatar
Linus Torvalds committed
983

984
985
	usbhid->intf = intf;
	usbhid->ifnum = interface->desc.bInterfaceNumber;
Linus Torvalds's avatar
Linus Torvalds committed
986

987
	usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL);
988
989
	if (!usbhid->urbctrl) {
		ret = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
990
		goto fail;
991
	}
992

993
994
995
996
997
	usb_fill_control_urb(usbhid->urbctrl, dev, 0, (void *) usbhid->cr,
			     usbhid->ctrlbuf, 1, hid_ctrl, hid);
	usbhid->urbctrl->setup_dma = usbhid->cr_dma;
	usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma;
	usbhid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);
998

Jiri Kosina's avatar
Jiri Kosina committed
999
1000
	if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS))
		usbhid_init_reports(hid);
Jiri Slaby's avatar
Jiri Slaby committed
1001

1002
1003
	set_bit(HID_STARTED, &usbhid->iofl);

1004
1005
1006
1007
1008
1009
1010
1011
1012
	/* 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.
	 */
	if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT &&
			interface->desc.bInterfaceProtocol ==
				USB_INTERFACE_PROTOCOL_KEYBOARD)
		usbhid_set_leds(hid);

1013
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1014
1015

fail:
1016
1017
1018
	usb_free_urb(usbhid->urbin);
	usb_free_urb(usbhid->urbout);
	usb_free_urb(usbhid->urbctrl);
1019
1020
1021
	usbhid->urbin = NULL;
	usbhid->urbout = NULL;
	usbhid->urbctrl = NULL;
1022
	hid_free_buffers(dev, hid);
1023
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1024
1025
}

1026
static void usbhid_stop(struct hid_device *hid)
Linus Torvalds's avatar
Linus Torvalds committed
1027
{
1028
	struct usbhid_device *usbhid = hid->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
1029

1030
	if (WARN_ON(!usbhid))
Linus Torvalds's avatar
Linus Torvalds committed
1031
1032
		return;

1033
	clear_bit(HID_STARTED, &usbhid->iofl);
1034
	spin_lock_irq(&usbhid->lock);	/* Sync with error handler */
1035
	set_bit(HID_DISCONNECTED, &usbhid->iofl);
1036
	spin_unlock_irq(&usbhid->lock);
1037
1038
1039
	usb_kill_urb(usbhid->urbin);
	usb_kill_urb(usbhid->urbout);
	usb_kill_urb(usbhid->urbctrl);
Linus Torvalds's avatar
Linus Torvalds committed
1040

1041
	hid_cancel_delayed_stuff(usbhid);
1042

1043
1044
	hid->claimed = 0;

1045
1046
1047
	usb_free_urb(usbhid->urbin);
	usb_free_urb(usbhid->urbctrl);
	usb_free_urb(usbhid->urbout);
1048
1049
1050
	usbhid->urbin = NULL; /* don't mess up next start */
	usbhid->urbctrl = NULL;
	usbhid->urbout = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1051

1052
	hid_free_buffers(hid_to_usb_dev(hid), hid);
Linus Torvalds's avatar
Linus Torvalds committed
1053
1054
}

1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
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;
}

1070
1071
1072
1073
1074
1075
static struct hid_ll_driver usb_hid_driver = {
	.parse = usbhid_parse,
	.start = usbhid_start,
	.stop = usbhid_stop,
	.open = usbhid_open,
	.close = usbhid_close,
1076
	.power = usbhid_power,
1077
1078
1079
	.hidinput_input_event = usb_hidinput_input_event,
};

Jiri Kosina's avatar