hid-core.c 31.8 KB
Newer Older
L
Linus Torvalds 已提交
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) 2006-2007 Jiri Kosina
L
Linus Torvalds 已提交
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 */

/*
 * 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>
#include <linux/smp_lock.h>
#include <linux/spinlock.h>
#include <asm/unaligned.h>
#include <asm/byteorder.h>
#include <linux/input.h>
#include <linux/wait.h>

#include <linux/usb.h>

32
#include <linux/hid.h>
L
Linus Torvalds 已提交
33
#include <linux/hiddev.h>
34
#include <linux/hid-debug.h>
J
Jiri Kosina 已提交
35
#include <linux/hidraw.h>
J
Jiri Kosina 已提交
36
#include "usbhid.h"
L
Linus Torvalds 已提交
37 38 39 40 41

/*
 * Version Information
 */

42
#define DRIVER_VERSION "v2.6"
43
#define DRIVER_AUTHOR "Andreas Gal, Vojtech Pavlik, Jiri Kosina"
L
Linus Torvalds 已提交
44 45 46 47 48 49 50 51 52 53 54 55 56
#define DRIVER_DESC "USB HID core driver"
#define DRIVER_LICENSE "GPL"

static char *hid_types[] = {"Device", "Pointer", "Mouse", "Device", "Joystick",
				"Gamepad", "Keyboard", "Keypad", "Multi-Axis Controller"};
/*
 * 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");

57 58 59 60 61 62 63
/* 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");
64 65 66 67 68 69
static char *rdesc_quirks_param[MAX_USBHID_BOOT_QUIRKS] = { [ 0 ... (MAX_USBHID_BOOT_QUIRKS - 1) ] = NULL };
module_param_array_named(rdesc_quirks, rdesc_quirks_param, charp, NULL, 0444);
MODULE_PARM_DESC(rdesc_quirks, "Add/modify report descriptor quirks by specifying "
		" rdesc_quirks=vendorID:productID:rdesc_quirks"
		" where vendorID, productID, and rdesc_quirks are all in"
		" 0x-prefixed hex");
L
Linus Torvalds 已提交
70
/*
71
 * Input submission and I/O error handler.
L
Linus Torvalds 已提交
72 73
 */

74 75 76 77
static void hid_io_error(struct hid_device *hid);

/* Start up the input URB */
static int hid_start_in(struct hid_device *hid)
L
Linus Torvalds 已提交
78 79
{
	unsigned long flags;
80 81
	int rc = 0;
	struct usbhid_device *usbhid = hid->driver_data;
L
Linus Torvalds 已提交
82

83 84
	spin_lock_irqsave(&usbhid->inlock, flags);
	if (hid->open > 0 && !test_bit(HID_SUSPENDED, &usbhid->iofl) &&
85
			!test_bit(HID_DISCONNECTED, &usbhid->iofl) &&
86 87 88 89
			!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);
L
Linus Torvalds 已提交
90
	}
91 92
	spin_unlock_irqrestore(&usbhid->inlock, flags);
	return rc;
L
Linus Torvalds 已提交
93 94
}

95 96
/* I/O retry timer routine */
static void hid_retry_timeout(unsigned long _hid)
L
Linus Torvalds 已提交
97
{
98
	struct hid_device *hid = (struct hid_device *) _hid;
J
Jiri Kosina 已提交
99
	struct usbhid_device *usbhid = hid->driver_data;
L
Linus Torvalds 已提交
100

101 102 103
	dev_dbg(&usbhid->intf->dev, "retrying intr urb\n");
	if (hid_start_in(hid))
		hid_io_error(hid);
L
Linus Torvalds 已提交
104 105
}

106 107
/* Workqueue routine to reset the device or clear a halt */
static void hid_reset(struct work_struct *work)
L
Linus Torvalds 已提交
108
{
109 110 111 112
	struct usbhid_device *usbhid =
		container_of(work, struct usbhid_device, reset_work);
	struct hid_device *hid = usbhid->hid;
	int rc_lock, rc = 0;
L
Linus Torvalds 已提交
113

114 115 116 117 118 119
	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);
	}
L
Linus Torvalds 已提交
120

121 122 123 124
	else if (test_bit(HID_RESET_PENDING, &usbhid->iofl)) {
		dev_dbg(&usbhid->intf->dev, "resetting device\n");
		rc = rc_lock = usb_lock_device_for_reset(hid_to_usb_dev(hid), usbhid->intf);
		if (rc_lock >= 0) {
125
			rc = usb_reset_device(hid_to_usb_dev(hid));
126 127
			if (rc_lock)
				usb_unlock_device(hid_to_usb_dev(hid));
L
Linus Torvalds 已提交
128
		}
129
		clear_bit(HID_RESET_PENDING, &usbhid->iofl);
L
Linus Torvalds 已提交
130 131
	}

132 133 134 135 136 137
	switch (rc) {
	case 0:
		if (!test_bit(HID_IN_RUNNING, &usbhid->iofl))
			hid_io_error(hid);
		break;
	default:
138
		err_hid("can't reset device, %s-%s/input%d, status %d",
139 140 141 142 143 144 145 146
				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;
L
Linus Torvalds 已提交
147 148 149
	}
}

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

156
	spin_lock_irqsave(&usbhid->inlock, flags);
157

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

