[mirror_ubuntu-bionic-kernel.git] / drivers / hid / usbhid / usbkbd.c

/*
 *  Copyright (c) 1999-2001 Vojtech Pavlik
 *
 *  USB HIDBP Keyboard support
 */

/*
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * Should you need to contact me, the author, you can do so either by
 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/usb/input.h>
#include <linux/hid.h>

/*
 * Version Information
 */
#define DRIVER_VERSION ""
#define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
#define DRIVER_DESC "USB HID Boot Protocol keyboard driver"
#define DRIVER_LICENSE "GPL"

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

static const unsigned char usb_kbd_keycode[256] = {
	  0,  0,  0,  0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
	 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44,  2,  3,
	  4,  5,  6,  7,  8,  9, 10, 11, 28,  1, 14, 15, 57, 12, 13, 26,
	 27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
	 65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
	105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
	 72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
	191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
	115,114,  0,  0,  0,121,  0, 89, 93,124, 92, 94, 95,  0,  0,  0,
	122,123, 90, 91, 85,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	 29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
	150,158,159,128,136,177,178,176,142,152,173,140
};

struct usb_kbd {
	struct input_dev *dev;
	struct usb_device *usbdev;
	unsigned char old[8];
	struct urb *irq, *led;
	unsigned char newleds;
	char name[128];
	char phys[64];

	unsigned char *new;
	struct usb_ctrlrequest *cr;
	unsigned char *leds;
	dma_addr_t new_dma;
	dma_addr_t leds_dma;
};

static void usb_kbd_irq(struct urb *urb)
{
	struct usb_kbd *kbd = urb->context;
	int i;

	switch (urb->status) {
	case 0:			/* success */
		break;
	case -ECONNRESET:	/* unlink */
	case -ENOENT:
	case -ESHUTDOWN:
		return;
	/* -EPIPE:  should clear the halt */
	default:		/* error */
		goto resubmit;
	}

	for (i = 0; i < 8; i++)
		input_report_key(kbd->dev, usb_kbd_keycode[i + 224], (kbd->new[0] >> i) & 1);

	for (i = 2; i < 8; i++) {

		if (kbd->old[i] > 3 && memscan(kbd->new + 2, kbd->old[i], 6) == kbd->new + 8) {
			if (usb_kbd_keycode[kbd->old[i]])
				input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0);
			else
				hid_info(urb->dev,
					 "Unknown key (scancode %#x) released.\n",
					 kbd->old[i]);
		}

		if (kbd->new[i] > 3 && memscan(kbd->old + 2, kbd->new[i], 6) == kbd->old + 8) {
			if (usb_kbd_keycode[kbd->new[i]])
				input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1);
			else
				hid_info(urb->dev,
					 "Unknown key (scancode %#x) released.\n",
					 kbd->new[i]);
		}
	}

	input_sync(kbd->dev);

	memcpy(kbd->old, kbd->new, 8);

resubmit:
	i = usb_submit_urb (urb, GFP_ATOMIC);
	if (i)
		hid_err(urb->dev, "can't resubmit intr, %s-%s/input0, status %d",
			kbd->usbdev->bus->bus_name,
			kbd->usbdev->devpath, i);
}

static int usb_kbd_event(struct input_dev *dev, unsigned int type,
			 unsigned int code, int value)
{
	struct usb_kbd *kbd = input_get_drvdata(dev);

	if (type != EV_LED)
		return -1;

	kbd->newleds = (!!test_bit(LED_KANA,    dev->led) << 3) | (!!test_bit(LED_COMPOSE, dev->led) << 3) |
		       (!!test_bit(LED_SCROLLL, dev->led) << 2) | (!!test_bit(LED_CAPSL,   dev->led) << 1) |
		       (!!test_bit(LED_NUML,    dev->led));

	if (kbd->led->status == -EINPROGRESS)
		return 0;

	if (*(kbd->leds) == kbd->newleds)
		return 0;

	*(kbd->leds) = kbd->newleds;
	kbd->led->dev = kbd->usbdev;
	if (usb_submit_urb(kbd->led, GFP_ATOMIC))
		pr_err("usb_submit_urb(leds) failed\n");

	return 0;
}

