[deliverable/linux.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 - state of each attached keyboard
 * @dev:	input device associated with this keyboard
 * @usbdev:	usb device associated with this keyboard
 * @old:	data received in the past from the @irq URB representing which
 *		keys were pressed. By comparing with the current list of keys
 *		that are pressed, we are able to see key releases.
 * @irq:	URB for receiving a list of keys that are pressed when a
 *		new key is pressed or a key that was pressed is released.
 * @led:	URB for sending LEDs (e.g. numlock, ...)
 * @newleds:	data that will be sent with the @led URB representing which LEDs
 		should be on
 * @name:	Name of the keyboard. @dev's name field points to this buffer
 * @phys:	Physical path of the keyboard. @dev's phys field points to this
 *		buffer
 * @new:	Buffer for the @irq URB
 * @cr:		Control request for @led URB
 * @leds:	Buffer for the @led URB
 * @new_dma:	DMA address for @irq URB
 * @leds_dma:	DMA address for @led URB
 * @leds_lock:	spinlock that protects @leds, @newleds, and @led_urb_submitted
 * @led_urb_submitted: indicates whether @led is in progress, i.e. it has been
 *		submitted and its completion handler has not returned yet
 *		without	resubmitting @led
 */
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;
	
	spinlock_t leds_lock;
	bool led_urb_submitted;

};

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) pressed.\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)
{
	unsigned long flags;
	struct usb_kbd *kbd = input_get_drvdata(dev);

	if (type != EV_LED)
		return -1;

	spin_lock_irqsave(&kbd->leds_lock, flags);
	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_urb_submitted){
		spin_unlock_irqrestore(&kbd->leds_lock, flags);
		return 0;
	}

	if (*(kbd->leds) == kbd->newleds){
		spin_unlock_irqrestore(&kbd->leds_lock, flags);
		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");
	else
		kbd->led_urb_submitted = true;
	
	spin_unlock_irqrestore(&kbd->leds_lock, flags);
	
	return 0;
}

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

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

	spin_lock_irqsave(&kbd->leds_lock, flags);

	if (*(kbd->leds) == kbd->newleds){
		kbd->led_urb_submitted = false;
		spin_unlock_irqrestore(&kbd->leds_lock, flags);
		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");
		kbd->led_urb_submitted = false;
	}
	spin_unlock_irqrestore(&kbd->leds_lock, flags);
	
}

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;
	spin_lock_init(&kbd->leds_lock);

	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_kill_urb(kbd->led);
		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,
};

module_usb_driver(usb_kbd_driver);
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
c196adf8 WP	67
	68	/**
	69	* struct usb_kbd - state of each attached keyboard
	70	* @dev: input device associated with this keyboard
	71	* @usbdev: usb device associated with this keyboard
	72	* @old: data received in the past from the @irq URB representing which
	73	* keys were pressed. By comparing with the current list of keys
	74	* that are pressed, we are able to see key releases.
	75	* @irq: URB for receiving a list of keys that are pressed when a
	76	* new key is pressed or a key that was pressed is released.
	77	* @led: URB for sending LEDs (e.g. numlock, ...)
	78	* @newleds: data that will be sent with the @led URB representing which LEDs
	79	should be on
	80	* @name: Name of the keyboard. @dev's name field points to this buffer
	81	* @phys: Physical path of the keyboard. @dev's phys field points to this
	82	* buffer
	83	* @new: Buffer for the @irq URB
	84	* @cr: Control request for @led URB
	85	* @leds: Buffer for the @led URB
	86	* @new_dma: DMA address for @irq URB
	87	* @leds_dma: DMA address for @led URB
	88	* @leds_lock: spinlock that protects @leds, @newleds, and @led_urb_submitted
	89	* @led_urb_submitted: indicates whether @led is in progress, i.e. it has been
	90	* submitted and its completion handler has not returned yet
	91	* without resubmitting @led
	92	*/