A
Alan Stern 已提交
162 163 164 165 166
	/* 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;

167 168 169 170 171 172
	/* 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;
173

174
	if (time_after(jiffies, usbhid->stop_retry)) {
J
Jiri Kosina 已提交
175

176 177 178 179 180
		/* Retries failed, so do a port reset */
		if (!test_and_set_bit(HID_RESET_PENDING, &usbhid->iofl)) {
			schedule_work(&usbhid->reset_work);
			goto done;
		}
L
Linus Torvalds 已提交
181 182
	}

183 184 185 186
	mod_timer(&usbhid->io_retry,
			jiffies + msecs_to_jiffies(usbhid->retry_delay));
done:
	spin_unlock_irqrestore(&usbhid->inlock, flags);
L
Linus Torvalds 已提交
187 188
}

189 190 191
/*
 * Input interrupt completion handler.
 */
192

193
static void hid_irq_in(struct urb *urb)
L
Linus Torvalds 已提交
194
{
195 196 197
	struct hid_device	*hid = urb->context;
	struct usbhid_device 	*usbhid = hid->driver_data;
	int			status;
L
Linus Torvalds 已提交
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
	switch (urb->status) {
		case 0:			/* success */
			usbhid->retry_delay = 0;
			hid_input_report(urb->context, HID_INPUT_REPORT,
					 urb->transfer_buffer,
					 urb->actual_length, 1);
			break;
		case -EPIPE:		/* stall */
			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... */
			clear_bit(HID_IN_RUNNING, &usbhid->iofl);
			hid_io_error(hid);
			return;
		default:		/* error */
			warn("input irq status %d received", urb->status);
	}
L
Linus Torvalds 已提交
226

227 228 229 230
	status = usb_submit_urb(urb, GFP_ATOMIC);
	if (status) {
		clear_bit(HID_IN_RUNNING, &usbhid->iofl);
		if (status != -EPERM) {
231
			err_hid("can't resubmit intr, %s-%s/input%d, status %d",
232 233 234 235 236 237
					hid_to_usb_dev(hid)->bus->bus_name,
					hid_to_usb_dev(hid)->devpath,
					usbhid->ifnum, status);
			hid_io_error(hid);
		}
	}
L
Linus Torvalds 已提交
238 239
}

240
static int hid_submit_out(struct hid_device *hid)
L
Linus Torvalds 已提交
241
{
242
	struct hid_report *report;
J
Jiri Kosina 已提交
243 244
	struct usbhid_device *usbhid = hid->driver_data;

245
	report = usbhid->out[usbhid->outtail];
L
Linus Torvalds 已提交
246

247 248 249
	hid_output_report(report, usbhid->outbuf);
	usbhid->urbout->transfer_buffer_length = ((report->size - 1) >> 3) + 1 + (report->id > 0);
	usbhid->urbout->dev = hid_to_usb_dev(hid);
250

251
	dbg_hid("submitting out urb\n");
252

253
	if (usb_submit_urb(usbhid->urbout, GFP_ATOMIC)) {
254
		err_hid("usb_submit_urb(out) failed");
255 256
		return -1;
	}
L
Linus Torvalds 已提交
257

258 259 260 261
	return 0;
}

static int hid_submit_ctrl(struct hid_device *hid)
L
Linus Torvalds 已提交
262 263
{
	struct hid_report *report;
264 265
	unsigned char dir;
	int len;
J
Jiri Kosina 已提交
266
	struct usbhid_device *usbhid = hid->driver_data;
L
Linus Torvalds 已提交
267

268 269
	report = usbhid->ctrl[usbhid->ctrltail].report;
	dir = usbhid->ctrl[usbhid->ctrltail].dir;
L
Linus Torvalds 已提交
270

271 272 273 274 275 276 277
	len = ((report->size - 1) >> 3) + 1 + (report->id > 0);
	if (dir == USB_DIR_OUT) {
		hid_output_report(report, usbhid->ctrlbuf);
		usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0);
		usbhid->urbctrl->transfer_buffer_length = len;
	} else {
		int maxpacket, padlen;
L
Linus Torvalds 已提交
278

279 280 281
		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) {
J
Julia Lawall 已提交
282
			padlen = DIV_ROUND_UP(len, maxpacket);
283 284 285 286 287 288
			padlen *= maxpacket;
			if (padlen > usbhid->bufsize)
				padlen = usbhid->bufsize;
		} else
			padlen = 0;
		usbhid->urbctrl->transfer_buffer_length = padlen;
L
Linus Torvalds 已提交
289
	}
290
	usbhid->urbctrl->dev = hid_to_usb_dev(hid);
L
Linus Torvalds 已提交
291

292 293 294 295 296
	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);
L
Linus Torvalds 已提交
297

298
	dbg_hid("submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u\n",
299 300
		usbhid->cr->bRequest == HID_REQ_SET_REPORT ? "Set_Report" : "Get_Report",
		usbhid->cr->wValue, usbhid->cr->wIndex, usbhid->cr->wLength);
L
Linus Torvalds 已提交
301

302
	if (usb_submit_urb(usbhid->urbctrl, GFP_ATOMIC)) {
303
		err_hid("usb_submit_urb(ctrl) failed");
304 305
		return -1;
	}
L
Linus Torvalds 已提交
306

307 308
	return 0;
}
L
Linus Torvalds 已提交
309

310 311 312
/*
 * Output interrupt completion handler.
 */
L
Linus Torvalds 已提交
313