static void usb_kbd_led(struct urb *urb)
{
	struct usb_kbd *kbd = urb->context;

	if (urb->status)
		hid_warn(urb->dev, "led urb status %d received\n",
			 urb->status);

	if (*(kbd->leds) == kbd->newleds)
		return;

	*(kbd->leds) = kbd->newleds;
	kbd->led->dev = kbd->usbdev;
	if (usb_submit_urb(kbd->led, GFP_ATOMIC))
		hid_err(urb->dev, "usb_submit_urb(leds) failed\n");
}

static int usb_kbd_open(struct input_dev *dev)
{
	struct usb_kbd *kbd = input_get_drvdata(dev);

	kbd->irq->dev = kbd->usbdev;
	if (usb_submit_urb(kbd->irq, GFP_KERNEL))
		return -EIO;

	return 0;
}

static void usb_kbd_close(struct input_dev *dev)
{
	struct usb_kbd *kbd = input_get_drvdata(dev);

	usb_kill_urb(kbd->irq);
}

static int usb_kbd_alloc_mem(struct usb_device *dev, struct usb_kbd *kbd)
{
	if (!(kbd->irq = usb_alloc_urb(0, GFP_KERNEL)))
		return -1;
	if (!(kbd->led = usb_alloc_urb(0, GFP_KERNEL)))
		return -1;
	if (!(kbd->new = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &kbd->new_dma)))
		return -1;
	if (!(kbd->cr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL)))
		return -1;
	if (!(kbd->leds = usb_alloc_coherent(dev, 1, GFP_ATOMIC, &kbd->leds_dma)))
		return -1;

	return 0;
}

static void usb_kbd_free_mem(struct usb_device *dev, struct usb_kbd *kbd)
{
	usb_free_urb(kbd->irq);
	usb_free_urb(kbd->led);
	usb_free_coherent(dev, 8, kbd->new, kbd->new_dma);
	kfree(kbd->cr);
	usb_free_coherent(dev, 1, kbd->leds, kbd->leds_dma);
}

