usbkbd.c 10.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
 * $Id: usbkbd.c,v 1.27 2001/12/27 10:37:41 vojtech Exp $
Linus Torvalds's avatar
Linus Torvalds committed
3
 *
Linus Torvalds's avatar
Linus Torvalds committed
4
 *  Copyright (c) 1999-2001 Vojtech Pavlik
Linus Torvalds's avatar
Linus Torvalds committed
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 *  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
25 26
 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
Linus Torvalds's avatar
Linus Torvalds committed
27 28 29
 */

#include <linux/kernel.h>
Linus Torvalds's avatar
Linus Torvalds committed
30
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34 35
#include <linux/module.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/usb.h>

Linus Torvalds's avatar
Linus Torvalds committed
36 37 38 39
/*
 * Version Information
 */
#define DRIVER_VERSION ""
40
#define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>"
Linus Torvalds's avatar
Linus Torvalds committed
41
#define DRIVER_DESC "USB HID Boot Protocol keyboard driver"
42
#define DRIVER_LICENSE "GPL"
Linus Torvalds's avatar
Linus Torvalds committed
43

44 45 46
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE(DRIVER_LICENSE);
Linus Torvalds's avatar
Linus Torvalds committed
47 48 49 50 51

static 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,
52
	 27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
Linus Torvalds's avatar
Linus Torvalds committed
53 54
	 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,
55 56 57 58
	 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,
Linus Torvalds's avatar
Linus Torvalds committed
59 60 61 62 63 64 65 66 67 68 69 70
	  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];
Linus Torvalds's avatar
Linus Torvalds committed
71
	struct urb *irq, *led;
72
	unsigned char newleds;
Linus Torvalds's avatar
Linus Torvalds committed
73
	char name[128];
74
	char phys[64];
Linus Torvalds's avatar
Linus Torvalds committed
75
	int open;
76 77 78 79 80 81 82

	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;
Linus Torvalds's avatar
Linus Torvalds committed
83 84
};

David S. Miller's avatar
David S. Miller committed
85
static void usb_kbd_irq(struct urb *urb, struct pt_regs *regs)
Linus Torvalds's avatar
Linus Torvalds committed
86 87 88 89
{
	struct usb_kbd *kbd = urb->context;
	int i;

90 91 92 93 94 95 96 97 98 99 100
	switch (urb->status) {
	case 0:			/* success */
		break;
	case -ECONNRESET:	/* unlink */
	case -ENOENT:
	case -ESHUTDOWN:
		return;
	/* -EPIPE:  should clear the halt */
	default:		/* error */
		goto resubmit;
	}
Linus Torvalds's avatar
Linus Torvalds committed
101

102 103
	input_regs(&kbd->dev, regs);

Linus Torvalds's avatar
Linus Torvalds committed
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
	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
				info("Unknown key (scancode %#x) released.", 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
				info("Unknown key (scancode %#x) pressed.", kbd->new[i]);
		}
	}

124 125
	input_sync(&kbd->dev);

Linus Torvalds's avatar
Linus Torvalds committed
126
	memcpy(kbd->old, kbd->new, 8);
127 128 129 130 131 132 133

resubmit:
	i = usb_submit_urb (urb, SLAB_ATOMIC);
	if (i)
		err ("can't resubmit intr, %s-%s/input0, status %d",
				kbd->usbdev->bus->bus_name,
				kbd->usbdev->devpath, i);
Linus Torvalds's avatar
Linus Torvalds committed
134 135 136 137 138 139
}

int usb_kbd_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
	struct usb_kbd *kbd = dev->private;

140 141
	if (type != EV_LED)
		return -1;
Linus Torvalds's avatar
Linus Torvalds committed
142 143 144 145 146 147


	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));

Linus Torvalds's avatar
Linus Torvalds committed
148
	if (kbd->led->status == -EINPROGRESS)
Linus Torvalds's avatar
Linus Torvalds committed
149 150
		return 0;

151
	if (*(kbd->leds) == kbd->newleds)
Linus Torvalds's avatar
Linus Torvalds committed
152 153
		return 0;

154
	*(kbd->leds) = kbd->newleds;
Linus Torvalds's avatar
Linus Torvalds committed
155
	kbd->led->dev = kbd->usbdev;
156
	if (usb_submit_urb(kbd->led, GFP_ATOMIC))
Linus Torvalds's avatar
Linus Torvalds committed
157 158 159 160 161
		err("usb_submit_urb(leds) failed");

	return 0;
}