314 315 316 317 318 319
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;
L
Linus Torvalds 已提交
320

321 322 323 324 325 326 327 328 329 330 331 332 333
	switch (urb->status) {
		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 */
			warn("output irq status %d received", urb->status);
	}
L
Linus Torvalds 已提交
334

335
	spin_lock_irqsave(&usbhid->outlock, flags);
L
Linus Torvalds 已提交
336

337 338 339 340
	if (unplug)
		usbhid->outtail = usbhid->outhead;
	else
		usbhid->outtail = (usbhid->outtail + 1) & (HID_OUTPUT_FIFO_SIZE - 1);
L
Linus Torvalds 已提交
341

342 343 344
	if (usbhid->outhead != usbhid->outtail) {
		if (hid_submit_out(hid)) {
			clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
J
Jiri Slaby 已提交
345
			wake_up(&usbhid->wait);
346 347 348 349
		}
		spin_unlock_irqrestore(&usbhid->outlock, flags);
		return;
	}
L
Linus Torvalds 已提交
350

351 352
	clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
	spin_unlock_irqrestore(&usbhid->outlock, flags);
J
Jiri Slaby 已提交
353
	wake_up(&usbhid->wait);
354
}
355

356 357 358
/*
 * Control pipe completion handler.
 */
L
Linus Torvalds 已提交
359

360 361 362 363 364 365
static void hid_ctrl(struct urb *urb)
{
	struct hid_device *hid = urb->context;
	struct usbhid_device *usbhid = hid->driver_data;
	unsigned long flags;
	int unplug = 0;
L
Linus Torvalds 已提交
366

367
	spin_lock_irqsave(&usbhid->ctrllock, flags);
L
Linus Torvalds 已提交
368

369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
	switch (urb->status) {
		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 */
			warn("ctrl urb status %d received", urb->status);
	}
L
Linus Torvalds 已提交
386

387 388 389 390
	if (unplug)
		usbhid->ctrltail = usbhid->ctrlhead;
	else
		usbhid->ctrltail = (usbhid->ctrltail + 1) & (HID_CONTROL_FIFO_SIZE - 1);
L
Linus Torvalds 已提交
391

392 393 394
	if (usbhid->ctrlhead != usbhid->ctrltail) {
		if (hid_submit_ctrl(hid)) {
			clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
J
Jiri Slaby 已提交
395
			wake_up(&usbhid->wait);
396 397 398 399
		}
		spin_unlock_irqrestore(&usbhid->ctrllock, flags);
		return;
	}
L
Linus Torvalds 已提交
400

401 402
	clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
	spin_unlock_irqrestore(&usbhid->ctrllock, flags);
J
Jiri Slaby 已提交
403
	wake_up(&usbhid->wait);
404
}
L
Linus Torvalds 已提交
405

406 407 408 409 410
void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir)
{
	int head;
	unsigned long flags;
	struct usbhid_device *usbhid = hid->driver_data;
L
Linus Torvalds 已提交
411

412 413
	if ((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN)
		return;
414

415
	if (usbhid->urbout && dir == USB_DIR_OUT && report->type == HID_OUTPUT_REPORT) {
L
Linus Torvalds 已提交
416

417
		spin_lock_irqsave(&usbhid->outlock, flags);
L
Linus Torvalds 已提交
418

419 420 421 422 423
		if ((head = (usbhid->outhead + 1) & (HID_OUTPUT_FIFO_SIZE - 1)) == usbhid->outtail) {
			spin_unlock_irqrestore(&usbhid->outlock, flags);
			warn("output queue full");
			return;
		}
L
Linus Torvalds 已提交
424

425 426
		usbhid->out[usbhid->outhead] = report;
		usbhid->outhead = head;
427

428 429 430
		if (!test_and_set_bit(HID_OUT_RUNNING, &usbhid->iofl))
			if (hid_submit_out(hid))
				clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
431

432 433 434
		spin_unlock_irqrestore(&usbhid->outlock, flags);
		return;
	}
L
Linus Torvalds 已提交
435

436
	spin_lock_irqsave(&usbhid->ctrllock, flags);
437

438 439 440 441 442
	if ((head = (usbhid->ctrlhead + 1) & (HID_CONTROL_FIFO_SIZE - 1)) == usbhid->ctrltail) {
		spin_unlock_irqrestore(&usbhid->ctrllock, flags);
		warn("control queue full");
		return;
	}
443

444 445 446
	usbhid->ctrl[usbhid->ctrlhead].report = report;
	usbhid->ctrl[usbhid->ctrlhead].dir = dir;
	usbhid->ctrlhead = head;
447

448 449 450
	if (!test_and_set_bit(HID_CTRL_RUNNING, &usbhid->iofl))
		if (hid_submit_ctrl(hid))
			clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
451

452 453
	spin_unlock_irqrestore(&usbhid->ctrllock, flags);
}
454

455 456
static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
457
	struct hid_device *hid = input_get_drvdata(dev);
458 459
	struct hid_field *field;
	int offset;
460

461 462
	if (type == EV_FF)
		return input_ff_event(dev, type, code, value);
463

464 465
	if (type != EV_LED)
		return -1;
466

467 468 469 470
	if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
		warn("event field not found");
		return -1;
	}
G
Geoff Levand 已提交
471

472 473
	hid_set_field(field, offset, value);
	usbhid_submit_report(hid, field->report, USB_DIR_OUT);