static int usb_kbd_probe(struct usb_interface *iface,
			 const struct usb_device_id *id)
{
	struct usb_device *dev = interface_to_usbdev(iface);
	struct usb_host_interface *interface;
	struct usb_endpoint_descriptor *endpoint;
	struct usb_kbd *kbd;
	struct input_dev *input_dev;
	int i, pipe, maxp;
	int error = -ENOMEM;

	interface = iface->cur_altsetting;

	if (interface->desc.bNumEndpoints != 1)
		return -ENODEV;

	endpoint = &interface->endpoint[0].desc;
	if (!usb_endpoint_is_int_in(endpoint))
		return -ENODEV;

	pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
	maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));

	kbd = kzalloc(sizeof(struct usb_kbd), GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!kbd || !input_dev)
		goto fail1;

	if (usb_kbd_alloc_mem(dev, kbd))
		goto fail2;

	kbd->usbdev = dev;
	kbd->dev = input_dev;

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

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

	if (!strlen(kbd->name))
		snprintf(kbd->name, sizeof(kbd->name),
			 "USB HIDBP Keyboard %04x:%04x",
			 le16_to_cpu(dev->descriptor.idVendor),
			 le16_to_cpu(dev->descriptor.idProduct));

	usb_make_path(dev, kbd->phys, sizeof(kbd->phys));
	strlcat(kbd->phys, "/input0", sizeof(kbd->phys));

	input_dev->name = kbd->name;
	input_dev->phys = kbd->phys;
	usb_to_input_id(dev, &input_dev->id);
	input_dev->dev.parent = &iface->dev;

	input_set_drvdata(input_dev, kbd);

	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_LED) |
		BIT_MASK(EV_REP);
	input_dev->ledbit[0] = BIT_MASK(LED_NUML) | BIT_MASK(LED_CAPSL) |
		BIT_MASK(LED_SCROLLL) | BIT_MASK(LED_COMPOSE) |
		BIT_MASK(LED_KANA);

	for (i = 0; i < 255; i++)
		set_bit(usb_kbd_keycode[i], input_dev->keybit);
	clear_bit(0, input_dev->keybit);

	input_dev->event = usb_kbd_event;
	input_dev->open = usb_kbd_open;
	input_dev->close = usb_kbd_close;

	usb_fill_int_urb(kbd->irq, dev, pipe,
			 kbd->new, (maxp > 8 ? 8 : maxp),
			 usb_kbd_irq, kbd, endpoint->bInterval);
	kbd->irq->transfer_dma = kbd->new_dma;
	kbd->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

	kbd->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
	kbd->cr->bRequest = 0x09;
	kbd->cr->wValue = cpu_to_le16(0x200);
	kbd->cr->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);
	kbd->cr->wLength = cpu_to_le16(1);

	usb_fill_control_urb(kbd->led, dev, usb_sndctrlpipe(dev, 0),
			     (void *) kbd->cr, kbd->leds, 1,
			     usb_kbd_led, kbd);
	kbd->led->transfer_dma = kbd->leds_dma;
	kbd->led->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

	error = input_register_device(kbd->dev);
	if (error)
		goto fail2;

	usb_set_intfdata(iface, kbd);
	device_set_wakeup_enable(&dev->dev, 1);
	return 0;

fail2:	
	usb_kbd_free_mem(dev, kbd);
fail1:	
	input_free_device(input_dev);
	kfree(kbd);
	return error;
}

static void usb_kbd_disconnect(struct usb_interface *intf)
{
	struct usb_kbd *kbd = usb_get_intfdata (intf);

	usb_set_intfdata(intf, NULL);
	if (kbd) {
		usb_kill_urb(kbd->irq);
		input_unregister_device(kbd->dev);
		usb_kbd_free_mem(interface_to_usbdev(intf), kbd);
		kfree(kbd);
	}
}

static struct usb_device_id usb_kbd_id_table [] = {
	{ USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
		USB_INTERFACE_PROTOCOL_KEYBOARD) },
	{ }						/* Terminating entry */
};

MODULE_DEVICE_TABLE (usb, usb_kbd_id_table);

static struct usb_driver usb_kbd_driver = {
	.name =		"usbkbd",
	.probe =	usb_kbd_probe,
	.disconnect =	usb_kbd_disconnect,
	.id_table =	usb_kbd_id_table,
};

static int __init usb_kbd_init(void)
{
	int result = usb_register(&usb_kbd_driver);
	if (result == 0)
		printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
				DRIVER_DESC "\n");
	return result;
}

static void __exit usb_kbd_exit(void)
{
	usb_deregister(&usb_kbd_driver);
}

module_init(usb_kbd_init);
module_exit(usb_kbd_exit);
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* Copyright (c) 1999-2001 Vojtech Pavlik
	3	*
	4	* USB HIDBP Keyboard support
	5	*/
	6
	7	/*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
05f091ab	10	* the Free Software Foundation; either version 2 of the License, or
1da177e4	11	* (at your option) any later version.
05f091ab	12	*
1da177e4 LT	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
05f091ab	17	*
1da177e4 LT	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
05f091ab	21	*
1da177e4 LT	22	* Should you need to contact me, the author, you can do so either by
	23	* e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
	24	* Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
	25	*/
	26
4291ee30 JP	27	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
4291ee30 JP	28
1da177e4 LT	29	#include <linux/kernel.h>
	30	#include <linux/slab.h>
	31	#include <linux/module.h>