David S. Miller's avatar
David S. Miller committed
162
static void usb_kbd_led(struct urb *urb, struct pt_regs *regs)
Linus Torvalds's avatar
Linus Torvalds committed
163 164 165 166 167 168
{
	struct usb_kbd *kbd = urb->context;

	if (urb->status)
		warn("led urb status %d received", urb->status);
	
169
	if (*(kbd->leds) == kbd->newleds)
Linus Torvalds's avatar
Linus Torvalds committed
170 171
		return;

172
	*(kbd->leds) = kbd->newleds;
Linus Torvalds's avatar
Linus Torvalds committed
173
	kbd->led->dev = kbd->usbdev;
174
	if (usb_submit_urb(kbd->led, GFP_ATOMIC))
Linus Torvalds's avatar
Linus Torvalds committed
175 176 177 178 179 180 181 182 183 184
		err("usb_submit_urb(leds) failed");
}

static int usb_kbd_open(struct input_dev *dev)
{
	struct usb_kbd *kbd = dev->private;

	if (kbd->open++)
		return 0;

Linus Torvalds's avatar
Linus Torvalds committed
185
	kbd->irq->dev = kbd->usbdev;
186 187
	if (usb_submit_urb(kbd->irq, GFP_KERNEL)) {
		kbd->open--;
Linus Torvalds's avatar
Linus Torvalds committed
188
		return -EIO;
189
	}
Linus Torvalds's avatar
Linus Torvalds committed
190 191 192 193 194 195 196 197 198

	return 0;
}

static void usb_kbd_close(struct input_dev *dev)
{
	struct usb_kbd *kbd = dev->private;

	if (!--kbd->open)
Linus Torvalds's avatar
Linus Torvalds committed
199
		usb_unlink_urb(kbd->irq);
Linus Torvalds's avatar
Linus Torvalds committed
200 201
}

202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
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, SLAB_ATOMIC, &kbd->new_dma)))
		return -1;
	if (!(kbd->cr = usb_buffer_alloc(dev, sizeof(struct usb_ctrlrequest), SLAB_ATOMIC, &kbd->cr_dma)))
		return -1;
	if (!(kbd->leds = usb_buffer_alloc(dev, 1, SLAB_ATOMIC, &kbd->leds_dma)))
		return -1;

	return 0;
}

static void usb_kbd_free_mem(struct usb_device *dev, struct usb_kbd *kbd)
{
	if (kbd->irq)
		usb_free_urb(kbd->irq);
	if (kbd->led)
		usb_free_urb(kbd->led);
	if (kbd->new)
		usb_buffer_free(dev, 8, kbd->new, kbd->new_dma);
	if (kbd->cr)
		usb_buffer_free(dev, sizeof(struct usb_ctrlrequest), kbd->cr, kbd->cr_dma);
	if (kbd->leds)
		usb_buffer_free(dev, 1, kbd->leds, kbd->leds_dma);
}

232 233
static int usb_kbd_probe(struct usb_interface *iface, 
			 const struct usb_device_id *id)
Linus Torvalds's avatar
Linus Torvalds committed
234
{
235
	struct usb_device * dev = interface_to_usbdev(iface);
236
	struct usb_host_interface *interface;
Linus Torvalds's avatar
Linus Torvalds committed
237 238 239
	struct usb_endpoint_descriptor *endpoint;
	struct usb_kbd *kbd;
	int i, pipe, maxp;
240
	char path[64];
Linus Torvalds's avatar
Linus Torvalds committed
241 242 243 244
	char *buf;

	interface = &iface->altsetting[iface->act_altsetting];

245
	if (interface->desc.bNumEndpoints != 1)
246
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
247

248
	endpoint = &interface->endpoint[0].desc;
249 250 251 252
	if (!(endpoint->bEndpointAddress & 0x80))
		return -ENODEV;
	if ((endpoint->bmAttributes & 3) != 3)
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
253 254 255 256

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

257 258
	if (!(kbd = kmalloc(sizeof(struct usb_kbd), GFP_KERNEL)))
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
259 260
	memset(kbd, 0, sizeof(struct usb_kbd));

261 262
	if (usb_kbd_alloc_mem(dev, kbd)) {
		usb_kbd_free_mem(dev, kbd);
Linus Torvalds's avatar
Linus Torvalds committed
263
		kfree(kbd);
264
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
265 266
	}

Linus Torvalds's avatar
Linus Torvalds committed
267 268 269 270 271 272 273 274 275 276 277 278 279 280
	kbd->usbdev = dev;

	kbd->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_LED) | BIT(EV_REP);
	kbd->dev.ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL) | BIT(LED_COMPOSE) | BIT(LED_KANA);

	for (i = 0; i < 255; i++)
		set_bit(usb_kbd_keycode[i], kbd->dev.keybit);
	clear_bit(0, kbd->dev.keybit);
	
	kbd->dev.private = kbd;
	kbd->dev.event = usb_kbd_event;
	kbd->dev.open = usb_kbd_open;
	kbd->dev.close = usb_kbd_close;