L
Linus Torvalds 已提交
474

475 476
	return 0;
}
L
Linus Torvalds 已提交
477

478 479 480
int usbhid_wait_io(struct hid_device *hid)
{
	struct usbhid_device *usbhid = hid->driver_data;
481

J
Jiri Slaby 已提交
482 483 484
	if (!wait_event_timeout(usbhid->wait,
				(!test_bit(HID_CTRL_RUNNING, &usbhid->iofl) &&
				!test_bit(HID_OUT_RUNNING, &usbhid->iofl)),
485
					10*HZ)) {
486
		dbg_hid("timeout waiting for ctrl or out queue to clear\n");
487 488
		return -1;
	}
L
Linus Torvalds 已提交
489

490 491
	return 0;
}
492

493 494 495 496 497 498
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);
}
L
Linus Torvalds 已提交
499

500 501 502 503
static int hid_get_class_descriptor(struct usb_device *dev, int ifnum,
		unsigned char type, void *buf, int size)
{
	int result, retries = 4;
L
Linus Torvalds 已提交
504

505
	memset(buf, 0, size);
L
Linus Torvalds 已提交
506

507 508 509 510 511 512 513 514
	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;
}
515

516 517
int usbhid_open(struct hid_device *hid)
{
518 519 520 521 522 523 524 525 526 527
	struct usbhid_device *usbhid = hid->driver_data;
	int res;

	if (!hid->open++) {
		res = usb_autopm_get_interface(usbhid->intf);
		if (res < 0) {
			hid->open--;
			return -EIO;
		}
	}
528 529 530 531
	if (hid_start_in(hid))
		hid_io_error(hid);
	return 0;
}
532

533 534 535
void usbhid_close(struct hid_device *hid)
{
	struct usbhid_device *usbhid = hid->driver_data;
536

537
	if (!--hid->open) {
538
		usb_kill_urb(usbhid->urbin);
539 540
		usb_autopm_put_interface(usbhid->intf);
	}
541
}
542

543 544 545
/*
 * Initialize all reports
 */
546

547 548 549 550 551
void usbhid_init_reports(struct hid_device *hid)
{
	struct hid_report *report;
	struct usbhid_device *usbhid = hid->driver_data;
	int err, ret;
552

553 554
	list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list)
		usbhid_submit_report(hid, report, USB_DIR_IN);
555

556 557
	list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].report_list, list)
		usbhid_submit_report(hid, report, USB_DIR_IN);
G
Geoff Levand 已提交
558

559 560 561 562 563 564 565 566 567 568
	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);
	}
569

570 571 572
	if (err)
		warn("timeout initializing reports");
}
L
Linus Torvalds 已提交
573

574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
/*
 * 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;
}

static void usbhid_set_leds(struct hid_device *hid)
{
	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);
	}
}

612 613 614
/*
 * Traverse the supplied list of reports and find the longest
 */
J
Jiri Slaby 已提交
615 616
static void hid_find_max_report(struct hid_device *hid, unsigned int type,
		unsigned int *max)
617 618
{
	struct hid_report *report;
J
Jiri Slaby 已提交
619
	unsigned int size;
620 621 622 623 624 625 626 627 628 629

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

L
Linus Torvalds 已提交
630 631
static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid)
{
J
Jiri Kosina 已提交
632 633 634
	struct usbhid_device *usbhid = hid->driver_data;

	if (!(usbhid->inbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->inbuf_dma)))
L
Linus Torvalds 已提交
635
		return -1;
J
Jiri Kosina 已提交
636
	if (!(usbhid->outbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->outbuf_dma)))
L
Linus Torvalds 已提交
637
		return -1;
J
Jiri Kosina 已提交
638
	if (!(usbhid->cr = usb_buffer_alloc(dev, sizeof(*(usbhid->cr)), GFP_ATOMIC, &usbhid->cr_dma)))
L
Linus Torvalds 已提交
639
		return -1;
J
Jiri Kosina 已提交
640
	if (!(usbhid->ctrlbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->ctrlbuf_dma)))
L
Linus Torvalds 已提交
641 642 643 644 645
		return -1;

	return 0;
}

646 647 648 649 650 651 652 653 654 655 656
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,
657
		((HID_OUTPUT_REPORT + 1) << 8) | *buf,
658 659 660 661 662 663 664 665 666 667
		interface->desc.bInterfaceNumber, buf + 1, count - 1,
		USB_CTRL_SET_TIMEOUT);

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

	return ret;
}

L
Linus Torvalds 已提交
668 669
static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
{
J
Jiri Kosina 已提交
670 671
	struct usbhid_device *usbhid = hid->driver_data;

672 673 674 675
	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);
L
Linus Torvalds 已提交
676 677
}

G
Geoff Levand 已提交
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
/*
 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
 * to "operational".  Without this, the ps3 controller will not report any
 * events.
 */
static void hid_fixup_sony_ps3_controller(struct usb_device *dev, int ifnum)
{
	int result;
	char *buf = kmalloc(18, GFP_KERNEL);

	if (!buf)
		return;

	result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
				 HID_REQ_GET_REPORT,
				 USB_DIR_IN | USB_TYPE_CLASS |
				 USB_RECIP_INTERFACE,
				 (3 << 8) | 0xf2, ifnum, buf, 17,
				 USB_CTRL_GET_TIMEOUT);

	if (result < 0)