1da177e4	32	#include <linux/init.h>
ae0dadcf	33	#include <linux/usb/input.h>
4ef2e23f	34	#include <linux/hid.h>
1da177e4 LT	35
	36	/*
	37	* Version Information
	38	*/
	39	#define DRIVER_VERSION ""
	40	#define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
	41	#define DRIVER_DESC "USB HID Boot Protocol keyboard driver"
	42	#define DRIVER_LICENSE "GPL"
	43
	44	MODULE_AUTHOR(DRIVER_AUTHOR);
	45	MODULE_DESCRIPTION(DRIVER_DESC);
	46	MODULE_LICENSE(DRIVER_LICENSE);
	47
a44ebcce	48	static const unsigned char usb_kbd_keycode[256] = {
1da177e4 LT	49	0, 0, 0, 0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
	50	50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44, 2, 3,
	51	4, 5, 6, 7, 8, 9, 10, 11, 28, 1, 14, 15, 57, 12, 13, 26,
	52	27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
	53	65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
	54	105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
	55	72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
	56	191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
	57	115,114, 0, 0, 0,121, 0, 89, 93,124, 92, 94, 95, 0, 0, 0,
	58	122,123, 90, 91, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	59	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	60	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	61	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	62	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	63	29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
	64	150,158,159,128,136,177,178,176,142,152,173,140
	65	};
	66
	67	struct usb_kbd {
c5b7c7c3	68	struct input_dev *dev;
1da177e4 LT	69	struct usb_device *usbdev;
	70	unsigned char old[8];
	71	struct urb irq, led;
	72	unsigned char newleds;
	73	char name[128];
	74	char phys[64];
1da177e4 LT	75
	76	unsigned char *new;
	77	struct usb_ctrlrequest *cr;
	78	unsigned char *leds;
1da177e4 LT	79	dma_addr_t new_dma;
	80	dma_addr_t leds_dma;
	81	};
	82
7d12e780	83	static void usb_kbd_irq(struct urb *urb)
1da177e4 LT	84	{
	85	struct usb_kbd *kbd = urb->context;
	86	int i;
	87
	88	switch (urb->status) {
	89	case 0: /* success */
	90	break;
	91	case -ECONNRESET: /* unlink */
	92	case -ENOENT:
	93	case -ESHUTDOWN:
	94	return;
	95	/* -EPIPE: should clear the halt */
	96	default: /* error */
	97	goto resubmit;
	98	}
	99
1da177e4	100	for (i = 0; i < 8; i++)
c5b7c7c3	101	input_report_key(kbd->dev, usb_kbd_keycode[i + 224], (kbd->new[0] >> i) & 1);
1da177e4 LT	102
	103	for (i = 2; i < 8; i++) {
	104
	105	if (kbd->old[i] > 3 && memscan(kbd->new + 2, kbd->old[i], 6) == kbd->new + 8) {
	106	if (usb_kbd_keycode[kbd->old[i]])
c5b7c7c3	107	input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0);
1da177e4	108	else
4291ee30 JP	109	hid_info(urb->dev,
	110	"Unknown key (scancode %#x) released.\n",
	111	kbd->old[i]);
1da177e4 LT	112	}
	113
	114	if (kbd->new[i] > 3 && memscan(kbd->old + 2, kbd->new[i], 6) == kbd->old + 8) {
	115	if (usb_kbd_keycode[kbd->new[i]])
c5b7c7c3	116	input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1);
1da177e4	117	else
4291ee30 JP	118	hid_info(urb->dev,
	119	"Unknown key (scancode %#x) released.\n",
	120	kbd->new[i]);
1da177e4 LT	121	}
	122	}
	123
c5b7c7c3	124	input_sync(kbd->dev);
1da177e4 LT	125
	126	memcpy(kbd->old, kbd->new, 8);
	127
	128	resubmit:
