1/*
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
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
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.
17 *
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
21 *
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#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28
29#include <linux/kernel.h>
30#include <linux/slab.h>
31#include <linux/module.h>
32#include <linux/init.h>
33#include <linux/usb/input.h>
34#include <linux/hid.h>
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
44MODULE_AUTHOR(DRIVER_AUTHOR);
45MODULE_DESCRIPTION(DRIVER_DESC);
46MODULE_LICENSE(DRIVER_LICENSE);
47
48static const unsigned char usb_kbd_keycode[256] = {
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
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 */
93struct usb_kbd {
94	struct input_dev *dev;
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];
101
102	unsigned char *new;
103	struct usb_ctrlrequest *cr;
104	unsigned char *leds;
105	dma_addr_t new_dma;
106	dma_addr_t leds_dma;
107
108	spinlock_t leds_lock;
109	bool led_urb_submitted;
110
111};
112
113static void usb_kbd_irq(struct urb *urb)
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
130	for (i = 0; i < 8; i++)
131		input_report_key(kbd->dev, usb_kbd_keycode[i + 224], (kbd->new[0] >> i) & 1);
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]])
137				input_report_key(kbd->dev, usb_kbd_keycode[kbd->old[i]], 0);
138			else
139				hid_info(urb->dev,
140					 "Unknown key (scancode %#x) released.\n",
141					 kbd->old[i]);
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]])
146				input_report_key(kbd->dev, usb_kbd_keycode[kbd->new[i]], 1);
147			else
148				hid_info(urb->dev,
149					 "Unknown key (scancode %#x) pressed.\n",
150					 kbd->new[i]);
151		}
152	}
153
154	input_sync(kbd->dev);
155
156	memcpy(kbd->old, kbd->new, 8);
157
158resubmit:
159	i = usb_submit_urb (urb, GFP_ATOMIC);
160	if (i)
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);
164}
165
166static int usb_kbd_event(struct input_dev *dev, unsigned int type,
167			 unsigned int code, int value)
168{
169	unsigned long flags;
170	struct usb_kbd *kbd = input_get_drvdata(dev);
171
172	if (type != EV_LED)
173		return -1;
174
175	spin_lock_irqsave(&kbd->leds_lock, flags);
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
180	if (kbd->led_urb_submitted){
181		spin_unlock_irqrestore(&kbd->leds_lock, flags);
182		return 0;
183	}
184
185	if (*(kbd->leds) == kbd->newleds){
186		spin_unlock_irqrestore(&kbd->leds_lock, flags);
187		return 0;
188	}
189
190	*(kbd->leds) = kbd->newleds;
191
192	kbd->led->dev = kbd->usbdev;
193	if (usb_submit_urb(kbd->led, GFP_ATOMIC))
194		pr_err("usb_submit_urb(leds) failed\n");
195	else
196		kbd->led_urb_submitted = true;
197
198	spin_unlock_irqrestore(&kbd->leds_lock, flags);
199
200	return 0;
201}
202
203static void usb_kbd_led(struct urb *urb)
204{
205	unsigned long flags;
206	struct usb_kbd *kbd = urb->context;
207
208	if (urb->status)
209		hid_warn(urb->dev, "led urb status %d received\n",
210			 urb->status);
211
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);
217		return;
218	}
219
220	*(kbd->leds) = kbd->newleds;
221
222	kbd->led->dev = kbd->usbdev;
223	if (usb_submit_urb(kbd->led, GFP_ATOMIC)){
224		hid_err(urb->dev, "usb_submit_urb(leds) failed\n");
225		kbd->led_urb_submitted = false;
226	}
227	spin_unlock_irqrestore(&kbd->leds_lock, flags);
228
229}
230
231static int usb_kbd_open(struct input_dev *dev)
232{
233	struct usb_kbd *kbd = input_get_drvdata(dev);
234
235	kbd->irq->dev = kbd->usbdev;
236	if (usb_submit_urb(kbd->irq, GFP_KERNEL))
237		return -EIO;
238
239	return 0;
240}
241
242static void usb_kbd_close(struct input_dev *dev)
243{
244	struct usb_kbd *kbd = input_get_drvdata(dev);
245
246	usb_kill_urb(kbd->irq);
247}
248
249static 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;
255	if (!(kbd->new = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &kbd->new_dma)))
256		return -1;
257	if (!(kbd->cr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL)))
258		return -1;
259	if (!(kbd->leds = usb_alloc_coherent(dev, 1, GFP_ATOMIC, &kbd->leds_dma)))
260		return -1;
261
262	return 0;
263}
264
265static void usb_kbd_free_mem(struct usb_device *dev, struct usb_kbd *kbd)
266{
267	usb_free_urb(kbd->irq);
268	usb_free_urb(kbd->led);
269	usb_free_coherent(dev, 8, kbd->new, kbd->new_dma);
270	kfree(kbd->cr);
271	usb_free_coherent(dev, 1, kbd->leds, kbd->leds_dma);
272}
273
274static int usb_kbd_probe(struct usb_interface *iface,
275			 const struct usb_device_id *id)
276{
277	struct usb_device *dev = interface_to_usbdev(iface);
278	struct usb_host_interface *interface;
279	struct usb_endpoint_descriptor *endpoint;
280	struct usb_kbd *kbd;
281	struct input_dev *input_dev;
282	int i, pipe, maxp;
283	int error = -ENOMEM;
284
285	interface = iface->cur_altsetting;
286
287	if (interface->desc.bNumEndpoints != 1)
288		return -ENODEV;
289
290	endpoint = &interface->endpoint[0].desc;
291	if (!usb_endpoint_is_int_in(endpoint))
292		return -ENODEV;
293
294	pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
295	maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
296
297	kbd = kzalloc(sizeof(struct usb_kbd), GFP_KERNEL);
298	input_dev = input_allocate_device();
299	if (!kbd || !input_dev)
300		goto fail1;
301
302	if (usb_kbd_alloc_mem(dev, kbd))
303		goto fail2;
304
305	kbd->usbdev = dev;
306	kbd->dev = input_dev;
307	spin_lock_init(&kbd->leds_lock);
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));
325	strlcat(kbd->phys, "/input0", sizeof(kbd->phys));
326
327	input_dev->name = kbd->name;
328	input_dev->phys = kbd->phys;
329	usb_to_input_id(dev, &input_dev->id);
330	input_dev->dev.parent = &iface->dev;
331
332	input_set_drvdata(input_dev, kbd);
333
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);
339
340	for (i = 0; i < 255; i++)
341		set_bit(usb_kbd_keycode[i], input_dev->keybit);
342	clear_bit(0, input_dev->keybit);
343
344	input_dev->event = usb_kbd_event;
345	input_dev->open = usb_kbd_open;
346	input_dev->close = usb_kbd_close;
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
360	usb_fill_control_urb(kbd->led, dev, usb_sndctrlpipe(dev, 0),
361			     (void *) kbd->cr, kbd->leds, 1,
362			     usb_kbd_led, kbd);
363	kbd->led->transfer_dma = kbd->leds_dma;
364	kbd->led->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
365
366	error = input_register_device(kbd->dev);
367	if (error)
368		goto fail2;
369
370	usb_set_intfdata(iface, kbd);
371	device_set_wakeup_enable(&dev->dev, 1);
372	return 0;
373
374fail2:
375	usb_kbd_free_mem(dev, kbd);
376fail1:
377	input_free_device(input_dev);
378	kfree(kbd);
379	return error;
380}
381
382static void usb_kbd_disconnect(struct usb_interface *intf)
383{
384	struct usb_kbd *kbd = usb_get_intfdata (intf);
385
386	usb_set_intfdata(intf, NULL);
387	if (kbd) {
388		usb_kill_urb(kbd->irq);
389		input_unregister_device(kbd->dev);
390		usb_kill_urb(kbd->led);
391		usb_kbd_free_mem(interface_to_usbdev(intf), kbd);
392		kfree(kbd);
393	}
394}
395
396static struct usb_device_id usb_kbd_id_table [] = {
397	{ USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
398		USB_INTERFACE_PROTOCOL_KEYBOARD) },
399	{ }						/* Terminating entry */
400};
401
402MODULE_DEVICE_TABLE (usb, usb_kbd_id_table);
403
404static struct usb_driver usb_kbd_driver = {
405	.name =		"usbkbd",
406	.probe =	usb_kbd_probe,
407	.disconnect =	usb_kbd_disconnect,
408	.id_table =	usb_kbd_id_table,
409};
410
411module_usb_driver(usb_kbd_driver);
412