281 282 283 284
	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;
285
	kbd->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
Linus Torvalds's avatar
Linus Torvalds committed
286

287 288 289
	kbd->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE;
	kbd->cr->bRequest = 0x09;
	kbd->cr->wValue = cpu_to_le16(0x200);
290
	kbd->cr->wIndex = cpu_to_le16(interface->desc.bInterfaceNumber);
291
	kbd->cr->wLength = cpu_to_le16(1);
292 293 294

	usb_make_path(dev, path, 64);
	sprintf(kbd->phys, "%s/input0", path);
Linus Torvalds's avatar
Linus Torvalds committed
295 296

	kbd->dev.name = kbd->name;
297
	kbd->dev.phys = kbd->phys;	
298
	kbd->dev.id.bustype = BUS_USB;
299 300 301
	kbd->dev.id.vendor = dev->descriptor.idVendor;
	kbd->dev.id.product = dev->descriptor.idProduct;
	kbd->dev.id.version = dev->descriptor.bcdDevice;
Linus Torvalds's avatar
Linus Torvalds committed
302 303

	if (!(buf = kmalloc(63, GFP_KERNEL))) {
304
		usb_free_urb(kbd->irq);
David S. Miller's avatar
David S. Miller committed
305
		usb_kbd_free_mem(dev, kbd);
Linus Torvalds's avatar
Linus Torvalds committed
306
		kfree(kbd);
307
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
308 309 310 311 312 313 314 315 316 317 318
	}

	if (dev->descriptor.iManufacturer &&
		usb_string(dev, dev->descriptor.iManufacturer, buf, 63) > 0)
			strcat(kbd->name, buf);
	if (dev->descriptor.iProduct &&
		usb_string(dev, dev->descriptor.iProduct, buf, 63) > 0)
			sprintf(kbd->name, "%s %s", kbd->name, buf);

	if (!strlen(kbd->name))
		sprintf(kbd->name, "USB HIDBP Keyboard %04x:%04x",
319
			kbd->dev.id.vendor, kbd->dev.id.product);
Linus Torvalds's avatar
Linus Torvalds committed
320 321 322

	kfree(buf);

323 324 325 326 327
	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;
328 329
	kbd->led->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP
				| URB_NO_SETUP_DMA_MAP);
330

Linus Torvalds's avatar
Linus Torvalds committed
331 332
	input_register_device(&kbd->dev);

333
	printk(KERN_INFO "input: %s on %s\n", kbd->name, path);
Linus Torvalds's avatar
Linus Torvalds committed
334

335
	usb_set_intfdata(iface, kbd);
336
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
337 338
}

339
static void usb_kbd_disconnect(struct usb_interface *intf)
Linus Torvalds's avatar
Linus Torvalds committed
340
{
341
	struct usb_kbd *kbd = usb_get_intfdata (intf);
342
	
343
	usb_set_intfdata(intf, NULL);
344 345 346
	if (kbd) {
		usb_unlink_urb(kbd->irq);
		input_unregister_device(&kbd->dev);
David S. Miller's avatar
David S. Miller committed
347
		usb_kbd_free_mem(interface_to_usbdev(intf), kbd);
348 349
		kfree(kbd);
	}
Linus Torvalds's avatar
Linus Torvalds committed
350 351 352 353 354 355 356 357 358 359
}

static struct usb_device_id usb_kbd_id_table [] = {
	{ USB_INTERFACE_INFO(3, 1, 1) },
	{ }						/* Terminating entry */
};

MODULE_DEVICE_TABLE (usb, usb_kbd_id_table);

static struct usb_driver usb_kbd_driver = {
360
	.owner =	THIS_MODULE,
361
	.name =		"usbkbd",
362 363 364
	.probe =	usb_kbd_probe,
	.disconnect =	usb_kbd_disconnect,
	.id_table =	usb_kbd_id_table,
Linus Torvalds's avatar
Linus Torvalds committed
365 366 367 368
};

static int __init usb_kbd_init(void)
{
369 370 371 372
	int result = usb_register(&usb_kbd_driver);
	if (result == 0)
		info(DRIVER_VERSION ":" DRIVER_DESC);
	return result;
Linus Torvalds's avatar
Linus Torvalds committed
373 374 375 376 377 378 379 380 381
}

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

module_init(usb_kbd_init);
module_exit(usb_kbd_exit);