54e6ecb2	129	i = usb_submit_urb (urb, GFP_ATOMIC);
1da177e4	130	if (i)
4291ee30 JP	131	hid_err(urb->dev, "can't resubmit intr, %s-%s/input0, status %d",
	132	kbd->usbdev->bus->bus_name,
	133	kbd->usbdev->devpath, i);
1da177e4 LT	134	}
1da177e4 LT	135
be5e3383 AB	136	static int usb_kbd_event(struct input_dev *dev, unsigned int type,
be5e3383 AB	137	unsigned int code, int value)
1da177e4	138	{
e0712985	139	struct usb_kbd *kbd = input_get_drvdata(dev);
1da177e4 LT	140
	141	if (type != EV_LED)
	142	return -1;
	143
1da177e4 LT	144	kbd->newleds = (!!test_bit(LED_KANA, dev->led) << 3) \| (!!test_bit(LED_COMPOSE, dev->led) << 3) \|
	145	(!!test_bit(LED_SCROLLL, dev->led) << 2) \| (!!test_bit(LED_CAPSL, dev->led) << 1) \|
	146	(!!test_bit(LED_NUML, dev->led));
	147
	148	if (kbd->led->status == -EINPROGRESS)
	149	return 0;
	150
	151	if (*(kbd->leds) == kbd->newleds)
	152	return 0;
	153
	154	*(kbd->leds) = kbd->newleds;
	155	kbd->led->dev = kbd->usbdev;
	156	if (usb_submit_urb(kbd->led, GFP_ATOMIC))
4291ee30	157	pr_err("usb_submit_urb(leds) failed\n");
1da177e4 LT	158
	159	return 0;
	160	}
	161
