tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

kernel / drivers / usb / input / hid-core.c
at v2.6.21-rc1 1457 lines 48 kB view raw
1/* 2 * USB HID support for Linux 3 * 4 * Copyright (c) 1999 Andreas Gal 5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz> 6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc 7 * Copyright (c) 2006 Jiri Kosina 8 */ 9 10/* 11 * This program is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License as published by the Free 13 * Software Foundation; either version 2 of the License, or (at your option) 14 * any later version. 15 */ 16 17#include <linux/module.h> 18#include <linux/slab.h> 19#include <linux/init.h> 20#include <linux/kernel.h> 21#include <linux/list.h> 22#include <linux/mm.h> 23#include <linux/smp_lock.h> 24#include <linux/spinlock.h> 25#include <asm/unaligned.h> 26#include <asm/byteorder.h> 27#include <linux/input.h> 28#include <linux/wait.h> 29 30#undef DEBUG 31#undef DEBUG_DATA 32 33#include <linux/usb.h> 34 35#include <linux/hid.h> 36#include <linux/hiddev.h> 37#include <linux/hid-debug.h> 38#include "usbhid.h" 39 40/* 41 * Version Information 42 */ 43 44#define DRIVER_VERSION "v2.6" 45#define DRIVER_AUTHOR "Andreas Gal, Vojtech Pavlik" 46#define DRIVER_DESC "USB HID core driver" 47#define DRIVER_LICENSE "GPL" 48 49static char *hid_types[] = {"Device", "Pointer", "Mouse", "Device", "Joystick", 50 "Gamepad", "Keyboard", "Keypad", "Multi-Axis Controller"}; 51/* 52 * Module parameters. 53 */ 54 55static unsigned int hid_mousepoll_interval; 56module_param_named(mousepoll, hid_mousepoll_interval, uint, 0644); 57MODULE_PARM_DESC(mousepoll, "Polling interval of mice"); 58 59/* 60 * Input submission and I/O error handler. 61 */ 62 63static void hid_io_error(struct hid_device *hid); 64 65/* Start up the input URB */ 66static int hid_start_in(struct hid_device *hid) 67{ 68 unsigned long flags; 69 int rc = 0; 70 struct usbhid_device *usbhid = hid->driver_data; 71 72 spin_lock_irqsave(&usbhid->inlock, flags); 73 if (hid->open > 0 && !test_bit(HID_SUSPENDED, &usbhid->iofl) && 74 !test_and_set_bit(HID_IN_RUNNING, &usbhid->iofl)) { 75 rc = usb_submit_urb(usbhid->urbin, GFP_ATOMIC); 76 if (rc != 0) 77 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 78 } 79 spin_unlock_irqrestore(&usbhid->inlock, flags); 80 return rc; 81} 82 83/* I/O retry timer routine */ 84static void hid_retry_timeout(unsigned long _hid) 85{ 86 struct hid_device *hid = (struct hid_device *) _hid; 87 struct usbhid_device *usbhid = hid->driver_data; 88 89 dev_dbg(&usbhid->intf->dev, "retrying intr urb\n"); 90 if (hid_start_in(hid)) 91 hid_io_error(hid); 92} 93 94/* Workqueue routine to reset the device or clear a halt */ 95static void hid_reset(struct work_struct *work) 96{ 97 struct usbhid_device *usbhid = 98 container_of(work, struct usbhid_device, reset_work); 99 struct hid_device *hid = usbhid->hid; 100 int rc_lock, rc = 0; 101 102 if (test_bit(HID_CLEAR_HALT, &usbhid->iofl)) { 103 dev_dbg(&usbhid->intf->dev, "clear halt\n"); 104 rc = usb_clear_halt(hid_to_usb_dev(hid), usbhid->urbin->pipe); 105 clear_bit(HID_CLEAR_HALT, &usbhid->iofl); 106 hid_start_in(hid); 107 } 108 109 else if (test_bit(HID_RESET_PENDING, &usbhid->iofl)) { 110 dev_dbg(&usbhid->intf->dev, "resetting device\n"); 111 rc = rc_lock = usb_lock_device_for_reset(hid_to_usb_dev(hid), usbhid->intf); 112 if (rc_lock >= 0) { 113 rc = usb_reset_composite_device(hid_to_usb_dev(hid), usbhid->intf); 114 if (rc_lock) 115 usb_unlock_device(hid_to_usb_dev(hid)); 116 } 117 clear_bit(HID_RESET_PENDING, &usbhid->iofl); 118 } 119 120 switch (rc) { 121 case 0: 122 if (!test_bit(HID_IN_RUNNING, &usbhid->iofl)) 123 hid_io_error(hid); 124 break; 125 default: 126 err("can't reset device, %s-%s/input%d, status %d", 127 hid_to_usb_dev(hid)->bus->bus_name, 128 hid_to_usb_dev(hid)->devpath, 129 usbhid->ifnum, rc); 130 /* FALLTHROUGH */ 131 case -EHOSTUNREACH: 132 case -ENODEV: 133 case -EINTR: 134 break; 135 } 136} 137 138/* Main I/O error handler */ 139static void hid_io_error(struct hid_device *hid) 140{ 141 unsigned long flags; 142 struct usbhid_device *usbhid = hid->driver_data; 143 144 spin_lock_irqsave(&usbhid->inlock, flags); 145 146 /* Stop when disconnected */ 147 if (usb_get_intfdata(usbhid->intf) == NULL) 148 goto done; 149 150 /* When an error occurs, retry at increasing intervals */ 151 if (usbhid->retry_delay == 0) { 152 usbhid->retry_delay = 13; /* Then 26, 52, 104, 104, ... */ 153 usbhid->stop_retry = jiffies + msecs_to_jiffies(1000); 154 } else if (usbhid->retry_delay < 100) 155 usbhid->retry_delay *= 2; 156 157 if (time_after(jiffies, usbhid->stop_retry)) { 158 159 /* Retries failed, so do a port reset */ 160 if (!test_and_set_bit(HID_RESET_PENDING, &usbhid->iofl)) { 161 schedule_work(&usbhid->reset_work); 162 goto done; 163 } 164 } 165 166 mod_timer(&usbhid->io_retry, 167 jiffies + msecs_to_jiffies(usbhid->retry_delay)); 168done: 169 spin_unlock_irqrestore(&usbhid->inlock, flags); 170} 171 172/* 173 * Input interrupt completion handler. 174 */ 175 176static void hid_irq_in(struct urb *urb) 177{ 178 struct hid_device *hid = urb->context; 179 struct usbhid_device *usbhid = hid->driver_data; 180 int status; 181 182 switch (urb->status) { 183 case 0: /* success */ 184 usbhid->retry_delay = 0; 185 hid_input_report(urb->context, HID_INPUT_REPORT, 186 urb->transfer_buffer, 187 urb->actual_length, 1); 188 break; 189 case -EPIPE: /* stall */ 190 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 191 set_bit(HID_CLEAR_HALT, &usbhid->iofl); 192 schedule_work(&usbhid->reset_work); 193 return; 194 case -ECONNRESET: /* unlink */ 195 case -ENOENT: 196 case -ESHUTDOWN: /* unplug */ 197 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 198 return; 199 case -EILSEQ: /* protocol error or unplug */ 200 case -EPROTO: /* protocol error or unplug */ 201 case -ETIME: /* protocol error or unplug */ 202 case -ETIMEDOUT: /* Should never happen, but... */ 203 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 204 hid_io_error(hid); 205 return; 206 default: /* error */ 207 warn("input irq status %d received", urb->status); 208 } 209 210 status = usb_submit_urb(urb, GFP_ATOMIC); 211 if (status) { 212 clear_bit(HID_IN_RUNNING, &usbhid->iofl); 213 if (status != -EPERM) { 214 err("can't resubmit intr, %s-%s/input%d, status %d", 215 hid_to_usb_dev(hid)->bus->bus_name, 216 hid_to_usb_dev(hid)->devpath, 217 usbhid->ifnum, status); 218 hid_io_error(hid); 219 } 220 } 221} 222 223static int hid_submit_out(struct hid_device *hid) 224{ 225 struct hid_report *report; 226 struct usbhid_device *usbhid = hid->driver_data; 227 228 report = usbhid->out[usbhid->outtail]; 229 230 hid_output_report(report, usbhid->outbuf); 231 usbhid->urbout->transfer_buffer_length = ((report->size - 1) >> 3) + 1 + (report->id > 0); 232 usbhid->urbout->dev = hid_to_usb_dev(hid); 233 234 dbg("submitting out urb"); 235 236 if (usb_submit_urb(usbhid->urbout, GFP_ATOMIC)) { 237 err("usb_submit_urb(out) failed"); 238 return -1; 239 } 240 241 return 0; 242} 243 244static int hid_submit_ctrl(struct hid_device *hid) 245{ 246 struct hid_report *report; 247 unsigned char dir; 248 int len; 249 struct usbhid_device *usbhid = hid->driver_data; 250 251 report = usbhid->ctrl[usbhid->ctrltail].report; 252 dir = usbhid->ctrl[usbhid->ctrltail].dir; 253 254 len = ((report->size - 1) >> 3) + 1 + (report->id > 0); 255 if (dir == USB_DIR_OUT) { 256 hid_output_report(report, usbhid->ctrlbuf); 257 usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0); 258 usbhid->urbctrl->transfer_buffer_length = len; 259 } else { 260 int maxpacket, padlen; 261 262 usbhid->urbctrl->pipe = usb_rcvctrlpipe(hid_to_usb_dev(hid), 0); 263 maxpacket = usb_maxpacket(hid_to_usb_dev(hid), usbhid->urbctrl->pipe, 0); 264 if (maxpacket > 0) { 265 padlen = (len + maxpacket - 1) / maxpacket; 266 padlen *= maxpacket; 267 if (padlen > usbhid->bufsize) 268 padlen = usbhid->bufsize; 269 } else 270 padlen = 0; 271 usbhid->urbctrl->transfer_buffer_length = padlen; 272 } 273 usbhid->urbctrl->dev = hid_to_usb_dev(hid); 274 275 usbhid->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE | dir; 276 usbhid->cr->bRequest = (dir == USB_DIR_OUT) ? HID_REQ_SET_REPORT : HID_REQ_GET_REPORT; 277 usbhid->cr->wValue = cpu_to_le16(((report->type + 1) << 8) | report->id); 278 usbhid->cr->wIndex = cpu_to_le16(usbhid->ifnum); 279 usbhid->cr->wLength = cpu_to_le16(len); 280 281 dbg("submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u", 282 usbhid->cr->bRequest == HID_REQ_SET_REPORT ? "Set_Report" : "Get_Report", 283 usbhid->cr->wValue, usbhid->cr->wIndex, usbhid->cr->wLength); 284 285 if (usb_submit_urb(usbhid->urbctrl, GFP_ATOMIC)) { 286 err("usb_submit_urb(ctrl) failed"); 287 return -1; 288 } 289 290 return 0; 291} 292 293/* 294 * Output interrupt completion handler. 295 */ 296 297static void hid_irq_out(struct urb *urb) 298{ 299 struct hid_device *hid = urb->context; 300 struct usbhid_device *usbhid = hid->driver_data; 301 unsigned long flags; 302 int unplug = 0; 303 304 switch (urb->status) { 305 case 0: /* success */ 306 break; 307 case -ESHUTDOWN: /* unplug */ 308 unplug = 1; 309 case -EILSEQ: /* protocol error or unplug */ 310 case -EPROTO: /* protocol error or unplug */ 311 case -ECONNRESET: /* unlink */ 312 case -ENOENT: 313 break; 314 default: /* error */ 315 warn("output irq status %d received", urb->status); 316 } 317 318 spin_lock_irqsave(&usbhid->outlock, flags); 319 320 if (unplug) 321 usbhid->outtail = usbhid->outhead; 322 else 323 usbhid->outtail = (usbhid->outtail + 1) & (HID_OUTPUT_FIFO_SIZE - 1); 324 325 if (usbhid->outhead != usbhid->outtail) { 326 if (hid_submit_out(hid)) { 327 clear_bit(HID_OUT_RUNNING, &usbhid->iofl); 328 wake_up(&hid->wait); 329 } 330 spin_unlock_irqrestore(&usbhid->outlock, flags); 331 return; 332 } 333 334 clear_bit(HID_OUT_RUNNING, &usbhid->iofl); 335 spin_unlock_irqrestore(&usbhid->outlock, flags); 336 wake_up(&hid->wait); 337} 338 339/* 340 * Control pipe completion handler. 341 */ 342 343static void hid_ctrl(struct urb *urb) 344{ 345 struct hid_device *hid = urb->context; 346 struct usbhid_device *usbhid = hid->driver_data; 347 unsigned long flags; 348 int unplug = 0; 349 350 spin_lock_irqsave(&usbhid->ctrllock, flags); 351 352 switch (urb->status) { 353 case 0: /* success */ 354 if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN) 355 hid_input_report(urb->context, usbhid->ctrl[usbhid->ctrltail].report->type, 356 urb->transfer_buffer, urb->actual_length, 0); 357 break; 358 case -ESHUTDOWN: /* unplug */ 359 unplug = 1; 360 case -EILSEQ: /* protocol error or unplug */ 361 case -EPROTO: /* protocol error or unplug */ 362 case -ECONNRESET: /* unlink */ 363 case -ENOENT: 364 case -EPIPE: /* report not available */ 365 break; 366 default: /* error */ 367 warn("ctrl urb status %d received", urb->status); 368 } 369 370 if (unplug) 371 usbhid->ctrltail = usbhid->ctrlhead; 372 else 373 usbhid->ctrltail = (usbhid->ctrltail + 1) & (HID_CONTROL_FIFO_SIZE - 1); 374 375 if (usbhid->ctrlhead != usbhid->ctrltail) { 376 if (hid_submit_ctrl(hid)) { 377 clear_bit(HID_CTRL_RUNNING, &usbhid->iofl); 378 wake_up(&hid->wait); 379 } 380 spin_unlock_irqrestore(&usbhid->ctrllock, flags); 381 return; 382 } 383 384 clear_bit(HID_CTRL_RUNNING, &usbhid->iofl); 385 spin_unlock_irqrestore(&usbhid->ctrllock, flags); 386 wake_up(&hid->wait); 387} 388 389void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir) 390{ 391 int head; 392 unsigned long flags; 393 struct usbhid_device *usbhid = hid->driver_data; 394 395 if ((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN) 396 return; 397 398 if (usbhid->urbout && dir == USB_DIR_OUT && report->type == HID_OUTPUT_REPORT) { 399 400 spin_lock_irqsave(&usbhid->outlock, flags); 401 402 if ((head = (usbhid->outhead + 1) & (HID_OUTPUT_FIFO_SIZE - 1)) == usbhid->outtail) { 403 spin_unlock_irqrestore(&usbhid->outlock, flags); 404 warn("output queue full"); 405 return; 406 } 407 408 usbhid->out[usbhid->outhead] = report; 409 usbhid->outhead = head; 410 411 if (!test_and_set_bit(HID_OUT_RUNNING, &usbhid->iofl)) 412 if (hid_submit_out(hid)) 413 clear_bit(HID_OUT_RUNNING, &usbhid->iofl); 414 415 spin_unlock_irqrestore(&usbhid->outlock, flags); 416 return; 417 } 418 419 spin_lock_irqsave(&usbhid->ctrllock, flags); 420 421 if ((head = (usbhid->ctrlhead + 1) & (HID_CONTROL_FIFO_SIZE - 1)) == usbhid->ctrltail) { 422 spin_unlock_irqrestore(&usbhid->ctrllock, flags); 423 warn("control queue full"); 424 return; 425 } 426 427 usbhid->ctrl[usbhid->ctrlhead].report = report; 428 usbhid->ctrl[usbhid->ctrlhead].dir = dir; 429 usbhid->ctrlhead = head; 430 431 if (!test_and_set_bit(HID_CTRL_RUNNING, &usbhid->iofl)) 432 if (hid_submit_ctrl(hid)) 433 clear_bit(HID_CTRL_RUNNING, &usbhid->iofl); 434 435 spin_unlock_irqrestore(&usbhid->ctrllock, flags); 436} 437 438static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) 439{ 440 struct hid_device *hid = dev->private; 441 struct hid_field *field; 442 int offset; 443 444 if (type == EV_FF) 445 return input_ff_event(dev, type, code, value); 446 447 if (type != EV_LED) 448 return -1; 449 450 if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) { 451 warn("event field not found"); 452 return -1; 453 } 454 455 hid_set_field(field, offset, value); 456 usbhid_submit_report(hid, field->report, USB_DIR_OUT); 457 458 return 0; 459} 460 461int usbhid_wait_io(struct hid_device *hid) 462{ 463 struct usbhid_device *usbhid = hid->driver_data; 464 465 if (!wait_event_timeout(hid->wait, (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl) && 466 !test_bit(HID_OUT_RUNNING, &usbhid->iofl)), 467 10*HZ)) { 468 dbg("timeout waiting for ctrl or out queue to clear"); 469 return -1; 470 } 471 472 return 0; 473} 474 475static int hid_set_idle(struct usb_device *dev, int ifnum, int report, int idle) 476{ 477 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 478 HID_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE, (idle << 8) | report, 479 ifnum, NULL, 0, USB_CTRL_SET_TIMEOUT); 480} 481 482static int hid_get_class_descriptor(struct usb_device *dev, int ifnum, 483 unsigned char type, void *buf, int size) 484{ 485 int result, retries = 4; 486 487 memset(buf, 0, size); 488 489 do { 490 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 491 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN, 492 (type << 8), ifnum, buf, size, USB_CTRL_GET_TIMEOUT); 493 retries--; 494 } while (result < size && retries); 495 return result; 496} 497 498int usbhid_open(struct hid_device *hid) 499{ 500 ++hid->open; 501 if (hid_start_in(hid)) 502 hid_io_error(hid); 503 return 0; 504} 505 506void usbhid_close(struct hid_device *hid) 507{ 508 struct usbhid_device *usbhid = hid->driver_data; 509 510 if (!--hid->open) 511 usb_kill_urb(usbhid->urbin); 512} 513 514#define USB_VENDOR_ID_PANJIT 0x134c 515 516#define USB_VENDOR_ID_TURBOX 0x062a 517#define USB_DEVICE_ID_TURBOX_KEYBOARD 0x0201 518#define USB_VENDOR_ID_CIDC 0x1677 519 520/* 521 * Initialize all reports 522 */ 523 524void usbhid_init_reports(struct hid_device *hid) 525{ 526 struct hid_report *report; 527 struct usbhid_device *usbhid = hid->driver_data; 528 int err, ret; 529 530 list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list) 531 usbhid_submit_report(hid, report, USB_DIR_IN); 532 533 list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].report_list, list) 534 usbhid_submit_report(hid, report, USB_DIR_IN); 535 536 err = 0; 537 ret = usbhid_wait_io(hid); 538 while (ret) { 539 err |= ret; 540 if (test_bit(HID_CTRL_RUNNING, &usbhid->iofl)) 541 usb_kill_urb(usbhid->urbctrl); 542 if (test_bit(HID_OUT_RUNNING, &usbhid->iofl)) 543 usb_kill_urb(usbhid->urbout); 544 ret = usbhid_wait_io(hid); 545 } 546 547 if (err) 548 warn("timeout initializing reports"); 549} 550 551#define USB_VENDOR_ID_GTCO 0x078c 552#define USB_DEVICE_ID_GTCO_90 0x0090 553#define USB_DEVICE_ID_GTCO_100 0x0100 554#define USB_DEVICE_ID_GTCO_101 0x0101 555#define USB_DEVICE_ID_GTCO_103 0x0103 556#define USB_DEVICE_ID_GTCO_104 0x0104 557#define USB_DEVICE_ID_GTCO_105 0x0105 558#define USB_DEVICE_ID_GTCO_106 0x0106 559#define USB_DEVICE_ID_GTCO_107 0x0107 560#define USB_DEVICE_ID_GTCO_108 0x0108 561#define USB_DEVICE_ID_GTCO_200 0x0200 562#define USB_DEVICE_ID_GTCO_201 0x0201 563#define USB_DEVICE_ID_GTCO_202 0x0202 564#define USB_DEVICE_ID_GTCO_203 0x0203 565#define USB_DEVICE_ID_GTCO_204 0x0204 566#define USB_DEVICE_ID_GTCO_205 0x0205 567#define USB_DEVICE_ID_GTCO_206 0x0206 568#define USB_DEVICE_ID_GTCO_207 0x0207 569#define USB_DEVICE_ID_GTCO_300 0x0300 570#define USB_DEVICE_ID_GTCO_301 0x0301 571#define USB_DEVICE_ID_GTCO_302 0x0302 572#define USB_DEVICE_ID_GTCO_303 0x0303 573#define USB_DEVICE_ID_GTCO_304 0x0304 574#define USB_DEVICE_ID_GTCO_305 0x0305 575#define USB_DEVICE_ID_GTCO_306 0x0306 576#define USB_DEVICE_ID_GTCO_307 0x0307 577#define USB_DEVICE_ID_GTCO_308 0x0308 578#define USB_DEVICE_ID_GTCO_309 0x0309 579#define USB_DEVICE_ID_GTCO_400 0x0400 580#define USB_DEVICE_ID_GTCO_401 0x0401 581#define USB_DEVICE_ID_GTCO_402 0x0402 582#define USB_DEVICE_ID_GTCO_403 0x0403 583#define USB_DEVICE_ID_GTCO_404 0x0404 584#define USB_DEVICE_ID_GTCO_405 0x0405 585#define USB_DEVICE_ID_GTCO_500 0x0500 586#define USB_DEVICE_ID_GTCO_501 0x0501 587#define USB_DEVICE_ID_GTCO_502 0x0502 588#define USB_DEVICE_ID_GTCO_503 0x0503 589#define USB_DEVICE_ID_GTCO_504 0x0504 590#define USB_DEVICE_ID_GTCO_1000 0x1000 591#define USB_DEVICE_ID_GTCO_1001 0x1001 592#define USB_DEVICE_ID_GTCO_1002 0x1002 593#define USB_DEVICE_ID_GTCO_1003 0x1003 594#define USB_DEVICE_ID_GTCO_1004 0x1004 595#define USB_DEVICE_ID_GTCO_1005 0x1005 596#define USB_DEVICE_ID_GTCO_1006 0x1006 597 598#define USB_VENDOR_ID_WACOM 0x056a 599 600#define USB_VENDOR_ID_ACECAD 0x0460 601#define USB_DEVICE_ID_ACECAD_FLAIR 0x0004 602#define USB_DEVICE_ID_ACECAD_302 0x0008 603 604#define USB_VENDOR_ID_KBGEAR 0x084e 605#define USB_DEVICE_ID_KBGEAR_JAMSTUDIO 0x1001 606 607#define USB_VENDOR_ID_AIPTEK 0x08ca 608#define USB_DEVICE_ID_AIPTEK_01 0x0001 609#define USB_DEVICE_ID_AIPTEK_10 0x0010 610#define USB_DEVICE_ID_AIPTEK_20 0x0020 611#define USB_DEVICE_ID_AIPTEK_21 0x0021 612#define USB_DEVICE_ID_AIPTEK_22 0x0022 613#define USB_DEVICE_ID_AIPTEK_23 0x0023 614#define USB_DEVICE_ID_AIPTEK_24 0x0024 615 616#define USB_VENDOR_ID_GRIFFIN 0x077d 617#define USB_DEVICE_ID_POWERMATE 0x0410 618#define USB_DEVICE_ID_SOUNDKNOB 0x04AA 619 620#define USB_VENDOR_ID_ATEN 0x0557 621#define USB_DEVICE_ID_ATEN_UC100KM 0x2004 622#define USB_DEVICE_ID_ATEN_CS124U 0x2202 623#define USB_DEVICE_ID_ATEN_2PORTKVM 0x2204 624#define USB_DEVICE_ID_ATEN_4PORTKVM 0x2205 625#define USB_DEVICE_ID_ATEN_4PORTKVMC 0x2208 626 627#define USB_VENDOR_ID_TOPMAX 0x0663 628#define USB_DEVICE_ID_TOPMAX_COBRAPAD 0x0103 629 630#define USB_VENDOR_ID_HAPP 0x078b 631#define USB_DEVICE_ID_UGCI_DRIVING 0x0010 632#define USB_DEVICE_ID_UGCI_FLYING 0x0020 633#define USB_DEVICE_ID_UGCI_FIGHTING 0x0030 634 635#define USB_VENDOR_ID_MGE 0x0463 636#define USB_DEVICE_ID_MGE_UPS 0xffff 637#define USB_DEVICE_ID_MGE_UPS1 0x0001 638 639#define USB_VENDOR_ID_ONTRAK 0x0a07 640#define USB_DEVICE_ID_ONTRAK_ADU100 0x0064 641 642#define USB_VENDOR_ID_ESSENTIAL_REALITY 0x0d7f 643#define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100 644 645#define USB_VENDOR_ID_A4TECH 0x09da 646#define USB_DEVICE_ID_A4TECH_WCP32PU 0x0006 647 648#define USB_VENDOR_ID_AASHIMA 0x06d6 649#define USB_DEVICE_ID_AASHIMA_GAMEPAD 0x0025 650#define USB_DEVICE_ID_AASHIMA_PREDATOR 0x0026 651 652#define USB_VENDOR_ID_CYPRESS 0x04b4 653#define USB_DEVICE_ID_CYPRESS_MOUSE 0x0001 654#define USB_DEVICE_ID_CYPRESS_HIDCOM 0x5500 655#define USB_DEVICE_ID_CYPRESS_ULTRAMOUSE 0x7417 656 657#define USB_VENDOR_ID_BERKSHIRE 0x0c98 658#define USB_DEVICE_ID_BERKSHIRE_PCWD 0x1140 659 660#define USB_VENDOR_ID_ALPS 0x0433 661#define USB_DEVICE_ID_IBM_GAMEPAD 0x1101 662 663#define USB_VENDOR_ID_SAITEK 0x06a3 664#define USB_DEVICE_ID_SAITEK_RUMBLEPAD 0xff17 665 666#define USB_VENDOR_ID_NEC 0x073e 667#define USB_DEVICE_ID_NEC_USB_GAME_PAD 0x0301 668 669#define USB_VENDOR_ID_CHIC 0x05fe 670#define USB_DEVICE_ID_CHIC_GAMEPAD 0x0014 671 672#define USB_VENDOR_ID_GLAB 0x06c2 673#define USB_DEVICE_ID_4_PHIDGETSERVO_30 0x0038 674#define USB_DEVICE_ID_1_PHIDGETSERVO_30 0x0039 675#define USB_DEVICE_ID_0_0_4_IF_KIT 0x0040 676#define USB_DEVICE_ID_0_16_16_IF_KIT 0x0044 677#define USB_DEVICE_ID_8_8_8_IF_KIT 0x0045 678#define USB_DEVICE_ID_0_8_7_IF_KIT 0x0051 679#define USB_DEVICE_ID_0_8_8_IF_KIT 0x0053 680#define USB_DEVICE_ID_PHIDGET_MOTORCONTROL 0x0058 681 682#define USB_VENDOR_ID_WISEGROUP 0x0925 683#define USB_DEVICE_ID_1_PHIDGETSERVO_20 0x8101 684#define USB_DEVICE_ID_4_PHIDGETSERVO_20 0x8104 685#define USB_DEVICE_ID_8_8_4_IF_KIT 0x8201 686#define USB_DEVICE_ID_DUAL_USB_JOYPAD 0x8866 687 688#define USB_VENDOR_ID_WISEGROUP_LTD 0x6677 689#define USB_DEVICE_ID_SMARTJOY_DUAL_PLUS 0x8802 690 691#define USB_VENDOR_ID_CODEMERCS 0x07c0 692#define USB_DEVICE_ID_CODEMERCS_IOW40 0x1500 693#define USB_DEVICE_ID_CODEMERCS_IOW24 0x1501 694#define USB_DEVICE_ID_CODEMERCS_IOW48 0x1502 695#define USB_DEVICE_ID_CODEMERCS_IOW28 0x1503 696 697#define USB_VENDOR_ID_DELORME 0x1163 698#define USB_DEVICE_ID_DELORME_EARTHMATE 0x0100 699#define USB_DEVICE_ID_DELORME_EM_LT20 0x0200 700 701#define USB_VENDOR_ID_MCC 0x09db 702#define USB_DEVICE_ID_MCC_PMD1024LS 0x0076 703#define USB_DEVICE_ID_MCC_PMD1208LS 0x007a 704 705#define USB_VENDOR_ID_VERNIER 0x08f7 706#define USB_DEVICE_ID_VERNIER_LABPRO 0x0001 707#define USB_DEVICE_ID_VERNIER_GOTEMP 0x0002 708#define USB_DEVICE_ID_VERNIER_SKIP 0x0003 709#define USB_DEVICE_ID_VERNIER_CYCLOPS 0x0004 710 711#define USB_VENDOR_ID_LD 0x0f11 712#define USB_DEVICE_ID_LD_CASSY 0x1000 713#define USB_DEVICE_ID_LD_POCKETCASSY 0x1010 714#define USB_DEVICE_ID_LD_MOBILECASSY 0x1020 715#define USB_DEVICE_ID_LD_JWM 0x1080 716#define USB_DEVICE_ID_LD_DMMP 0x1081 717#define USB_DEVICE_ID_LD_UMIP 0x1090 718#define USB_DEVICE_ID_LD_XRAY1 0x1100 719#define USB_DEVICE_ID_LD_XRAY2 0x1101 720#define USB_DEVICE_ID_LD_VIDEOCOM 0x1200 721#define USB_DEVICE_ID_LD_COM3LAB 0x2000 722#define USB_DEVICE_ID_LD_TELEPORT 0x2010 723#define USB_DEVICE_ID_LD_NETWORKANALYSER 0x2020 724#define USB_DEVICE_ID_LD_POWERCONTROL 0x2030 725#define USB_DEVICE_ID_LD_MACHINETEST 0x2040 726 727#define USB_VENDOR_ID_APPLE 0x05ac 728#define USB_DEVICE_ID_APPLE_MIGHTYMOUSE 0x0304 729#define USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI 0x020e 730#define USB_DEVICE_ID_APPLE_FOUNTAIN_ISO 0x020f 731#define USB_DEVICE_ID_APPLE_GEYSER_ANSI 0x0214 732#define USB_DEVICE_ID_APPLE_GEYSER_ISO 0x0215 733#define USB_DEVICE_ID_APPLE_GEYSER_JIS 0x0216 734#define USB_DEVICE_ID_APPLE_GEYSER3_ANSI 0x0217 735#define USB_DEVICE_ID_APPLE_GEYSER3_ISO 0x0218 736#define USB_DEVICE_ID_APPLE_GEYSER3_JIS 0x0219 737#define USB_DEVICE_ID_APPLE_GEYSER4_ANSI 0x021a 738#define USB_DEVICE_ID_APPLE_GEYSER4_ISO 0x021b 739#define USB_DEVICE_ID_APPLE_GEYSER4_JIS 0x021c 740#define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY 0x030a 741#define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY 0x030b 742#define USB_DEVICE_ID_APPLE_IR 0x8240 743 744#define USB_VENDOR_ID_CHERRY 0x046a 745#define USB_DEVICE_ID_CHERRY_CYMOTION 0x0023 746 747#define USB_VENDOR_ID_YEALINK 0x6993 748#define USB_DEVICE_ID_YEALINK_P1K_P4K_B2K 0xb001 749 750#define USB_VENDOR_ID_ALCOR 0x058f 751#define USB_DEVICE_ID_ALCOR_USBRS232 0x9720 752 753#define USB_VENDOR_ID_SUN 0x0430 754#define USB_DEVICE_ID_RARITAN_KVM_DONGLE 0xcdab 755 756#define USB_VENDOR_ID_AIRCABLE 0x16CA 757#define USB_DEVICE_ID_AIRCABLE1 0x1502 758 759#define USB_VENDOR_ID_LOGITECH 0x046d 760#define USB_DEVICE_ID_LOGITECH_USB_RECEIVER 0xc101 761 762#define USB_VENDOR_ID_IMATION 0x0718 763#define USB_DEVICE_ID_DISC_STAKKA 0xd000 764 765#define USB_VENDOR_ID_PANTHERLORD 0x0810 766#define USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK 0x0001 767 768#define USB_VENDOR_ID_SONY 0x054c 769#define USB_DEVICE_ID_SONY_PS3_CONTROLLER 0x0268 770 771/* 772 * Alphabetically sorted blacklist by quirk type. 773 */ 774 775static const struct hid_blacklist { 776 __u16 idVendor; 777 __u16 idProduct; 778 unsigned quirks; 779} hid_blacklist[] = { 780 781 { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_01, HID_QUIRK_IGNORE }, 782 { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_10, HID_QUIRK_IGNORE }, 783 { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_20, HID_QUIRK_IGNORE }, 784 { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_21, HID_QUIRK_IGNORE }, 785 { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_22, HID_QUIRK_IGNORE }, 786 { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_23, HID_QUIRK_IGNORE }, 787 { USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24, HID_QUIRK_IGNORE }, 788 { USB_VENDOR_ID_AIRCABLE, USB_DEVICE_ID_AIRCABLE1, HID_QUIRK_IGNORE }, 789 { USB_VENDOR_ID_ALCOR, USB_DEVICE_ID_ALCOR_USBRS232, HID_QUIRK_IGNORE }, 790 { USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD, HID_QUIRK_IGNORE }, 791 { USB_VENDOR_ID_CODEMERCS, USB_DEVICE_ID_CODEMERCS_IOW40, HID_QUIRK_IGNORE }, 792 { USB_VENDOR_ID_CODEMERCS, USB_DEVICE_ID_CODEMERCS_IOW24, HID_QUIRK_IGNORE }, 793 { USB_VENDOR_ID_CODEMERCS, USB_DEVICE_ID_CODEMERCS_IOW48, HID_QUIRK_IGNORE }, 794 { USB_VENDOR_ID_CODEMERCS, USB_DEVICE_ID_CODEMERCS_IOW28, HID_QUIRK_IGNORE }, 795 { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM, HID_QUIRK_IGNORE }, 796 { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE, HID_QUIRK_IGNORE }, 797 { USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE, HID_QUIRK_IGNORE }, 798 { USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20, HID_QUIRK_IGNORE }, 799 { USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5, HID_QUIRK_IGNORE }, 800 { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30, HID_QUIRK_IGNORE }, 801 { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30, HID_QUIRK_IGNORE }, 802 { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_0_4_IF_KIT, HID_QUIRK_IGNORE }, 803 { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_16_16_IF_KIT, HID_QUIRK_IGNORE }, 804 { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_8_8_8_IF_KIT, HID_QUIRK_IGNORE }, 805 { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_7_IF_KIT, HID_QUIRK_IGNORE }, 806 { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_8_IF_KIT, HID_QUIRK_IGNORE }, 807 { USB_VENDOR_ID_GLAB, USB_DEVICE_ID_PHIDGET_MOTORCONTROL, HID_QUIRK_IGNORE }, 808 { USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE, HID_QUIRK_IGNORE }, 809 { USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB, HID_QUIRK_IGNORE }, 810 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_90, HID_QUIRK_IGNORE }, 811 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_100, HID_QUIRK_IGNORE }, 812 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_101, HID_QUIRK_IGNORE }, 813 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_103, HID_QUIRK_IGNORE }, 814 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_104, HID_QUIRK_IGNORE }, 815 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_105, HID_QUIRK_IGNORE }, 816 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_106, HID_QUIRK_IGNORE }, 817 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_107, HID_QUIRK_IGNORE }, 818 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_108, HID_QUIRK_IGNORE }, 819 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_200, HID_QUIRK_IGNORE }, 820 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_201, HID_QUIRK_IGNORE }, 821 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_202, HID_QUIRK_IGNORE }, 822 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_203, HID_QUIRK_IGNORE }, 823 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_204, HID_QUIRK_IGNORE }, 824 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_205, HID_QUIRK_IGNORE }, 825 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_206, HID_QUIRK_IGNORE }, 826 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_207, HID_QUIRK_IGNORE }, 827 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_300, HID_QUIRK_IGNORE }, 828 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_301, HID_QUIRK_IGNORE }, 829 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_302, HID_QUIRK_IGNORE }, 830 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_303, HID_QUIRK_IGNORE }, 831 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_304, HID_QUIRK_IGNORE }, 832 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_305, HID_QUIRK_IGNORE }, 833 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_306, HID_QUIRK_IGNORE }, 834 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_307, HID_QUIRK_IGNORE }, 835 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_308, HID_QUIRK_IGNORE }, 836 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_309, HID_QUIRK_IGNORE }, 837 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_400, HID_QUIRK_IGNORE }, 838 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_401, HID_QUIRK_IGNORE }, 839 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_402, HID_QUIRK_IGNORE }, 840 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_403, HID_QUIRK_IGNORE }, 841 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_404, HID_QUIRK_IGNORE }, 842 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_405, HID_QUIRK_IGNORE }, 843 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_500, HID_QUIRK_IGNORE }, 844 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_501, HID_QUIRK_IGNORE }, 845 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_502, HID_QUIRK_IGNORE }, 846 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_503, HID_QUIRK_IGNORE }, 847 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_504, HID_QUIRK_IGNORE }, 848 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1000, HID_QUIRK_IGNORE }, 849 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1001, HID_QUIRK_IGNORE }, 850 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1002, HID_QUIRK_IGNORE }, 851 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1003, HID_QUIRK_IGNORE }, 852 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004, HID_QUIRK_IGNORE }, 853 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005, HID_QUIRK_IGNORE }, 854 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006, HID_QUIRK_IGNORE }, 855 { USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA, HID_QUIRK_IGNORE }, 856 { USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO, HID_QUIRK_IGNORE }, 857 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY, HID_QUIRK_IGNORE }, 858 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY, HID_QUIRK_IGNORE }, 859 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MOBILECASSY, HID_QUIRK_IGNORE }, 860 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_JWM, HID_QUIRK_IGNORE }, 861 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_DMMP, HID_QUIRK_IGNORE }, 862 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_UMIP, HID_QUIRK_IGNORE }, 863 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY1, HID_QUIRK_IGNORE }, 864 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_XRAY2, HID_QUIRK_IGNORE }, 865 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_VIDEOCOM, HID_QUIRK_IGNORE }, 866 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_COM3LAB, HID_QUIRK_IGNORE }, 867 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_TELEPORT, HID_QUIRK_IGNORE }, 868 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_NETWORKANALYSER, HID_QUIRK_IGNORE }, 869 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POWERCONTROL, HID_QUIRK_IGNORE }, 870 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MACHINETEST, HID_QUIRK_IGNORE }, 871 { USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS, HID_QUIRK_IGNORE }, 872 { USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS, HID_QUIRK_IGNORE }, 873 { USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS, HID_QUIRK_IGNORE }, 874 { USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1, HID_QUIRK_IGNORE }, 875 { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100, HID_QUIRK_IGNORE }, 876 { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 20, HID_QUIRK_IGNORE }, 877 { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 30, HID_QUIRK_IGNORE }, 878 { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 100, HID_QUIRK_IGNORE }, 879 { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 108, HID_QUIRK_IGNORE }, 880 { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 118, HID_QUIRK_IGNORE }, 881 { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 200, HID_QUIRK_IGNORE }, 882 { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300, HID_QUIRK_IGNORE }, 883 { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400, HID_QUIRK_IGNORE }, 884 { USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500, HID_QUIRK_IGNORE }, 885 { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO, HID_QUIRK_IGNORE }, 886 { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP, HID_QUIRK_IGNORE }, 887 { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP, HID_QUIRK_IGNORE }, 888 { USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_CYCLOPS, HID_QUIRK_IGNORE }, 889 { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20, HID_QUIRK_IGNORE }, 890 { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20, HID_QUIRK_IGNORE }, 891 { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT, HID_QUIRK_IGNORE }, 892 { USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K, HID_QUIRK_IGNORE }, 893 894 { USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_FLAIR, HID_QUIRK_IGNORE }, 895 { USB_VENDOR_ID_ACECAD, USB_DEVICE_ID_ACECAD_302, HID_QUIRK_IGNORE }, 896 897 { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM, HID_QUIRK_NOGET }, 898 { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_CS124U, HID_QUIRK_NOGET }, 899 { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET }, 900 { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVM, HID_QUIRK_NOGET }, 901 { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVMC, HID_QUIRK_NOGET }, 902 { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET }, 903 { USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_DUAL_USB_JOYPAD, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT }, 904 { USB_VENDOR_ID_WISEGROUP_LTD, USB_DEVICE_ID_SMARTJOY_DUAL_PLUS, HID_QUIRK_NOGET | HID_QUIRK_MULTI_INPUT }, 905 906 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE, HID_QUIRK_MIGHTYMOUSE | HID_QUIRK_INVERT_HWHEEL }, 907 { USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU, HID_QUIRK_2WHEEL_MOUSE_HACK_7 }, 908 { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE, HID_QUIRK_2WHEEL_MOUSE_HACK_5 }, 909 910 { USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_GAMEPAD, HID_QUIRK_BADPAD }, 911 { USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_PREDATOR, HID_QUIRK_BADPAD }, 912 { USB_VENDOR_ID_ALPS, USB_DEVICE_ID_IBM_GAMEPAD, HID_QUIRK_BADPAD }, 913 { USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD, HID_QUIRK_BADPAD }, 914 { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_DRIVING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT }, 915 { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FLYING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT }, 916 { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FIGHTING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT }, 917 { USB_VENDOR_ID_NEC, USB_DEVICE_ID_NEC_USB_GAME_PAD, HID_QUIRK_BADPAD }, 918 { USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RUMBLEPAD, HID_QUIRK_BADPAD }, 919 { USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD, HID_QUIRK_BADPAD }, 920 921 { USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION, HID_QUIRK_CYMOTION }, 922 923 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE }, 924 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE }, 925 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE }, 926 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_POWERBOOK_ISO_KEYBOARD}, 927 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE }, 928 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE }, 929 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_POWERBOOK_ISO_KEYBOARD}, 930 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE }, 931 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE }, 932 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_POWERBOOK_ISO_KEYBOARD}, 933 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE }, 934 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE }, 935 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE }, 936 937 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IR, HID_QUIRK_IGNORE }, 938 939 { USB_VENDOR_ID_PANJIT, 0x0001, HID_QUIRK_IGNORE }, 940 { USB_VENDOR_ID_PANJIT, 0x0002, HID_QUIRK_IGNORE }, 941 { USB_VENDOR_ID_PANJIT, 0x0003, HID_QUIRK_IGNORE }, 942 { USB_VENDOR_ID_PANJIT, 0x0004, HID_QUIRK_IGNORE }, 943 944 { USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_KEYBOARD, HID_QUIRK_NOGET }, 945 946 { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_USB_RECEIVER, HID_QUIRK_BAD_RELATIVE_KEYS }, 947 948 { USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS }, 949 950 { USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER, HID_QUIRK_SONY_PS3_CONTROLLER }, 951 952 { USB_VENDOR_ID_CIDC, 0x0103, HID_QUIRK_IGNORE }, 953 954 { 0, 0 } 955}; 956 957/* 958 * Traverse the supplied list of reports and find the longest 959 */ 960static void hid_find_max_report(struct hid_device *hid, unsigned int type, int *max) 961{ 962 struct hid_report *report; 963 int size; 964 965 list_for_each_entry(report, &hid->report_enum[type].report_list, list) { 966 size = ((report->size - 1) >> 3) + 1; 967 if (type == HID_INPUT_REPORT && hid->report_enum[type].numbered) 968 size++; 969 if (*max < size) 970 *max = size; 971 } 972} 973 974static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid) 975{ 976 struct usbhid_device *usbhid = hid->driver_data; 977 978 if (!(usbhid->inbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->inbuf_dma))) 979 return -1; 980 if (!(usbhid->outbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->outbuf_dma))) 981 return -1; 982 if (!(usbhid->cr = usb_buffer_alloc(dev, sizeof(*(usbhid->cr)), GFP_ATOMIC, &usbhid->cr_dma))) 983 return -1; 984 if (!(usbhid->ctrlbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->ctrlbuf_dma))) 985 return -1; 986 987 return 0; 988} 989 990static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid) 991{ 992 struct usbhid_device *usbhid = hid->driver_data; 993 994 if (usbhid->inbuf) 995 usb_buffer_free(dev, usbhid->bufsize, usbhid->inbuf, usbhid->inbuf_dma); 996 if (usbhid->outbuf) 997 usb_buffer_free(dev, usbhid->bufsize, usbhid->outbuf, usbhid->outbuf_dma); 998 if (usbhid->cr) 999 usb_buffer_free(dev, sizeof(*(usbhid->cr)), usbhid->cr, usbhid->cr_dma); 1000 if (usbhid->ctrlbuf) 1001 usb_buffer_free(dev, usbhid->bufsize, usbhid->ctrlbuf, usbhid->ctrlbuf_dma); 1002} 1003 1004/* 1005 * Cherry Cymotion keyboard have an invalid HID report descriptor, 1006 * that needs fixing before we can parse it. 1007 */ 1008 1009static void hid_fixup_cymotion_descriptor(char *rdesc, int rsize) 1010{ 1011 if (rsize >= 17 && rdesc[11] == 0x3c && rdesc[12] == 0x02) { 1012 info("Fixing up Cherry Cymotion report descriptor"); 1013 rdesc[11] = rdesc[16] = 0xff; 1014 rdesc[12] = rdesc[17] = 0x03; 1015 } 1016} 1017 1018/* 1019 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller 1020 * to "operational". Without this, the ps3 controller will not report any 1021 * events. 1022 */ 1023static void hid_fixup_sony_ps3_controller(struct usb_device *dev, int ifnum) 1024{ 1025 int result; 1026 char *buf = kmalloc(18, GFP_KERNEL); 1027 1028 if (!buf) 1029 return; 1030 1031 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 1032 HID_REQ_GET_REPORT, 1033 USB_DIR_IN | USB_TYPE_CLASS | 1034 USB_RECIP_INTERFACE, 1035 (3 << 8) | 0xf2, ifnum, buf, 17, 1036 USB_CTRL_GET_TIMEOUT); 1037 1038 if (result < 0) 1039 err("%s failed: %d\n", __func__, result); 1040 1041 kfree(buf); 1042} 1043 1044static struct hid_device *usb_hid_configure(struct usb_interface *intf) 1045{ 1046 struct usb_host_interface *interface = intf->cur_altsetting; 1047 struct usb_device *dev = interface_to_usbdev (intf); 1048 struct hid_descriptor *hdesc; 1049 struct hid_device *hid; 1050 unsigned quirks = 0, rsize = 0; 1051 char *rdesc; 1052 int n, len, insize = 0; 1053 struct usbhid_device *usbhid; 1054 1055 /* Ignore all Wacom devices */ 1056 if (le16_to_cpu(dev->descriptor.idVendor) == USB_VENDOR_ID_WACOM) 1057 return NULL; 1058 1059 for (n = 0; hid_blacklist[n].idVendor; n++) 1060 if ((hid_blacklist[n].idVendor == le16_to_cpu(dev->descriptor.idVendor)) && 1061 (hid_blacklist[n].idProduct == le16_to_cpu(dev->descriptor.idProduct))) 1062 quirks = hid_blacklist[n].quirks; 1063 1064 /* Many keyboards and mice don't like to be polled for reports, 1065 * so we will always set the HID_QUIRK_NOGET flag for them. */ 1066 if (interface->desc.bInterfaceSubClass == USB_INTERFACE_SUBCLASS_BOOT) { 1067 if (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_KEYBOARD || 1068 interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE) 1069 quirks |= HID_QUIRK_NOGET; 1070 } 1071 1072 if (quirks & HID_QUIRK_IGNORE) 1073 return NULL; 1074 1075 if ((quirks & HID_QUIRK_IGNORE_MOUSE) && 1076 (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE)) 1077 return NULL; 1078 1079 1080 if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) && 1081 (!interface->desc.bNumEndpoints || 1082 usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) { 1083 dbg("class descriptor not present\n"); 1084 return NULL; 1085 } 1086 1087 for (n = 0; n < hdesc->bNumDescriptors; n++) 1088 if (hdesc->desc[n].bDescriptorType == HID_DT_REPORT) 1089 rsize = le16_to_cpu(hdesc->desc[n].wDescriptorLength); 1090 1091 if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) { 1092 dbg("weird size of report descriptor (%u)", rsize); 1093 return NULL; 1094 } 1095 1096 if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) { 1097 dbg("couldn't allocate rdesc memory"); 1098 return NULL; 1099 } 1100 1101 hid_set_idle(dev, interface->desc.bInterfaceNumber, 0, 0); 1102 1103 if ((n = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber, HID_DT_REPORT, rdesc, rsize)) < 0) { 1104 dbg("reading report descriptor failed"); 1105 kfree(rdesc); 1106 return NULL; 1107 } 1108 1109 if ((quirks & HID_QUIRK_CYMOTION)) 1110 hid_fixup_cymotion_descriptor(rdesc, rsize); 1111 1112#ifdef DEBUG_DATA 1113 printk(KERN_DEBUG __FILE__ ": report descriptor (size %u, read %d) = ", rsize, n); 1114 for (n = 0; n < rsize; n++) 1115 printk(" %02x", (unsigned char) rdesc[n]); 1116 printk("\n"); 1117#endif 1118 1119 if (!(hid = hid_parse_report(rdesc, n))) { 1120 dbg("parsing report descriptor failed"); 1121 kfree(rdesc); 1122 return NULL; 1123 } 1124 1125 kfree(rdesc); 1126 hid->quirks = quirks; 1127 1128 if (!(usbhid = kzalloc(sizeof(struct usbhid_device), GFP_KERNEL))) 1129 goto fail; 1130 1131 hid->driver_data = usbhid; 1132 usbhid->hid = hid; 1133 1134 usbhid->bufsize = HID_MIN_BUFFER_SIZE; 1135 hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize); 1136 hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize); 1137 hid_find_max_report(hid, HID_FEATURE_REPORT, &usbhid->bufsize); 1138 1139 if (usbhid->bufsize > HID_MAX_BUFFER_SIZE) 1140 usbhid->bufsize = HID_MAX_BUFFER_SIZE; 1141 1142 hid_find_max_report(hid, HID_INPUT_REPORT, &insize); 1143 1144 if (insize > HID_MAX_BUFFER_SIZE) 1145 insize = HID_MAX_BUFFER_SIZE; 1146 1147 if (hid_alloc_buffers(dev, hid)) { 1148 hid_free_buffers(dev, hid); 1149 goto fail; 1150 } 1151 1152 for (n = 0; n < interface->desc.bNumEndpoints; n++) { 1153 1154 struct usb_endpoint_descriptor *endpoint; 1155 int pipe; 1156 int interval; 1157 1158 endpoint = &interface->endpoint[n].desc; 1159 if ((endpoint->bmAttributes & 3) != 3) /* Not an interrupt endpoint */ 1160 continue; 1161 1162 interval = endpoint->bInterval; 1163 1164 /* Change the polling interval of mice. */ 1165 if (hid->collection->usage == HID_GD_MOUSE && hid_mousepoll_interval > 0) 1166 interval = hid_mousepoll_interval; 1167 1168 if (usb_endpoint_dir_in(endpoint)) { 1169 if (usbhid->urbin) 1170 continue; 1171 if (!(usbhid->urbin = usb_alloc_urb(0, GFP_KERNEL))) 1172 goto fail; 1173 pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress); 1174 usb_fill_int_urb(usbhid->urbin, dev, pipe, usbhid->inbuf, insize, 1175 hid_irq_in, hid, interval); 1176 usbhid->urbin->transfer_dma = usbhid->inbuf_dma; 1177 usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1178 } else { 1179 if (usbhid->urbout) 1180 continue; 1181 if (!(usbhid->urbout = usb_alloc_urb(0, GFP_KERNEL))) 1182 goto fail; 1183 pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress); 1184 usb_fill_int_urb(usbhid->urbout, dev, pipe, usbhid->outbuf, 0, 1185 hid_irq_out, hid, interval); 1186 usbhid->urbout->transfer_dma = usbhid->outbuf_dma; 1187 usbhid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1188 } 1189 } 1190 1191 if (!usbhid->urbin) { 1192 err("couldn't find an input interrupt endpoint"); 1193 goto fail; 1194 } 1195 1196 init_waitqueue_head(&hid->wait); 1197 1198 INIT_WORK(&usbhid->reset_work, hid_reset); 1199 setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid); 1200 1201 spin_lock_init(&usbhid->inlock); 1202 spin_lock_init(&usbhid->outlock); 1203 spin_lock_init(&usbhid->ctrllock); 1204 1205 hid->version = le16_to_cpu(hdesc->bcdHID); 1206 hid->country = hdesc->bCountryCode; 1207 hid->dev = &intf->dev; 1208 usbhid->intf = intf; 1209 usbhid->ifnum = interface->desc.bInterfaceNumber; 1210 1211 hid->name[0] = 0; 1212 1213 if (dev->manufacturer) 1214 strlcpy(hid->name, dev->manufacturer, sizeof(hid->name)); 1215 1216 if (dev->product) { 1217 if (dev->manufacturer) 1218 strlcat(hid->name, " ", sizeof(hid->name)); 1219 strlcat(hid->name, dev->product, sizeof(hid->name)); 1220 } 1221 1222 if (!strlen(hid->name)) 1223 snprintf(hid->name, sizeof(hid->name), "HID %04x:%04x", 1224 le16_to_cpu(dev->descriptor.idVendor), 1225 le16_to_cpu(dev->descriptor.idProduct)); 1226 1227 hid->bus = BUS_USB; 1228 hid->vendor = dev->descriptor.idVendor; 1229 hid->product = dev->descriptor.idProduct; 1230 1231 usb_make_path(dev, hid->phys, sizeof(hid->phys)); 1232 strlcat(hid->phys, "/input", sizeof(hid->phys)); 1233 len = strlen(hid->phys); 1234 if (len < sizeof(hid->phys) - 1) 1235 snprintf(hid->phys + len, sizeof(hid->phys) - len, 1236 "%d", intf->altsetting[0].desc.bInterfaceNumber); 1237 1238 if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0) 1239 hid->uniq[0] = 0; 1240 1241 usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL); 1242 if (!usbhid->urbctrl) 1243 goto fail; 1244 1245 usb_fill_control_urb(usbhid->urbctrl, dev, 0, (void *) usbhid->cr, 1246 usbhid->ctrlbuf, 1, hid_ctrl, hid); 1247 usbhid->urbctrl->setup_dma = usbhid->cr_dma; 1248 usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma; 1249 usbhid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP); 1250 hid->hidinput_input_event = usb_hidinput_input_event; 1251 hid->hid_open = usbhid_open; 1252 hid->hid_close = usbhid_close; 1253#ifdef CONFIG_USB_HIDDEV 1254 hid->hiddev_hid_event = hiddev_hid_event; 1255 hid->hiddev_report_event = hiddev_report_event; 1256#endif 1257 return hid; 1258 1259fail: 1260 usb_free_urb(usbhid->urbin); 1261 usb_free_urb(usbhid->urbout); 1262 usb_free_urb(usbhid->urbctrl); 1263 hid_free_buffers(dev, hid); 1264 hid_free_device(hid); 1265 1266 return NULL; 1267} 1268 1269static void hid_disconnect(struct usb_interface *intf) 1270{ 1271 struct hid_device *hid = usb_get_intfdata (intf); 1272 struct usbhid_device *usbhid; 1273 1274 if (!hid) 1275 return; 1276 1277 usbhid = hid->driver_data; 1278 1279 spin_lock_irq(&usbhid->inlock); /* Sync with error handler */ 1280 usb_set_intfdata(intf, NULL); 1281 spin_unlock_irq(&usbhid->inlock); 1282 usb_kill_urb(usbhid->urbin); 1283 usb_kill_urb(usbhid->urbout); 1284 usb_kill_urb(usbhid->urbctrl); 1285 1286 del_timer_sync(&usbhid->io_retry); 1287 flush_scheduled_work(); 1288 1289 if (hid->claimed & HID_CLAIMED_INPUT) 1290 hidinput_disconnect(hid); 1291 if (hid->claimed & HID_CLAIMED_HIDDEV) 1292 hiddev_disconnect(hid); 1293 1294 usb_free_urb(usbhid->urbin); 1295 usb_free_urb(usbhid->urbctrl); 1296 usb_free_urb(usbhid->urbout); 1297 1298 hid_free_buffers(hid_to_usb_dev(hid), hid); 1299 hid_free_device(hid); 1300} 1301 1302static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id) 1303{ 1304 struct hid_device *hid; 1305 char path[64]; 1306 int i; 1307 char *c; 1308 1309 dbg("HID probe called for ifnum %d", 1310 intf->altsetting->desc.bInterfaceNumber); 1311 1312 if (!(hid = usb_hid_configure(intf))) 1313 return -ENODEV; 1314 1315 usbhid_init_reports(hid); 1316 hid_dump_device(hid); 1317 1318 if (!hidinput_connect(hid)) 1319 hid->claimed |= HID_CLAIMED_INPUT; 1320 if (!hiddev_connect(hid)) 1321 hid->claimed |= HID_CLAIMED_HIDDEV; 1322 1323 usb_set_intfdata(intf, hid); 1324 1325 if (!hid->claimed) { 1326 printk ("HID device not claimed by input or hiddev\n"); 1327 hid_disconnect(intf); 1328 return -ENODEV; 1329 } 1330 1331 if ((hid->claimed & HID_CLAIMED_INPUT)) 1332 hid_ff_init(hid); 1333 1334 if (hid->quirks & HID_QUIRK_SONY_PS3_CONTROLLER) 1335 hid_fixup_sony_ps3_controller(interface_to_usbdev(intf), 1336 intf->cur_altsetting->desc.bInterfaceNumber); 1337 1338 printk(KERN_INFO); 1339 1340 if (hid->claimed & HID_CLAIMED_INPUT) 1341 printk("input"); 1342 if (hid->claimed == (HID_CLAIMED_INPUT | HID_CLAIMED_HIDDEV)) 1343 printk(","); 1344 if (hid->claimed & HID_CLAIMED_HIDDEV) 1345 printk("hiddev%d", hid->minor); 1346 1347 c = "Device"; 1348 for (i = 0; i < hid->maxcollection; i++) { 1349 if (hid->collection[i].type == HID_COLLECTION_APPLICATION && 1350 (hid->collection[i].usage & HID_USAGE_PAGE) == HID_UP_GENDESK && 1351 (hid->collection[i].usage & 0xffff) < ARRAY_SIZE(hid_types)) { 1352 c = hid_types[hid->collection[i].usage & 0xffff]; 1353 break; 1354 } 1355 } 1356 1357 usb_make_path(interface_to_usbdev(intf), path, 63); 1358 1359 printk(": USB HID v%x.%02x %s [%s] on %s\n", 1360 hid->version >> 8, hid->version & 0xff, c, hid->name, path); 1361 1362 return 0; 1363} 1364 1365static int hid_suspend(struct usb_interface *intf, pm_message_t message) 1366{ 1367 struct hid_device *hid = usb_get_intfdata (intf); 1368 struct usbhid_device *usbhid = hid->driver_data; 1369 1370 spin_lock_irq(&usbhid->inlock); /* Sync with error handler */ 1371 set_bit(HID_SUSPENDED, &usbhid->iofl); 1372 spin_unlock_irq(&usbhid->inlock); 1373 del_timer(&usbhid->io_retry); 1374 usb_kill_urb(usbhid->urbin); 1375 dev_dbg(&intf->dev, "suspend\n"); 1376 return 0; 1377} 1378 1379static int hid_resume(struct usb_interface *intf) 1380{ 1381 struct hid_device *hid = usb_get_intfdata (intf); 1382 struct usbhid_device *usbhid = hid->driver_data; 1383 int status; 1384 1385 clear_bit(HID_SUSPENDED, &usbhid->iofl); 1386 usbhid->retry_delay = 0; 1387 status = hid_start_in(hid); 1388 dev_dbg(&intf->dev, "resume status %d\n", status); 1389 return status; 1390} 1391 1392/* Treat USB reset pretty much the same as suspend/resume */ 1393static void hid_pre_reset(struct usb_interface *intf) 1394{ 1395 /* FIXME: What if the interface is already suspended? */ 1396 hid_suspend(intf, PMSG_ON); 1397} 1398 1399static void hid_post_reset(struct usb_interface *intf) 1400{ 1401 struct usb_device *dev = interface_to_usbdev (intf); 1402 1403 hid_set_idle(dev, intf->cur_altsetting->desc.bInterfaceNumber, 0, 0); 1404 /* FIXME: Any more reinitialization needed? */ 1405 1406 hid_resume(intf); 1407} 1408 1409static struct usb_device_id hid_usb_ids [] = { 1410 { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS, 1411 .bInterfaceClass = USB_INTERFACE_CLASS_HID }, 1412 { } /* Terminating entry */ 1413}; 1414 1415MODULE_DEVICE_TABLE (usb, hid_usb_ids); 1416 1417static struct usb_driver hid_driver = { 1418 .name = "usbhid", 1419 .probe = hid_probe, 1420 .disconnect = hid_disconnect, 1421 .suspend = hid_suspend, 1422 .resume = hid_resume, 1423 .pre_reset = hid_pre_reset, 1424 .post_reset = hid_post_reset, 1425 .id_table = hid_usb_ids, 1426}; 1427 1428static int __init hid_init(void) 1429{ 1430 int retval; 1431 retval = hiddev_init(); 1432 if (retval) 1433 goto hiddev_init_fail; 1434 retval = usb_register(&hid_driver); 1435 if (retval) 1436 goto usb_register_fail; 1437 info(DRIVER_VERSION ":" DRIVER_DESC); 1438 1439 return 0; 1440usb_register_fail: 1441 hiddev_exit(); 1442hiddev_init_fail: 1443 return retval; 1444} 1445 1446static void __exit hid_exit(void) 1447{ 1448 usb_deregister(&hid_driver); 1449 hiddev_exit(); 1450} 1451 1452module_init(hid_init); 1453module_exit(hid_exit); 1454 1455MODULE_AUTHOR(DRIVER_AUTHOR); 1456MODULE_DESCRIPTION(DRIVER_DESC); 1457MODULE_LICENSE(DRIVER_LICENSE);