1da177e4	93	struct usb_kbd {
c5b7c7c3	94	struct input_dev *dev;
1da177e4 LT	95	struct usb_device *usbdev;
	96	unsigned char old[8];
	97	struct urb irq, led;
	98	unsigned char newleds;
	99	char name[128];
	100	char phys[64];
1da177e4 LT	101
	102	unsigned char *new;
	103	struct usb_ctrlrequest *cr;
	104	unsigned char *leds;
1da177e4 LT	105	dma_addr_t new_dma;
1da177e4 LT	106	dma_addr_t leds_dma;
c196adf8 WP	107
	108	spinlock_t leds_lock;
	109	bool led_urb_submitted;
	110
1da177e4 LT	111	};
1da177e4 LT	112
7d12e780	113	static void usb_kbd_irq(struct urb *urb)
1da177e4 LT	114	{
	115	struct usb_kbd *kbd = urb->context;
	116	int i;
	117
	118	switch (urb->status) {
	119	case 0: /* success */
	120	break;
	121	case -ECONNRESET: /* unlink */
	122	case -ENOENT:
	123	case -ESHUTDOWN:
	124	return;
	125	/* -EPIPE: should clear the halt */
	126	default: /* error */
	127	goto resubmit;
	128	}
	129
1da177e4	130	for (i = 0; i < 8; i++)
c5b7c7c3	131	input_report_key(kbd->dev, usb_kbd_keycode[i + 224], (kbd->new[0] >> i) & 1);
1da177e4 LT	132
	133	for (i = 2; i < 8; i++) {
	134
	135	if (kbd->old[i] > 3 && memscan(kbd->new + 2, kbd->old[i], 6) == kbd->new + 8) {
	136	if (usb_kbd_keycode[kbd->old[i]])
c5b7c7c3	137	input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0);
1da177e4	138	else
4291ee30 JP	139	hid_info(urb->dev,
	140	"Unknown key (scancode %#x) released.\n",
	141	kbd->old[i]);
1da177e4 LT	142	}
	143
	144	if (kbd->new[i] > 3 && memscan(kbd->old + 2, kbd->new[i], 6) == kbd->old + 8) {
	145	if (usb_kbd_keycode[kbd->new[i]])
c5b7c7c3	146	input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1);
1da177e4	147	else
4291ee30	148	hid_info(urb->dev,
9fee8240	149	"Unknown key (scancode %#x) pressed.\n",
4291ee30	150	kbd->new[i]);
1da177e4 LT	151	}
	152	}
	153
c5b7c7c3	154	input_sync(kbd->dev);
1da177e4 LT	155
	156	memcpy(kbd->old, kbd->new, 8);
	157
	158	resubmit:
54e6ecb2	159	i = usb_submit_urb (urb, GFP_ATOMIC);
1da177e4	160	if (i)
4291ee30 JP	161	hid_err(urb->dev, "can't resubmit intr, %s-%s/input0, status %d",
	162	kbd->usbdev->bus->bus_name,
	163	kbd->usbdev->devpath, i);