699
		err_hid("%s failed: %d\n", __func__, result);
G
Geoff Levand 已提交
700 701 702 703

	kfree(buf);
}

L
Linus Torvalds 已提交
704 705 706 707 708 709
static struct hid_device *usb_hid_configure(struct usb_interface *intf)
{
	struct usb_host_interface *interface = intf->cur_altsetting;
	struct usb_device *dev = interface_to_usbdev (intf);
	struct hid_descriptor *hdesc;
	struct hid_device *hid;
710
	u32 quirks = 0;
J
Jiri Slaby 已提交
711
	unsigned int insize = 0, rsize = 0;
712
	char *rdesc;
J
Jiri Slaby 已提交
713
	int n, len;
J
Jiri Kosina 已提交
714
	struct usbhid_device *usbhid;
L
Linus Torvalds 已提交
715

716 717
	quirks = usbhid_lookup_quirk(le16_to_cpu(dev->descriptor.idVendor),
			le16_to_cpu(dev->descriptor.idProduct));
L
Linus Torvalds 已提交
718

719 720 721 722 723 724 725 726
	/* 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;
	}

L
Linus Torvalds 已提交
727 728 729
	if (quirks & HID_QUIRK_IGNORE)
		return NULL;

730 731 732 733 734
	if ((quirks & HID_QUIRK_IGNORE_MOUSE) &&
		(interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE))
			return NULL;


735 736 737
	if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&
	    (!interface->desc.bNumEndpoints ||
	     usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {
738
		dbg_hid("class descriptor not present\n");
739
		return NULL;
L
Linus Torvalds 已提交
740 741 742 743 744 745 746
	}

	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) {
747
		dbg_hid("weird size of report descriptor (%u)\n", rsize);
L
Linus Torvalds 已提交
748 749 750 751
		return NULL;
	}

	if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) {
752
		dbg_hid("couldn't allocate rdesc memory\n");
L
Linus Torvalds 已提交
753 754 755
		return NULL;
	}

756 757
	hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0);

L
Linus Torvalds 已提交
758
	if ((n = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber, HID_DT_REPORT, rdesc, rsize)) < 0) {
759
		dbg_hid("reading report descriptor failed\n");
L
Linus Torvalds 已提交
760 761 762 763
		kfree(rdesc);
		return NULL;
	}

764 765 766
	usbhid_fixup_report_descriptor(le16_to_cpu(dev->descriptor.idVendor),
			le16_to_cpu(dev->descriptor.idProduct), rdesc,
			rsize, rdesc_quirks_param);
767

768
	dbg_hid("report descriptor (size %u, read %d) = ", rsize, n);
L
Linus Torvalds 已提交
769
	for (n = 0; n < rsize; n++)
770 771
		dbg_hid_line(" %02x", (unsigned char) rdesc[n]);
	dbg_hid_line("\n");
L
Linus Torvalds 已提交
772

J
Jiri Slaby 已提交
773 774 775 776 777 778 779
	hid = hid_allocate_device();
	if (IS_ERR(hid)) {
		kfree(rdesc);
		return NULL;
	}

	if (hid_parse_report(hid, rdesc, n)) {
780
		dbg_hid("parsing report descriptor failed\n");
J
Jiri Slaby 已提交
781
		hid_destroy_device(hid);
L
Linus Torvalds 已提交
782 783 784 785 786 787 788
		kfree(rdesc);
		return NULL;
	}

	kfree(rdesc);
	hid->quirks = quirks;

J
Jiri Kosina 已提交
789
	if (!(usbhid = kzalloc(sizeof(struct usbhid_device), GFP_KERNEL)))
790
		goto fail_no_usbhid;
J
Jiri Kosina 已提交
791 792 793 794 795 796 797 798

	hid->driver_data = usbhid;
	usbhid->hid = hid;

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

J
Jiri Kosina 已提交
800 801
	if (usbhid->bufsize > HID_MAX_BUFFER_SIZE)
		usbhid->bufsize = HID_MAX_BUFFER_SIZE;
802 803 804 805 806 807

	hid_find_max_report(hid, HID_INPUT_REPORT, &insize);

	if (insize > HID_MAX_BUFFER_SIZE)
		insize = HID_MAX_BUFFER_SIZE;

J
Jiri Slaby 已提交
808
	if (hid_alloc_buffers(dev, hid))
L
Linus Torvalds 已提交
809 810
		goto fail;

811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
	hid->name[0] = 0;

	if (dev->manufacturer)
		strlcpy(hid->name, dev->manufacturer, sizeof(hid->name));

	if (dev->product) {
		if (dev->manufacturer)
			strlcat(hid->name, " ", sizeof(hid->name));
		strlcat(hid->name, dev->product, sizeof(hid->name));
	}

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

L
Linus Torvalds 已提交
827 828 829 830 831 832 833 834 835 836 837 838
	for (n = 0; n < interface->desc.bNumEndpoints; n++) {

		struct usb_endpoint_descriptor *endpoint;
		int pipe;
		int interval;

		endpoint = &interface->endpoint[n].desc;
		if ((endpoint->bmAttributes & 3) != 3)		/* Not an interrupt endpoint */
			continue;

		interval = endpoint->bInterval;

839 840 841 842 843 844 845 846
		/* Some vendors give fullspeed interval on highspeed devides */
		if (quirks & HID_QUIRK_FULLSPEED_INTERVAL  &&
		    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);
		}

