[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
 */

#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 cr_dma;
	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
				dev_info(&urb->dev->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
				dev_info(&urb->dev->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)
		err_hid ("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))
		err_hid("usb_submit_urb(leds) failed");

	return 0;
}

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

	if (urb->status)
		dev_warn(&urb->dev->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))
		err_hid("usb_submit_urb(leds) failed");
}

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_buffer_alloc(dev, 8, GFP_ATOMIC, &kbd->new_dma)))
		return -1;
	if (!(kbd->cr = usb_buffer_alloc(dev, sizeof(struct usb_ctrlrequest), GFP_ATOMIC, &kbd->cr_dma)))
		return -1;
	if (!(kbd->leds = usb_buffer_alloc(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_buffer_free(dev, 8, kbd->new, kbd->new_dma);
	usb_buffer_free(dev, sizeof(struct usb_ctrlrequest), kbd->cr, kbd->cr_dma);
	usb_buffer_free(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->setup_dma = kbd->cr_dma;
	kbd->led->transfer_dma = kbd->leds_dma;
	kbd->led->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);

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

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