1da177e4 LT	164	}
1da177e4 LT	165
be5e3383 AB	166	static int usb_kbd_event(struct input_dev *dev, unsigned int type,
be5e3383 AB	167	unsigned int code, int value)
1da177e4	168	{
c196adf8	169	unsigned long flags;
e0712985	170	struct usb_kbd *kbd = input_get_drvdata(dev);
1da177e4 LT	171
	172	if (type != EV_LED)
	173	return -1;
	174
c196adf8	175	spin_lock_irqsave(&kbd->leds_lock, flags);
1da177e4 LT	176	kbd->newleds = (!!test_bit(LED_KANA, dev->led) << 3) \| (!!test_bit(LED_COMPOSE, dev->led) << 3) \|
	177	(!!test_bit(LED_SCROLLL, dev->led) << 2) \| (!!test_bit(LED_CAPSL, dev->led) << 1) \|
	178	(!!test_bit(LED_NUML, dev->led));
	179
c196adf8 WP	180	if (kbd->led_urb_submitted){
c196adf8 WP	181	spin_unlock_irqrestore(&kbd->leds_lock, flags);
1da177e4	182	return 0;
c196adf8	183	}
1da177e4	184
c196adf8 WP	185	if (*(kbd->leds) == kbd->newleds){
c196adf8 WP	186	spin_unlock_irqrestore(&kbd->leds_lock, flags);
1da177e4	187	return 0;
c196adf8	188	}
1da177e4 LT	189
1da177e4 LT	190	*(kbd->leds) = kbd->newleds;
c196adf8	191
1da177e4 LT	192	kbd->led->dev = kbd->usbdev;
1da177e4 LT	193	if (usb_submit_urb(kbd->led, GFP_ATOMIC))
4291ee30	194	pr_err("usb_submit_urb(leds) failed\n");
c196adf8 WP	195	else
	196	kbd->led_urb_submitted = true;
	197
	198	spin_unlock_irqrestore(&kbd->leds_lock, flags);
	199
1da177e4 LT	200	return 0;
	201	}
	202