L
Linus Torvalds 已提交
847 848 849
		/* Change the polling interval of mice. */
		if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0)
			interval = hid_mousepoll_interval;
850

851
		if (usb_endpoint_dir_in(endpoint)) {
J
Jiri Kosina 已提交
852
			if (usbhid->urbin)
L
Linus Torvalds 已提交
853
				continue;
J
Jiri Kosina 已提交
854
			if (!(usbhid->urbin = usb_alloc_urb(0, GFP_KERNEL)))
L
Linus Torvalds 已提交
855 856
				goto fail;
			pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
J
Jiri Kosina 已提交
857
			usb_fill_int_urb(usbhid->urbin, dev, pipe, usbhid->inbuf, insize,
L
Linus Torvalds 已提交
858
					 hid_irq_in, hid, interval);
J
Jiri Kosina 已提交
859 860
			usbhid->urbin->transfer_dma = usbhid->inbuf_dma;
			usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
L
Linus Torvalds 已提交
861
		} else {
J
Jiri Kosina 已提交
862
			if (usbhid->urbout)
L
Linus Torvalds 已提交
863
				continue;
J
Jiri Kosina 已提交
864
			if (!(usbhid->urbout = usb_alloc_urb(0, GFP_KERNEL)))
L
Linus Torvalds 已提交
865 866
				goto fail;
			pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress);
J
Jiri Kosina 已提交
867
			usb_fill_int_urb(usbhid->urbout, dev, pipe, usbhid->outbuf, 0,
L
Linus Torvalds 已提交
868
					 hid_irq_out, hid, interval);
J
Jiri Kosina 已提交
869 870
			usbhid->urbout->transfer_dma = usbhid->outbuf_dma;
			usbhid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
L
Linus Torvalds 已提交
871 872 873
		}
	}

J
Jiri Kosina 已提交
874
	if (!usbhid->urbin) {
875
		err_hid("couldn't find an input interrupt endpoint");
L
Linus Torvalds 已提交
876 877 878
		goto fail;
	}

J
Jiri Slaby 已提交
879
	init_waitqueue_head(&usbhid->wait);
J
Jiri Kosina 已提交
880 881
	INIT_WORK(&usbhid->reset_work, hid_reset);
	setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid);
A
Alan Stern 已提交
882

J
Jiri Kosina 已提交
883 884 885
	spin_lock_init(&usbhid->inlock);
	spin_lock_init(&usbhid->outlock);
	spin_lock_init(&usbhid->ctrllock);
L
Linus Torvalds 已提交
886 887 888

	hid->version = le16_to_cpu(hdesc->bcdHID);
	hid->country = hdesc->bCountryCode;
J
Jiri Slaby 已提交
889
	hid->dev.parent = &intf->dev;
J
Jiri Kosina 已提交
890 891
	usbhid->intf = intf;
	usbhid->ifnum = interface->desc.bInterfaceNumber;
L
Linus Torvalds 已提交
892

J
Jiri Kosina 已提交
893
	hid->bus = BUS_USB;
894 895
	hid->vendor = le16_to_cpu(dev->descriptor.idVendor);
	hid->product = le16_to_cpu(dev->descriptor.idProduct);
J
Jiri Kosina 已提交
896

897 898 899 900 901 902
	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);
L
Linus Torvalds 已提交
903 904 905 906

	if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
		hid->uniq[0] = 0;

J
Jiri Kosina 已提交
907 908
	usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL);
	if (!usbhid->urbctrl)
L
Linus Torvalds 已提交
909
		goto fail;
910

J
Jiri Kosina 已提交
911 912 913 914 915
	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);
J
Jiri Kosina 已提交
916
	hid->hidinput_input_event = usb_hidinput_input_event;
917 918
	hid->hid_open = usbhid_open;
	hid->hid_close = usbhid_close;
J
Jiri Kosina 已提交
919 920
#ifdef CONFIG_USB_HIDDEV
	hid->hiddev_hid_event = hiddev_hid_event;
921
	hid->hiddev_report_event = hiddev_report_event;
J
Jiri Kosina 已提交
922
#endif
923
	hid->hid_output_raw_report = usbhid_output_raw_report;
L
Linus Torvalds 已提交
924 925 926
	return hid;

fail:
J
Jiri Kosina 已提交
927 928 929
	usb_free_urb(usbhid->urbin);
	usb_free_urb(usbhid->urbout);
	usb_free_urb(usbhid->urbctrl);
930
	hid_free_buffers(dev, hid);
931
	kfree(usbhid);
932
fail_no_usbhid:
J
Jiri Slaby 已提交
933
	hid_destroy_device(hid);
L
Linus Torvalds 已提交
934 935 936 937 938 939 940

	return NULL;
}