7d12e780	162	static void usb_kbd_led(struct urb *urb)
1da177e4 LT	163	{
	164	struct usb_kbd *kbd = urb->context;
	165
	166	if (urb->status)
4291ee30	167	hid_warn(urb->dev, "led urb status %d received\n",
7d89fe12	168	urb->status);
05f091ab	169
1da177e4 LT	170	if (*(kbd->leds) == kbd->newleds)
	171	return;
	172
	173	*(kbd->leds) = kbd->newleds;
	174	kbd->led->dev = kbd->usbdev;
	175	if (usb_submit_urb(kbd->led, GFP_ATOMIC))
4291ee30	176	hid_err(urb->dev, "usb_submit_urb(leds) failed\n");
1da177e4 LT	177	}
	178
	179	static int usb_kbd_open(struct input_dev *dev)
	180	{
e0712985	181	struct usb_kbd *kbd = input_get_drvdata(dev);
1da177e4	182
1da177e4	183	kbd->irq->dev = kbd->usbdev;
65cde54b	184	if (usb_submit_urb(kbd->irq, GFP_KERNEL))
1da177e4	185	return -EIO;
1da177e4 LT	186
	187	return 0;
	188	}
	189
	190	static void usb_kbd_close(struct input_dev *dev)
	191	{
e0712985	192	struct usb_kbd *kbd = input_get_drvdata(dev);
1da177e4	193
65cde54b	194	usb_kill_urb(kbd->irq);
1da177e4 LT	195	}
	196
	197	static int usb_kbd_alloc_mem(struct usb_device dev, struct usb_kbd kbd)
	198	{
	199	if (!(kbd->irq = usb_alloc_urb(0, GFP_KERNEL)))
	200	return -1;
	201	if (!(kbd->led = usb_alloc_urb(0, GFP_KERNEL)))
	202	return -1;
997ea58e	203	if (!(kbd->new = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &kbd->new_dma)))
1da177e4	204	return -1;
0ede76fc	205	if (!(kbd->cr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL)))
1da177e4	206	return -1;
997ea58e	207	if (!(kbd->leds = usb_alloc_coherent(dev, 1, GFP_ATOMIC, &kbd->leds_dma)))
1da177e4 LT	208	return -1;
	209
	210	return 0;
	211	}
	212
	213	static void usb_kbd_free_mem(struct usb_device dev, struct usb_kbd kbd)
	214	{
4ba0b2ed MK	215	usb_free_urb(kbd->irq);
4ba0b2ed MK	216	usb_free_urb(kbd->led);
997ea58e	217	usb_free_coherent(dev, 8, kbd->new, kbd->new_dma);
0ede76fc	218	kfree(kbd->cr);
997ea58e	219	usb_free_coherent(dev, 1, kbd->leds, kbd->leds_dma);
1da177e4 LT	220	}
1da177e4 LT	221
05f091ab	222	static int usb_kbd_probe(struct usb_interface *iface,
1da177e4 LT	223	const struct usb_device_id *id)
1da177e4 LT	224	{
c5b7c7c3	225	struct usb_device *dev = interface_to_usbdev(iface);
1da177e4 LT	226	struct usb_host_interface *interface;
	227	struct usb_endpoint_descriptor *endpoint;
	228	struct usb_kbd *kbd;
c5b7c7c3	229	struct input_dev *input_dev;
1da177e4	230	int i, pipe, maxp;
5d6341c6	231	int error = -ENOMEM;
1da177e4 LT	232
	233	interface = iface->cur_altsetting;
	234
	235	if (interface->desc.bNumEndpoints != 1)
	236	return -ENODEV;
	237
	238	endpoint = &interface->endpoint[0].desc;
a20c3144	239	if (!usb_endpoint_is_int_in(endpoint))
1da177e4 LT	240	return -ENODEV;
	241
	242	pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
	243	maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
	244
c5b7c7c3 DT	245	kbd = kzalloc(sizeof(struct usb_kbd), GFP_KERNEL);
	246	input_dev = input_allocate_device();
	247	if (!kbd \|\| !input_dev)
	248	goto fail1;
1da177e4	249
c5b7c7c3 DT	250	if (usb_kbd_alloc_mem(dev, kbd))
c5b7c7c3 DT	251	goto fail2;
1da177e4 LT	252
1da177e4 LT	253	kbd->usbdev = dev;
c5b7c7c3 DT	254	kbd->dev = input_dev;
	255
	256	if (dev->manufacturer)
	257	strlcpy(kbd->name, dev->manufacturer, sizeof(kbd->name));
	258
	259	if (dev->product) {
	260	if (dev->manufacturer)
	261	strlcat(kbd->name, " ", sizeof(kbd->name));
	262	strlcat(kbd->name, dev->product, sizeof(kbd->name));
	263	}
	264
	265	if (!strlen(kbd->name))
	266	snprintf(kbd->name, sizeof(kbd->name),
	267	"USB HIDBP Keyboard %04x:%04x",
	268	le16_to_cpu(dev->descriptor.idVendor),
	269	le16_to_cpu(dev->descriptor.idProduct));
	270
	271	usb_make_path(dev, kbd->phys, sizeof(kbd->phys));
6236dfaa	272	strlcat(kbd->phys, "/input0", sizeof(kbd->phys));
1da177e4	273
c5b7c7c3 DT	274	input_dev->name = kbd->name;
	275	input_dev->phys = kbd->phys;
	276	usb_to_input_id(dev, &input_dev->id);
e0712985 DT	277	input_dev->dev.parent = &iface->dev;
	278
	279	input_set_drvdata(input_dev, kbd);
c5b7c7c3	280
7b19ada2 JS	281	input_dev->evbit[0] = BIT_MASK(EV_KEY) \| BIT_MASK(EV_LED) \|
	282	BIT_MASK(EV_REP);
	283	input_dev->ledbit[0] = BIT_MASK(LED_NUML) \| BIT_MASK(LED_CAPSL) \|
	284	BIT_MASK(LED_SCROLLL) \| BIT_MASK(LED_COMPOSE) \|
	285	BIT_MASK(LED_KANA);
1da177e4 LT	286
1da177e4 LT	287	for (i = 0; i < 255; i++)
c5b7c7c3 DT	288	set_bit(usb_kbd_keycode[i], input_dev->keybit);
c5b7c7c3 DT	289	clear_bit(0, input_dev->keybit);
05f091ab	290
c5b7c7c3 DT	291	input_dev->event = usb_kbd_event;
	292	input_dev->open = usb_kbd_open;
	293	input_dev->close = usb_kbd_close;
1da177e4 LT	294
	295	usb_fill_int_urb(kbd->irq, dev, pipe,
	296	kbd->new, (maxp > 8 ? 8 : maxp),
	297	usb_kbd_irq, kbd, endpoint->bInterval);
	298	kbd->irq->transfer_dma = kbd->new_dma;
	299	kbd->irq->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;
	300
	301	kbd->cr->bRequestType = USB_TYPE_CLASS \| USB_RECIP_INTERFACE;
	302	kbd->cr->bRequest = 0x09;
	303	kbd->cr->wValue = cpu_to_le16(0x200);
	304	kbd->cr->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);
	305	kbd->cr->wLength = cpu_to_le16(1);
	306