7d12e780	203	static void usb_kbd_led(struct urb *urb)
1da177e4	204	{
c196adf8	205	unsigned long flags;
1da177e4 LT	206	struct usb_kbd *kbd = urb->context;
	207
	208	if (urb->status)
4291ee30	209	hid_warn(urb->dev, "led urb status %d received\n",
7d89fe12	210	urb->status);
05f091ab	211
c196adf8 WP	212	spin_lock_irqsave(&kbd->leds_lock, flags);
	213
	214	if (*(kbd->leds) == kbd->newleds){
	215	kbd->led_urb_submitted = false;
	216	spin_unlock_irqrestore(&kbd->leds_lock, flags);
1da177e4	217	return;
c196adf8	218	}
1da177e4 LT	219
1da177e4 LT	220	*(kbd->leds) = kbd->newleds;
c196adf8	221
1da177e4	222	kbd->led->dev = kbd->usbdev;
c196adf8	223	if (usb_submit_urb(kbd->led, GFP_ATOMIC)){
4291ee30	224	hid_err(urb->dev, "usb_submit_urb(leds) failed\n");
c196adf8 WP	225	kbd->led_urb_submitted = false;
	226	}
	227	spin_unlock_irqrestore(&kbd->leds_lock, flags);
	228
1da177e4 LT	229	}
	230
	231	static int usb_kbd_open(struct input_dev *dev)
	232	{
e0712985	233	struct usb_kbd *kbd = input_get_drvdata(dev);
1da177e4	234
1da177e4	235	kbd->irq->dev = kbd->usbdev;
65cde54b	236	if (usb_submit_urb(kbd->irq, GFP_KERNEL))
1da177e4	237	return -EIO;
1da177e4 LT	238
	239	return 0;
	240	}
	241
	242	static void usb_kbd_close(struct input_dev *dev)
	243	{
e0712985	244	struct usb_kbd *kbd = input_get_drvdata(dev);
1da177e4	245
65cde54b	246	usb_kill_urb(kbd->irq);
1da177e4 LT	247	}
	248
	249	static int usb_kbd_alloc_mem(struct usb_device dev, struct usb_kbd kbd)
	250	{
	251	if (!(kbd->irq = usb_alloc_urb(0, GFP_KERNEL)))
	252	return -1;
	253	if (!(kbd->led = usb_alloc_urb(0, GFP_KERNEL)))
	254	return -1;
997ea58e	255	if (!(kbd->new = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &kbd->new_dma)))
1da177e4	256	return -1;
0ede76fc	257	if (!(kbd->cr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL)))
1da177e4	258	return -1;
997ea58e	259	if (!(kbd->leds = usb_alloc_coherent(dev, 1, GFP_ATOMIC, &kbd->leds_dma)))
1da177e4 LT	260	return -1;
	261
	262	return 0;
	263	}
	264
	265	static void usb_kbd_free_mem(struct usb_device dev, struct usb_kbd kbd)
	266	{
4ba0b2ed MK	267	usb_free_urb(kbd->irq);
4ba0b2ed MK	268	usb_free_urb(kbd->led);
997ea58e	269	usb_free_coherent(dev, 8, kbd->new, kbd->new_dma);
0ede76fc	270	kfree(kbd->cr);
997ea58e	271	usb_free_coherent(dev, 1, kbd->leds, kbd->leds_dma);
1da177e4 LT	272	}
1da177e4 LT	273
05f091ab	274	static int usb_kbd_probe(struct usb_interface *iface,
1da177e4 LT	275	const struct usb_device_id *id)
1da177e4 LT	276	{
c5b7c7c3	277	struct usb_device *dev = interface_to_usbdev(iface);
1da177e4 LT	278	struct usb_host_interface *interface;
	279	struct usb_endpoint_descriptor *endpoint;
	280	struct usb_kbd *kbd;
c5b7c7c3	281	struct input_dev *input_dev;
1da177e4	282	int i, pipe, maxp;
5d6341c6	283	int error = -ENOMEM;
1da177e4 LT	284
	285	interface = iface->cur_altsetting;
	286
	287	if (interface->desc.bNumEndpoints != 1)
	288	return -ENODEV;
	289
	290	endpoint = &interface->endpoint[0].desc;
a20c3144	291	if (!usb_endpoint_is_int_in(endpoint))
1da177e4 LT	292	return -ENODEV;
	293
	294	pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
	295	maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
	296
c5b7c7c3 DT	297	kbd = kzalloc(sizeof(struct usb_kbd), GFP_KERNEL);
	298	input_dev = input_allocate_device();
	299	if (!kbd \|\| !input_dev)
	300	goto fail1;
1da177e4	301
c5b7c7c3 DT	302	if (usb_kbd_alloc_mem(dev, kbd))
c5b7c7c3 DT	303	goto fail2;
1da177e4 LT	304
1da177e4 LT	305	kbd->usbdev = dev;
c5b7c7c3	306	kbd->dev = input_dev;
c196adf8	307	spin_lock_init(&kbd->leds_lock);
c5b7c7c3 DT	308
	309	if (dev->manufacturer)
	310	strlcpy(kbd->name, dev->manufacturer, sizeof(kbd->name));
	311
	312	if (dev->product) {
	313	if (dev->manufacturer)
	314	strlcat(kbd->name, " ", sizeof(kbd->name));
	315	strlcat(kbd->name, dev->product, sizeof(kbd->name));
	316	}
	317
	318	if (!strlen(kbd->name))
	319	snprintf(kbd->name, sizeof(kbd->name),
	320	"USB HIDBP Keyboard %04x:%04x",
	321	le16_to_cpu(dev->descriptor.idVendor),
	322	le16_to_cpu(dev->descriptor.idProduct));
	323
	324	usb_make_path(dev, kbd->phys, sizeof(kbd->phys));
6236dfaa	325	strlcat(kbd->phys, "/input0", sizeof(kbd->phys));
1da177e4	326
c5b7c7c3 DT	327	input_dev->name = kbd->name;
	328	input_dev->phys = kbd->phys;
	329	usb_to_input_id(dev, &input_dev->id);
e0712985 DT	330	input_dev->dev.parent = &iface->dev;
	331
	332	input_set_drvdata(input_dev, kbd);
c5b7c7c3	333
7b19ada2 JS	334	input_dev->evbit[0] = BIT_MASK(EV_KEY) \| BIT_MASK(EV_LED) \|
	335	BIT_MASK(EV_REP);
	336	input_dev->ledbit[0] = BIT_MASK(LED_NUML) \| BIT_MASK(LED_CAPSL) \|
	337	BIT_MASK(LED_SCROLLL) \| BIT_MASK(LED_COMPOSE) \|
	338	BIT_MASK(LED_KANA);
1da177e4 LT	339
1da177e4 LT	340	for (i = 0; i < 255; i++)
c5b7c7c3 DT	341	set_bit(usb_kbd_keycode[i], input_dev->keybit);
c5b7c7c3 DT	342	clear_bit(0, input_dev->keybit);
05f091ab	343
c5b7c7c3 DT	344	input_dev->event = usb_kbd_event;
	345	input_dev->open = usb_kbd_open;
	346	input_dev->close = usb_kbd_close;
1da177e4 LT	347
	348	usb_fill_int_urb(kbd->irq, dev, pipe,
	349	kbd->new, (maxp > 8 ? 8 : maxp),
	350	usb_kbd_irq, kbd, endpoint->bInterval);
	351	kbd->irq->transfer_dma = kbd->new_dma;
	352	kbd->irq->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;
	353
	354	kbd->cr->bRequestType = USB_TYPE_CLASS \| USB_RECIP_INTERFACE;
	355	kbd->cr->bRequest = 0x09;
	356	kbd->cr->wValue = cpu_to_le16(0x200);
	357	kbd->cr->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);
	358	kbd->cr->wLength = cpu_to_le16(1);
	359
