#define USB_DEVICE_ID_ATEN_4PORTKVMC   0x2208#define USB_VENDOR_ID_TOPMAX           0x0663#define USB_DEVICE_ID_TOPMAX_COBRAPAD  0x0103#define USB_VENDOR_ID_HAPP             0x078b#define USB_DEVICE_ID_UGCI_DRIVING     0x0010#define USB_DEVICE_ID_UGCI_FLYING      0x0020#define USB_DEVICE_ID_UGCI_FIGHTING    0x0030#define USB_VENDOR_ID_MGE              0x0463#define USB_DEVICE_ID_MGE_UPS          0xffff#define USB_DEVICE_ID_MGE_UPS1         0x0001#define USB_VENDOR_ID_ONTRAK		0x0a07#define USB_DEVICE_ID_ONTRAK_ADU100	0x0064#define USB_VENDOR_ID_TANGTOP          0x0d3d#define USB_DEVICE_ID_TANGTOP_USBPS2   0x0001#define USB_VENDOR_ID_ESSENTIAL_REALITY	0x0d7f#define USB_DEVICE_ID_ESSENTIAL_REALITY_P5	0x0100#define USB_VENDOR_ID_A4TECH		0x09DA#define USB_DEVICE_ID_A4TECH_WCP32PU	0x0006#define USB_VENDOR_ID_CYPRESS		0x04b4#define USB_DEVICE_ID_CYPRESS_MOUSE	0x0001#define USB_VENDOR_ID_BERKSHIRE		0x0c98#define USB_DEVICE_ID_BERKSHIRE_PCWD	0x1140#define USB_VENDOR_ID_ALPS		0x0433#define USB_DEVICE_ID_IBM_GAMEPAD	0x1101#define USB_VENDOR_ID_SAITEK		0x06a3#define USB_DEVICE_ID_SAITEK_RUMBLEPAD	0xff17#define USB_VENDOR_ID_NEC		0x073e#define USB_DEVICE_ID_NEC_USB_GAME_PAD	0x0301#define USB_VENDOR_ID_CHIC		0x05fe#define USB_DEVICE_ID_CHIC_GAMEPAD	0x0014#define USB_VENDOR_ID_GLAB		0x06c2#define USB_DEVICE_ID_4_PHIDGETSERVO_30	0x0038#define USB_DEVICE_ID_1_PHIDGETSERVO_30	0x0039#define USB_DEVICE_ID_8_8_8_IF_KIT	0x0045#define USB_DEVICE_ID_0_0_4_IF_KIT	0x0040#define USB_DEVICE_ID_0_8_8_IF_KIT	0x0053#define USB_VENDOR_ID_WISEGROUP		0x0925#define USB_DEVICE_ID_1_PHIDGETSERVO_20	0x8101#define USB_DEVICE_ID_4_PHIDGETSERVO_20	0x8104static struct hid_blacklist {	__u16 idVendor;	__u16 idProduct;	unsigned quirks;} hid_blacklist[] = {	{ USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_01, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_10, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_20, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_21, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_22, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_23, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_POWERMATE, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_GRIFFIN, USB_DEVICE_ID_SOUNDKNOB, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_MGE, USB_DEVICE_ID_MGE_UPS1, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 100, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 200, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 300, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 400, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_ONTRAK, USB_DEVICE_ID_ONTRAK_ADU100 + 500, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PENPARTNER, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE + 1, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE + 2, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE + 3, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_GRAPHIRE + 4, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS + 1, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS + 2, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS + 3, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS + 4, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 1, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 2, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 3, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 4, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PL + 5, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 1, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 2, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 3, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 4, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 5, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_INTUOS2 + 7, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_VOLITO, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WACOM, USB_DEVICE_ID_WACOM_PTU, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_GLAB, USB_DEVICE_ID_4_PHIDGETSERVO_30, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_GLAB, USB_DEVICE_ID_1_PHIDGETSERVO_30, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_GLAB, USB_DEVICE_ID_8_8_8_IF_KIT, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_0_4_IF_KIT, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_GLAB, USB_DEVICE_ID_0_8_8_IF_KIT, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_4_PHIDGETSERVO_20, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20, HID_QUIRK_IGNORE },	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM, HID_QUIRK_NOGET },	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_CS124U, HID_QUIRK_NOGET },	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_2PORTKVM, HID_QUIRK_NOGET },	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVM, HID_QUIRK_NOGET },	{ USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_4PORTKVMC, HID_QUIRK_NOGET },	{ USB_VENDOR_ID_TANGTOP, USB_DEVICE_ID_TANGTOP_USBPS2, HID_QUIRK_NOGET },	{ USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU, HID_QUIRK_2WHEEL_MOUSE_HACK_BACK },	{ USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE, HID_QUIRK_2WHEEL_MOUSE_HACK_EXTRA },	{ USB_VENDOR_ID_ALPS, USB_DEVICE_ID_IBM_GAMEPAD, HID_QUIRK_BADPAD },	{ USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD, HID_QUIRK_BADPAD },	{ USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_DRIVING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },	{ USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FLYING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },	{ USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FIGHTING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },	{ USB_VENDOR_ID_NEC, USB_DEVICE_ID_NEC_USB_GAME_PAD, HID_QUIRK_BADPAD },	{ USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RUMBLEPAD, HID_QUIRK_BADPAD },	{ USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD, HID_QUIRK_BADPAD },	{ 0, 0 }};static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid){	if (!(hid->inbuf = usb_buffer_alloc(dev, HID_BUFFER_SIZE, SLAB_ATOMIC, &hid->inbuf_dma)))		return -1;	if (!(hid->outbuf = usb_buffer_alloc(dev, HID_BUFFER_SIZE, SLAB_ATOMIC, &hid->outbuf_dma)))		return -1;	if (!(hid->cr = usb_buffer_alloc(dev, sizeof(*(hid->cr)), SLAB_ATOMIC, &hid->cr_dma)))		return -1;	if (!(hid->ctrlbuf = usb_buffer_alloc(dev, HID_BUFFER_SIZE, SLAB_ATOMIC, &hid->ctrlbuf_dma)))		return -1;	return 0;}static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid){	if (hid->inbuf)		usb_buffer_free(dev, HID_BUFFER_SIZE, hid->inbuf, hid->inbuf_dma);	if (hid->outbuf)		usb_buffer_free(dev, HID_BUFFER_SIZE, hid->outbuf, hid->outbuf_dma);	if (hid->cr)		usb_buffer_free(dev, sizeof(*(hid->cr)), hid->cr, hid->cr_dma);	if (hid->ctrlbuf)		usb_buffer_free(dev, HID_BUFFER_SIZE, hid->ctrlbuf, hid->ctrlbuf_dma);}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;	unsigned quirks = 0, rsize = 0;	char *buf, *rdesc;	int n;	for (n = 0; hid_blacklist[n].idVendor; n++)		if ((hid_blacklist[n].idVendor == dev->descriptor.idVendor) &&			(hid_blacklist[n].idProduct == dev->descriptor.idProduct))				quirks = hid_blacklist[n].quirks;	if (quirks & HID_QUIRK_IGNORE)		return NULL;	if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) && ((!interface->desc.bNumEndpoints) ||		usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {			dbg("class descriptor not present\n");			return NULL;	}	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) {		dbg("weird size of report descriptor (%u)", rsize);		return NULL;	}	if (!(rdesc = kmalloc(rsize, GFP_KERNEL))) {		dbg("couldn't allocate rdesc memory");		return NULL;	}	if ((n = hid_get_class_descriptor(dev, interface->desc.bInterfaceNumber, HID_DT_REPORT, rdesc, rsize)) < 0) {		dbg("reading report descriptor failed");		kfree(rdesc);		return NULL;	}#ifdef DEBUG_DATA	printk(KERN_DEBUG __FILE__ ": report descriptor (size %u, read %d) = ", rsize, n);	for (n = 0; n < rsize; n++)		printk(" %02x", (unsigned char) rdesc[n]);	printk("\n");#endif	if (!(hid = hid_parse_report(rdesc, rsize))) {		dbg("parsing report descriptor failed");		kfree(rdesc);		return NULL;	}	kfree(rdesc);	hid->quirks = quirks;	if (hid_alloc_buffers(dev, hid)) {		hid_free_buffers(dev, hid);		goto fail;	}	for (n = 0; n < interface->desc.bNumEndpoints; n++) {		struct usb_endpoint_descriptor *endpoint;		int pipe;		endpoint = &interface->endpoint[n].desc;		if ((endpoint->bmAttributes & 3) != 3)		/* Not an interrupt endpoint */			continue;		if (endpoint->bEndpointAddress & USB_DIR_IN) {			int len;			if (hid->urbin)				continue;			if (!(hid->urbin = usb_alloc_urb(0, GFP_KERNEL)))				goto fail;			pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);			len = usb_maxpacket(dev, pipe, 0);			if (len > HID_BUFFER_SIZE)				len = HID_BUFFER_SIZE;			usb_fill_int_urb(hid->urbin, dev, pipe, hid->inbuf, len,					 hid_irq_in, hid, endpoint->bInterval);			hid->urbin->transfer_dma = hid->inbuf_dma;			hid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;		} else {			if (hid->urbout)				continue;			if (!(hid->urbout = usb_alloc_urb(0, GFP_KERNEL)))				goto fail;			pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress);			usb_fill_int_urb(hid->urbout, dev, pipe, hid->outbuf, 0,					  hid_irq_out, hid, 1);			hid->urbout->transfer_dma = hid->outbuf_dma;			hid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;		}	}	if (!hid->urbin) {		err("couldn't find an input interrupt endpoint");		goto fail;	}	init_waitqueue_head(&hid->wait);		hid->outlock = SPIN_LOCK_UNLOCKED;	hid->ctrllock = SPIN_LOCK_UNLOCKED;	hid->version = le16_to_cpu(hdesc->bcdHID);	hid->country = hdesc->bCountryCode;	hid->dev = dev;	hid->intf = intf;	hid->ifnum = interface->desc.bInterfaceNumber;	hid->name[0] = 0;	if (!(buf = kmalloc(64, GFP_KERNEL)))		goto fail;	if (usb_string(dev, dev->descriptor.iManufacturer, buf, 64) > 0) {		strcat(hid->name, buf);		if (usb_string(dev, dev->descriptor.iProduct, buf, 64) > 0)			snprintf(hid->name, 64, "%s %s", hid->name, buf);	} else if (usb_string(dev, dev->descriptor.iProduct, buf, 128) > 0) {			snprintf(hid->name, 128, "%s", buf);	} else		snprintf(hid->name, 128, "%04x:%04x", dev->descriptor.idVendor, dev->descriptor.idProduct);	usb_make_path(dev, buf, 64);	snprintf(hid->phys, 64, "%s/input%d", buf,			intf->altsetting[0].desc.bInterfaceNumber);	if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)		hid->uniq[0] = 0;	kfree(buf);	hid->urbctrl = usb_alloc_urb(0, GFP_KERNEL);	if (!hid->urbctrl)		goto fail;	usb_fill_control_urb(hid->urbctrl, dev, 0, (void *) hid->cr,			     hid->ctrlbuf, 1, hid_ctrl, hid);	hid->urbctrl->setup_dma = hid->cr_dma;	hid->urbctrl->transfer_dma = hid->ctrlbuf_dma;	hid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP				| URB_NO_SETUP_DMA_MAP);	return hid;fail:	if (hid->urbin)		usb_free_urb(hid->urbin);	if (hid->urbout)		usb_free_urb(hid->urbout);	if (hid->urbctrl)		usb_free_urb(hid->urbctrl);	hid_free_buffers(dev, hid);	hid_free_device(hid);	return NULL;}static void hid_disconnect(struct usb_interface *intf){	struct hid_device *hid = usb_get_intfdata (intf);	if (!hid)		return;	usb_set_intfdata(intf, NULL);	usb_unlink_urb(hid->urbin);	usb_unlink_urb(hid->urbout);	usb_unlink_urb(hid->urbctrl);	if (hid->claimed & HID_CLAIMED_INPUT)		hidinput_disconnect(hid);	if (hid->claimed & HID_CLAIMED_HIDDEV)		hiddev_disconnect(hid);	usb_free_urb(hid->urbin);	usb_free_urb(hid->urbctrl);	if (hid->urbout)		usb_free_urb(hid->urbout);	hid_free_buffers(hid->dev, hid);	hid_free_device(hid);}static int hid_probe (struct usb_interface *intf, const struct usb_device_id *id){	struct hid_device *hid;	char path[64];	int i;	char *c;	dbg("HID probe called for ifnum %d",			intf->altsetting->desc.bInterfaceNumber);	if (!(hid = usb_hid_configure(intf)))		return -EIO;	hid_init_reports(hid);	hid_dump_device(hid);	if (!hidinput_connect(hid))		hid->claimed |= HID_CLAIMED_INPUT;	if (!hiddev_connect(hid))		hid->claimed |= HID_CLAIMED_HIDDEV;	usb_set_intfdata(intf, hid);	if (!hid->claimed) {		printk ("HID device not claimed by input or hiddev\n");		hid_disconnect(intf);		return -EIO;	}	printk(KERN_INFO);	if (hid->claimed & HID_CLAIMED_INPUT)		printk("input");	if (hid->claimed == (HID_CLAIMED_INPUT | HID_CLAIMED_HIDDEV))		printk(",");	if (hid->claimed & HID_CLAIMED_HIDDEV)		printk("hiddev%d", hid->minor);	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);	return 0;}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 = {	.owner =	THIS_MODULE,	.name =		"usbhid",	.probe =	hid_probe,	.disconnect =	hid_disconnect,	.id_table =	hid_usb_ids,};static int __init hid_init(void){	int retval;	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:	return retval;}static void __exit hid_exit(void){	hiddev_exit();	usb_deregister(&hid_driver);}module_init(hid_init);module_exit(hid_exit);MODULE_AUTHOR(DRIVER_AUTHOR);MODULE_DESCRIPTION(DRIVER_DESC);MODULE_LICENSE(DRIVER_LICENSE);