1da177e4 LT	307	usb_fill_control_urb(kbd->led, dev, usb_sndctrlpipe(dev, 0),
	308	(void *) kbd->cr, kbd->leds, 1,
	309	usb_kbd_led, kbd);
1da177e4	310	kbd->led->transfer_dma = kbd->leds_dma;
0ede76fc	311	kbd->led->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;
1da177e4	312
5d6341c6 DT	313	error = input_register_device(kbd->dev);
	314	if (error)
	315	goto fail2;
1da177e4 LT	316
1da177e4 LT	317	usb_set_intfdata(iface, kbd);
3d61510f	318	device_set_wakeup_enable(&dev->dev, 1);
1da177e4	319	return 0;
c5b7c7c3	320
5d6341c6 DT	321	fail2:
	322	usb_kbd_free_mem(dev, kbd);
	323	fail1:
	324	input_free_device(input_dev);
c5b7c7c3	325	kfree(kbd);
5d6341c6	326	return error;
1da177e4 LT	327	}
	328
	329	static void usb_kbd_disconnect(struct usb_interface *intf)
	330	{
	331	struct usb_kbd *kbd = usb_get_intfdata (intf);
05f091ab	332
1da177e4 LT	333	usb_set_intfdata(intf, NULL);
	334	if (kbd) {
	335	usb_kill_urb(kbd->irq);
c5b7c7c3	336	input_unregister_device(kbd->dev);
1da177e4 LT	337	usb_kbd_free_mem(interface_to_usbdev(intf), kbd);
	338	kfree(kbd);
	339	}
	340	}
	341
	342	static struct usb_device_id usb_kbd_id_table [] = {
4ef2e23f MO	343	{ USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
4ef2e23f MO	344	USB_INTERFACE_PROTOCOL_KEYBOARD) },
1da177e4 LT	345	{ } /* Terminating entry */
	346	};
	347
	348	MODULE_DEVICE_TABLE (usb, usb_kbd_id_table);
	349
	350	static struct usb_driver usb_kbd_driver = {
1da177e4 LT	351	.name = "usbkbd",
	352	.probe = usb_kbd_probe,
	353	.disconnect = usb_kbd_disconnect,
	354	.id_table = usb_kbd_id_table,
	355	};
	356
	357	static int __init usb_kbd_init(void)
	358	{
	359	int result = usb_register(&usb_kbd_driver);
	360	if (result == 0)
ddbe3249 GKH	361	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
ddbe3249 GKH	362	DRIVER_DESC "\n");
1da177e4 LT	363	return result;
	364	}
	365
	366	static void __exit usb_kbd_exit(void)
	367	{
	368	usb_deregister(&usb_kbd_driver);
	369	}
	370
	371	module_init(usb_kbd_init);
	372	module_exit(usb_kbd_exit);