static void hid_disconnect(struct usb_interface *intf)
{
	struct hid_device *hid = usb_get_intfdata (intf);
J
Jiri Kosina 已提交
941
	struct usbhid_device *usbhid;
L
Linus Torvalds 已提交
942 943 944 945

	if (!hid)
		return;

J
Jiri Kosina 已提交
946 947 948
	usbhid = hid->driver_data;

	spin_lock_irq(&usbhid->inlock);	/* Sync with error handler */
L
Linus Torvalds 已提交
949
	usb_set_intfdata(intf, NULL);
950
	set_bit(HID_DISCONNECTED, &usbhid->iofl);
J
Jiri Kosina 已提交
951 952 953 954
	spin_unlock_irq(&usbhid->inlock);
	usb_kill_urb(usbhid->urbin);
	usb_kill_urb(usbhid->urbout);
	usb_kill_urb(usbhid->urbctrl);
L
Linus Torvalds 已提交
955

J
Jiri Kosina 已提交
956
	del_timer_sync(&usbhid->io_retry);
957
	cancel_work_sync(&usbhid->reset_work);
A
Alan Stern 已提交
958

L
Linus Torvalds 已提交
959 960 961 962
	if (hid->claimed & HID_CLAIMED_INPUT)
		hidinput_disconnect(hid);
	if (hid->claimed & HID_CLAIMED_HIDDEV)
		hiddev_disconnect(hid);
J
Jiri Kosina 已提交
963 964
	if (hid->claimed & HID_CLAIMED_HIDRAW)
		hidraw_disconnect(hid);
L
Linus Torvalds 已提交
965

J
Jiri Kosina 已提交
966 967 968
	usb_free_urb(usbhid->urbin);
	usb_free_urb(usbhid->urbctrl);
	usb_free_urb(usbhid->urbout);
L
Linus Torvalds 已提交
969

970
	hid_free_buffers(hid_to_usb_dev(hid), hid);
971
	kfree(usbhid);
J
Jiri Slaby 已提交
972
	hid_destroy_device(hid);
L
Linus Torvalds 已提交
973 974 975 976 977 978
}

static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
	struct hid_device *hid;
	char path[64];
J
Jiri Slaby 已提交
979
	int i, ret;
L
Linus Torvalds 已提交
980 981
	char *c;

982
	dbg_hid("HID probe called for ifnum %d\n",
L
Linus Torvalds 已提交
983 984 985
			intf->altsetting->desc.bInterfaceNumber);

	if (!(hid = usb_hid_configure(intf)))
986
		return -ENODEV;
L
Linus Torvalds 已提交
987

J
Jiri Kosina 已提交
988
	usbhid_init_reports(hid);
L
Linus Torvalds 已提交
989
	hid_dump_device(hid);
990 991
	if (hid->quirks & HID_QUIRK_RESET_LEDS)
		usbhid_set_leds(hid);
L
Linus Torvalds 已提交
992 993 994 995 996

	if (!hidinput_connect(hid))
		hid->claimed |= HID_CLAIMED_INPUT;
	if (!hiddev_connect(hid))
		hid->claimed |= HID_CLAIMED_HIDDEV;
J
Jiri Kosina 已提交
997 998
	if (!hidraw_connect(hid))
		hid->claimed |= HID_CLAIMED_HIDRAW;
L
Linus Torvalds 已提交
999 1000 1001 1002

	usb_set_intfdata(intf, hid);

	if (!hid->claimed) {
J
Jiri Kosina 已提交
1003
		printk ("HID device claimed by neither input, hiddev nor hidraw\n");
L
Linus Torvalds 已提交
1004
		hid_disconnect(intf);
1005
		return -ENODEV;
L
Linus Torvalds 已提交
1006 1007
	}

1008
	if ((hid->claimed & HID_CLAIMED_INPUT))
J
Jiri Kosina 已提交
1009 1010
		hid_ff_init(hid);

G
Geoff Levand 已提交
1011 1012 1013 1014
	if (hid->quirks & HID_QUIRK_SONY_PS3_CONTROLLER)
		hid_fixup_sony_ps3_controller(interface_to_usbdev(intf),
			intf->cur_altsetting->desc.bInterfaceNumber);

L
Linus Torvalds 已提交
1015 1016 1017 1018
	printk(KERN_INFO);

	if (hid->claimed & HID_CLAIMED_INPUT)
		printk("input");
J
Jiri Kosina 已提交
1019 1020
	if ((hid->claimed & HID_CLAIMED_INPUT) && ((hid->claimed & HID_CLAIMED_HIDDEV) ||
				hid->claimed & HID_CLAIMED_HIDRAW))
L
Linus Torvalds 已提交
1021 1022 1023
		printk(",");
	if (hid->claimed & HID_CLAIMED_HIDDEV)
		printk("hiddev%d", hid->minor);
J
Jiri Kosina 已提交
1024 1025 1026 1027 1028
	if ((hid->claimed & HID_CLAIMED_INPUT) && (hid->claimed & HID_CLAIMED_HIDDEV) &&
			(hid->claimed & HID_CLAIMED_HIDRAW))
		printk(",");
	if (hid->claimed & HID_CLAIMED_HIDRAW)
		printk("hidraw%d", ((struct hidraw*)hid->hidraw)->minor);
L
Linus Torvalds 已提交
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044

	c = "Device";
	for (i = 0; i < hid->maxcollection; i++) {
		if (hid->collection[i].type == HID_COLLECTION_APPLICATION &&
		    (hid->collection[i].usage & HID_USAGE_PAGE) == HID_UP_GENDESK &&
		    (hid->collection[i].usage & 0xffff) < ARRAY_SIZE(hid_types)) {
			c = hid_types[hid->collection[i].usage & 0xffff];
			break;
		}
	}

	usb_make_path(interface_to_usbdev(intf), path, 63);

	printk(": USB HID v%x.%02x %s [%s] on %s\n",
		hid->version >> 8, hid->version & 0xff, c, hid->name, path);