1da177e4 LT	360	usb_fill_control_urb(kbd->led, dev, usb_sndctrlpipe(dev, 0),
	361	(void *) kbd->cr, kbd->leds, 1,
	362	usb_kbd_led, kbd);
1da177e4	363	kbd->led->transfer_dma = kbd->leds_dma;
0ede76fc	364	kbd->led->transfer_flags \|= URB_NO_TRANSFER_DMA_MAP;
1da177e4	365
5d6341c6 DT	366	error = input_register_device(kbd->dev);
	367	if (error)
	368	goto fail2;
1da177e4 LT	369
1da177e4 LT	370	usb_set_intfdata(iface, kbd);
3d61510f	371	device_set_wakeup_enable(&dev->dev, 1);
1da177e4	372	return 0;
c5b7c7c3	373
5d6341c6 DT	374	fail2:
	375	usb_kbd_free_mem(dev, kbd);
	376	fail1:
	377	input_free_device(input_dev);
c5b7c7c3	378	kfree(kbd);
5d6341c6	379	return error;
1da177e4 LT	380	}
	381
	382	static void usb_kbd_disconnect(struct usb_interface *intf)
	383	{
	384	struct usb_kbd *kbd = usb_get_intfdata (intf);
05f091ab	385
1da177e4 LT	386	usb_set_intfdata(intf, NULL);
	387	if (kbd) {
	388	usb_kill_urb(kbd->irq);
c5b7c7c3	389	input_unregister_device(kbd->dev);
a2b2c20b	390	usb_kill_urb(kbd->led);
1da177e4 LT	391	usb_kbd_free_mem(interface_to_usbdev(intf), kbd);
	392	kfree(kbd);
	393	}
	394	}
	395
	396	static struct usb_device_id usb_kbd_id_table [] = {
4ef2e23f MO	397	{ USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
4ef2e23f MO	398	USB_INTERFACE_PROTOCOL_KEYBOARD) },
1da177e4 LT	399	{ } /* Terminating entry */
	400	};
	401
	402	MODULE_DEVICE_TABLE (usb, usb_kbd_id_table);
	403
	404	static struct usb_driver usb_kbd_driver = {
1da177e4 LT	405	.name = "usbkbd",
	406	.probe = usb_kbd_probe,
	407	.disconnect = usb_kbd_disconnect,
	408	.id_table = usb_kbd_id_table,
	409	};
	410
42f06a13	411	module_usb_driver(usb_kbd_driver);