J
Jiri Slaby 已提交
1045 1046 1047 1048 1049 1050
	ret = hid_add_device(hid);
	if (ret) {
		dev_err(&intf->dev, "can't add hid device: %d\n", ret);
		hid_disconnect(intf);
	}
	return ret;
L
Linus Torvalds 已提交
1051 1052
}

1053
static int hid_suspend(struct usb_interface *intf, pm_message_t message)
L
Linus Torvalds 已提交
1054 1055
{
	struct hid_device *hid = usb_get_intfdata (intf);
J
Jiri Kosina 已提交
1056
	struct usbhid_device *usbhid = hid->driver_data;
L
Linus Torvalds 已提交
1057

J
Jiri Kosina 已提交
1058 1059 1060 1061 1062
	spin_lock_irq(&usbhid->inlock);	/* Sync with error handler */
	set_bit(HID_SUSPENDED, &usbhid->iofl);
	spin_unlock_irq(&usbhid->inlock);
	del_timer(&usbhid->io_retry);
	usb_kill_urb(usbhid->urbin);
L
Linus Torvalds 已提交
1063 1064 1065 1066 1067 1068 1069
	dev_dbg(&intf->dev, "suspend\n");
	return 0;
}

static int hid_resume(struct usb_interface *intf)
{
	struct hid_device *hid = usb_get_intfdata (intf);
J
Jiri Kosina 已提交
1070
	struct usbhid_device *usbhid = hid->driver_data;
L
Linus Torvalds 已提交
1071 1072
	int status;

J
Jiri Kosina 已提交
1073 1074
	clear_bit(HID_SUSPENDED, &usbhid->iofl);
	usbhid->retry_delay = 0;
A
Alan Stern 已提交
1075
	status = hid_start_in(hid);
L
Linus Torvalds 已提交
1076 1077 1078 1079
	dev_dbg(&intf->dev, "resume status %d\n", status);
	return status;
}

1080
/* Treat USB reset pretty much the same as suspend/resume */
A
Alan Stern 已提交
1081
static int hid_pre_reset(struct usb_interface *intf)
1082 1083 1084
{
	/* FIXME: What if the interface is already suspended? */
	hid_suspend(intf, PMSG_ON);
A
Alan Stern 已提交
1085
	return 0;
1086 1087
}

A
Alan Stern 已提交
1088 1089
/* Same routine used for post_reset and reset_resume */
static int hid_post_reset(struct usb_interface *intf)
1090 1091 1092 1093 1094 1095
{
	struct usb_device *dev = interface_to_usbdev (intf);

	hid_set_idle(dev, intf->cur_altsetting->desc.bInterfaceNumber, 0, 0);
	/* FIXME: Any more reinitialization needed? */

A
Alan Stern 已提交
1096
	return hid_resume(intf);
1097 1098
}

L
Linus Torvalds 已提交
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
static struct usb_device_id hid_usb_ids [] = {
	{ .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",
	.probe =	hid_probe,
	.disconnect =	hid_disconnect,
	.suspend =	hid_suspend,
	.resume =	hid_resume,
A
Alan Stern 已提交
1113
	.reset_resume =	hid_post_reset,
1114 1115
	.pre_reset =	hid_pre_reset,
	.post_reset =	hid_post_reset,
L
Linus Torvalds 已提交
1116
	.id_table =	hid_usb_ids,
1117
	.supports_autosuspend = 1,
L
Linus Torvalds 已提交
1118 1119
};

J
Jiri Slaby 已提交
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
static const struct hid_device_id hid_usb_table[] = {
	{ HID_USB_DEVICE(HID_ANY_ID, HID_ANY_ID) },
	{ }
};

static struct hid_driver hid_usb_driver = {
	.name = "generic-usb",
	.id_table = hid_usb_table,
};

L
Linus Torvalds 已提交
1130 1131 1132
static int __init hid_init(void)
{
	int retval;
J
Jiri Slaby 已提交
1133 1134 1135
	retval = hid_register_driver(&hid_usb_driver);
	if (retval)
		goto hid_register_fail;
1136 1137 1138
	retval = usbhid_quirks_init(quirks_param);
	if (retval)
		goto usbhid_quirks_init_fail;
L
Linus Torvalds 已提交
1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
	retval = hiddev_init();
	if (retval)
		goto hiddev_init_fail;
	retval = usb_register(&hid_driver);
	if (retval)
		goto usb_register_fail;
	info(DRIVER_VERSION ":" DRIVER_DESC);

	return 0;
usb_register_fail:
	hiddev_exit();
hiddev_init_fail:
1151 1152
	usbhid_quirks_exit();
usbhid_quirks_init_fail:
J
Jiri Slaby 已提交
1153 1154
	hid_unregister_driver(&hid_usb_driver);
hid_register_fail:
L
Linus Torvalds 已提交
1155 1156 1157 1158 1159 1160 1161
	return retval;
}

static void __exit hid_exit(void)
{
	usb_deregister(&hid_driver);
	hiddev_exit();
1162
	usbhid_quirks_exit();
J
Jiri Slaby 已提交
1163
	hid_unregister_driver(&hid_usb_driver);
L
Linus Torvalds 已提交
1164 1165 1166 1167 1168 1169 1170 1171
}

module_init(hid_init);
module_exit(hid_exit);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE(DRIVER_LICENSE);