Merge branch 'next' of git://git.denx.de/u-boot-blackfin
[platform/kernel/u-boot.git] / common / usb_kbd.c
1 /*
2  * (C) Copyright 2001
3  * Denis Peter, MPL AG Switzerland
4  *
5  * Part of this source has been derived from the Linux USB
6  * project.
7  *
8  * SPDX-License-Identifier:     GPL-2.0+
9  */
10 #include <common.h>
11 #include <dm.h>
12 #include <errno.h>
13 #include <malloc.h>
14 #include <memalign.h>
15 #include <stdio_dev.h>
16 #include <asm/byteorder.h>
17
18 #include <usb.h>
19
20 /*
21  * If overwrite_console returns 1, the stdin, stderr and stdout
22  * are switched to the serial port, else the settings in the
23  * environment are used
24  */
25 #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
26 extern int overwrite_console(void);
27 #else
28 int overwrite_console(void)
29 {
30         return 0;
31 }
32 #endif
33
34 /* Keyboard sampling rate */
35 #define REPEAT_RATE     40              /* 40msec -> 25cps */
36 #define REPEAT_DELAY    10              /* 10 x REPEAT_RATE = 400msec */
37
38 #define NUM_LOCK        0x53
39 #define CAPS_LOCK       0x39
40 #define SCROLL_LOCK     0x47
41
42 /* Modifier bits */
43 #define LEFT_CNTR       (1 << 0)
44 #define LEFT_SHIFT      (1 << 1)
45 #define LEFT_ALT        (1 << 2)
46 #define LEFT_GUI        (1 << 3)
47 #define RIGHT_CNTR      (1 << 4)
48 #define RIGHT_SHIFT     (1 << 5)
49 #define RIGHT_ALT       (1 << 6)
50 #define RIGHT_GUI       (1 << 7)
51
52 /* Size of the keyboard buffer */
53 #define USB_KBD_BUFFER_LEN      0x20
54
55 /* Device name */
56 #define DEVNAME                 "usbkbd"
57
58 /* Keyboard maps */
59 static const unsigned char usb_kbd_numkey[] = {
60         '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
61         '\r', 0x1b, '\b', '\t', ' ', '-', '=', '[', ']',
62         '\\', '#', ';', '\'', '`', ',', '.', '/'
63 };
64 static const unsigned char usb_kbd_numkey_shifted[] = {
65         '!', '@', '#', '$', '%', '^', '&', '*', '(', ')',
66         '\r', 0x1b, '\b', '\t', ' ', '_', '+', '{', '}',
67         '|', '~', ':', '"', '~', '<', '>', '?'
68 };
69
70 static const unsigned char usb_kbd_num_keypad[] = {
71         '/', '*', '-', '+', '\r',
72         '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
73         '.', 0, 0, 0, '='
74 };
75
76 /*
77  * map arrow keys to ^F/^B ^N/^P, can't really use the proper
78  * ANSI sequence for arrow keys because the queuing code breaks
79  * when a single keypress expands to 3 queue elements
80  */
81 static const unsigned char usb_kbd_arrow[] = {
82         0x6, 0x2, 0xe, 0x10
83 };
84
85 /*
86  * NOTE: It's important for the NUM, CAPS, SCROLL-lock bits to be in this
87  *       order. See usb_kbd_setled() function!
88  */
89 #define USB_KBD_NUMLOCK         (1 << 0)
90 #define USB_KBD_CAPSLOCK        (1 << 1)
91 #define USB_KBD_SCROLLLOCK      (1 << 2)
92 #define USB_KBD_CTRL            (1 << 3)
93
94 #define USB_KBD_LEDMASK         \
95         (USB_KBD_NUMLOCK | USB_KBD_CAPSLOCK | USB_KBD_SCROLLLOCK)
96
97 /*
98  * USB Keyboard reports are 8 bytes in boot protocol.
99  * Appendix B of HID Device Class Definition 1.11
100  */
101 #define USB_KBD_BOOT_REPORT_SIZE 8
102
103 struct usb_kbd_pdata {
104         unsigned long   intpipe;
105         int             intpktsize;
106         int             intinterval;
107         unsigned long   last_report;
108         struct int_queue *intq;
109
110         uint32_t        repeat_delay;
111
112         uint32_t        usb_in_pointer;
113         uint32_t        usb_out_pointer;
114         uint8_t         usb_kbd_buffer[USB_KBD_BUFFER_LEN];
115
116         uint8_t         *new;
117         uint8_t         old[USB_KBD_BOOT_REPORT_SIZE];
118
119         uint8_t         flags;
120 };
121
122 extern int __maybe_unused net_busy_flag;
123
124 /* The period of time between two calls of usb_kbd_testc(). */
125 static unsigned long __maybe_unused kbd_testc_tms;
126
127 /* Puts character in the queue and sets up the in and out pointer. */
128 static void usb_kbd_put_queue(struct usb_kbd_pdata *data, char c)
129 {
130         if (data->usb_in_pointer == USB_KBD_BUFFER_LEN - 1) {
131                 /* Check for buffer full. */
132                 if (data->usb_out_pointer == 0)
133                         return;
134
135                 data->usb_in_pointer = 0;
136         } else {
137                 /* Check for buffer full. */
138                 if (data->usb_in_pointer == data->usb_out_pointer - 1)
139                         return;
140
141                 data->usb_in_pointer++;
142         }
143
144         data->usb_kbd_buffer[data->usb_in_pointer] = c;
145 }
146
147 /*
148  * Set the LEDs. Since this is used in the irq routine, the control job is
149  * issued with a timeout of 0. This means, that the job is queued without
150  * waiting for job completion.
151  */
152 static void usb_kbd_setled(struct usb_device *dev)
153 {
154         struct usb_interface *iface = &dev->config.if_desc[0];
155         struct usb_kbd_pdata *data = dev->privptr;
156         ALLOC_ALIGN_BUFFER(uint32_t, leds, 1, USB_DMA_MINALIGN);
157
158         *leds = data->flags & USB_KBD_LEDMASK;
159         usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
160                 USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
161                 0x200, iface->desc.bInterfaceNumber, leds, 1, 0);
162 }
163
164 #define CAPITAL_MASK    0x20
165 /* Translate the scancode in ASCII */
166 static int usb_kbd_translate(struct usb_kbd_pdata *data, unsigned char scancode,
167                                 unsigned char modifier, int pressed)
168 {
169         uint8_t keycode = 0;
170
171         /* Key released */
172         if (pressed == 0) {
173                 data->repeat_delay = 0;
174                 return 0;
175         }
176
177         if (pressed == 2) {
178                 data->repeat_delay++;
179                 if (data->repeat_delay < REPEAT_DELAY)
180                         return 0;
181
182                 data->repeat_delay = REPEAT_DELAY;
183         }
184
185         /* Alphanumeric values */
186         if ((scancode > 3) && (scancode <= 0x1d)) {
187                 keycode = scancode - 4 + 'a';
188
189                 if (data->flags & USB_KBD_CAPSLOCK)
190                         keycode &= ~CAPITAL_MASK;
191
192                 if (modifier & (LEFT_SHIFT | RIGHT_SHIFT)) {
193                         /* Handle CAPSLock + Shift pressed simultaneously */
194                         if (keycode & CAPITAL_MASK)
195                                 keycode &= ~CAPITAL_MASK;
196                         else
197                                 keycode |= CAPITAL_MASK;
198                 }
199         }
200
201         if ((scancode > 0x1d) && (scancode < 0x3a)) {
202                 /* Shift pressed */
203                 if (modifier & (LEFT_SHIFT | RIGHT_SHIFT))
204                         keycode = usb_kbd_numkey_shifted[scancode - 0x1e];
205                 else
206                         keycode = usb_kbd_numkey[scancode - 0x1e];
207         }
208
209         /* Arrow keys */
210         if ((scancode >= 0x4f) && (scancode <= 0x52))
211                 keycode = usb_kbd_arrow[scancode - 0x4f];
212
213         /* Numeric keypad */
214         if ((scancode >= 0x54) && (scancode <= 0x67))
215                 keycode = usb_kbd_num_keypad[scancode - 0x54];
216
217         if (data->flags & USB_KBD_CTRL)
218                 keycode = scancode - 0x3;
219
220         if (pressed == 1) {
221                 if (scancode == NUM_LOCK) {
222                         data->flags ^= USB_KBD_NUMLOCK;
223                         return 1;
224                 }
225
226                 if (scancode == CAPS_LOCK) {
227                         data->flags ^= USB_KBD_CAPSLOCK;
228                         return 1;
229                 }
230                 if (scancode == SCROLL_LOCK) {
231                         data->flags ^= USB_KBD_SCROLLLOCK;
232                         return 1;
233                 }
234         }
235
236         /* Report keycode if any */
237         if (keycode) {
238                 debug("%c", keycode);
239                 usb_kbd_put_queue(data, keycode);
240         }
241
242         return 0;
243 }
244
245 static uint32_t usb_kbd_service_key(struct usb_device *dev, int i, int up)
246 {
247         uint32_t res = 0;
248         struct usb_kbd_pdata *data = dev->privptr;
249         uint8_t *new;
250         uint8_t *old;
251
252         if (up) {
253                 new = data->old;
254                 old = data->new;
255         } else {
256                 new = data->new;
257                 old = data->old;
258         }
259
260         if ((old[i] > 3) &&
261             (memscan(new + 2, old[i], USB_KBD_BOOT_REPORT_SIZE - 2) ==
262                         new + USB_KBD_BOOT_REPORT_SIZE)) {
263                 res |= usb_kbd_translate(data, old[i], data->new[0], up);
264         }
265
266         return res;
267 }
268
269 /* Interrupt service routine */
270 static int usb_kbd_irq_worker(struct usb_device *dev)
271 {
272         struct usb_kbd_pdata *data = dev->privptr;
273         int i, res = 0;
274
275         /* No combo key pressed */
276         if (data->new[0] == 0x00)
277                 data->flags &= ~USB_KBD_CTRL;
278         /* Left or Right Ctrl pressed */
279         else if ((data->new[0] == LEFT_CNTR) || (data->new[0] == RIGHT_CNTR))
280                 data->flags |= USB_KBD_CTRL;
281
282         for (i = 2; i < USB_KBD_BOOT_REPORT_SIZE; i++) {
283                 res |= usb_kbd_service_key(dev, i, 0);
284                 res |= usb_kbd_service_key(dev, i, 1);
285         }
286
287         /* Key is still pressed */
288         if ((data->new[2] > 3) && (data->old[2] == data->new[2]))
289                 res |= usb_kbd_translate(data, data->new[2], data->new[0], 2);
290
291         if (res == 1)
292                 usb_kbd_setled(dev);
293
294         memcpy(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE);
295
296         return 1;
297 }
298
299 /* Keyboard interrupt handler */
300 static int usb_kbd_irq(struct usb_device *dev)
301 {
302         if ((dev->irq_status != 0) ||
303             (dev->irq_act_len != USB_KBD_BOOT_REPORT_SIZE)) {
304                 debug("USB KBD: Error %lX, len %d\n",
305                       dev->irq_status, dev->irq_act_len);
306                 return 1;
307         }
308
309         return usb_kbd_irq_worker(dev);
310 }
311
312 /* Interrupt polling */
313 static inline void usb_kbd_poll_for_event(struct usb_device *dev)
314 {
315 #if defined(CONFIG_SYS_USB_EVENT_POLL)
316         struct usb_kbd_pdata *data = dev->privptr;
317
318         /* Submit a interrupt transfer request */
319         usb_submit_int_msg(dev, data->intpipe, &data->new[0], data->intpktsize,
320                            data->intinterval);
321
322         usb_kbd_irq_worker(dev);
323 #elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) || \
324       defined(CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE)
325 #if defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
326         struct usb_interface *iface;
327         struct usb_kbd_pdata *data = dev->privptr;
328         iface = &dev->config.if_desc[0];
329         usb_get_report(dev, iface->desc.bInterfaceNumber,
330                        1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE);
331         if (memcmp(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE)) {
332                 usb_kbd_irq_worker(dev);
333 #else
334         struct usb_kbd_pdata *data = dev->privptr;
335         if (poll_int_queue(dev, data->intq)) {
336                 usb_kbd_irq_worker(dev);
337                 /* We've consumed all queued int packets, create new */
338                 destroy_int_queue(dev, data->intq);
339                 data->intq = create_int_queue(dev, data->intpipe, 1,
340                                       USB_KBD_BOOT_REPORT_SIZE, data->new,
341                                       data->intinterval);
342 #endif
343                 data->last_report = get_timer(0);
344         /* Repeat last usb hid report every REPEAT_RATE ms for keyrepeat */
345         } else if (data->last_report != -1 &&
346                    get_timer(data->last_report) > REPEAT_RATE) {
347                 usb_kbd_irq_worker(dev);
348                 data->last_report = get_timer(0);
349         }
350 #endif
351 }
352
353 /* test if a character is in the queue */
354 static int usb_kbd_testc(struct stdio_dev *sdev)
355 {
356         struct stdio_dev *dev;
357         struct usb_device *usb_kbd_dev;
358         struct usb_kbd_pdata *data;
359
360 #ifdef CONFIG_CMD_NET
361         /*
362          * If net_busy_flag is 1, NET transfer is running,
363          * then we check key-pressed every second (first check may be
364          * less than 1 second) to improve TFTP booting performance.
365          */
366         if (net_busy_flag && (get_timer(kbd_testc_tms) < CONFIG_SYS_HZ))
367                 return 0;
368         kbd_testc_tms = get_timer(0);
369 #endif
370         dev = stdio_get_by_name(DEVNAME);
371         usb_kbd_dev = (struct usb_device *)dev->priv;
372         data = usb_kbd_dev->privptr;
373
374         usb_kbd_poll_for_event(usb_kbd_dev);
375
376         return !(data->usb_in_pointer == data->usb_out_pointer);
377 }
378
379 /* gets the character from the queue */
380 static int usb_kbd_getc(struct stdio_dev *sdev)
381 {
382         struct stdio_dev *dev;
383         struct usb_device *usb_kbd_dev;
384         struct usb_kbd_pdata *data;
385
386         dev = stdio_get_by_name(DEVNAME);
387         usb_kbd_dev = (struct usb_device *)dev->priv;
388         data = usb_kbd_dev->privptr;
389
390         while (data->usb_in_pointer == data->usb_out_pointer)
391                 usb_kbd_poll_for_event(usb_kbd_dev);
392
393         if (data->usb_out_pointer == USB_KBD_BUFFER_LEN - 1)
394                 data->usb_out_pointer = 0;
395         else
396                 data->usb_out_pointer++;
397
398         return data->usb_kbd_buffer[data->usb_out_pointer];
399 }
400
401 /* probes the USB device dev for keyboard type. */
402 static int usb_kbd_probe(struct usb_device *dev, unsigned int ifnum)
403 {
404         struct usb_interface *iface;
405         struct usb_endpoint_descriptor *ep;
406         struct usb_kbd_pdata *data;
407
408         if (dev->descriptor.bNumConfigurations != 1)
409                 return 0;
410
411         iface = &dev->config.if_desc[ifnum];
412
413         if (iface->desc.bInterfaceClass != 3)
414                 return 0;
415
416         if (iface->desc.bInterfaceSubClass != 1)
417                 return 0;
418
419         if (iface->desc.bInterfaceProtocol != 1)
420                 return 0;
421
422         if (iface->desc.bNumEndpoints != 1)
423                 return 0;
424
425         ep = &iface->ep_desc[0];
426
427         /* Check if endpoint 1 is interrupt endpoint */
428         if (!(ep->bEndpointAddress & 0x80))
429                 return 0;
430
431         if ((ep->bmAttributes & 3) != 3)
432                 return 0;
433
434         debug("USB KBD: found set protocol...\n");
435
436         data = malloc(sizeof(struct usb_kbd_pdata));
437         if (!data) {
438                 printf("USB KBD: Error allocating private data\n");
439                 return 0;
440         }
441
442         /* Clear private data */
443         memset(data, 0, sizeof(struct usb_kbd_pdata));
444
445         /* allocate input buffer aligned and sized to USB DMA alignment */
446         data->new = memalign(USB_DMA_MINALIGN,
447                 roundup(USB_KBD_BOOT_REPORT_SIZE, USB_DMA_MINALIGN));
448
449         /* Insert private data into USB device structure */
450         dev->privptr = data;
451
452         /* Set IRQ handler */
453         dev->irq_handle = usb_kbd_irq;
454
455         data->intpipe = usb_rcvintpipe(dev, ep->bEndpointAddress);
456         data->intpktsize = min(usb_maxpacket(dev, data->intpipe),
457                                USB_KBD_BOOT_REPORT_SIZE);
458         data->intinterval = ep->bInterval;
459         data->last_report = -1;
460
461         /* We found a USB Keyboard, install it. */
462         usb_set_protocol(dev, iface->desc.bInterfaceNumber, 0);
463
464         debug("USB KBD: found set idle...\n");
465 #if !defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) && \
466     !defined(CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE)
467         usb_set_idle(dev, iface->desc.bInterfaceNumber, REPEAT_RATE / 4, 0);
468 #else
469         usb_set_idle(dev, iface->desc.bInterfaceNumber, 0, 0);
470 #endif
471
472         debug("USB KBD: enable interrupt pipe...\n");
473 #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
474         data->intq = create_int_queue(dev, data->intpipe, 1,
475                                       USB_KBD_BOOT_REPORT_SIZE, data->new,
476                                       data->intinterval);
477         if (!data->intq) {
478 #else
479         if (usb_submit_int_msg(dev, data->intpipe, data->new, data->intpktsize,
480                                data->intinterval) < 0) {
481 #endif
482                 printf("Failed to get keyboard state from device %04x:%04x\n",
483                        dev->descriptor.idVendor, dev->descriptor.idProduct);
484                 /* Abort, we don't want to use that non-functional keyboard. */
485                 return 0;
486         }
487
488         /* Success. */
489         return 1;
490 }
491
492 static int probe_usb_keyboard(struct usb_device *dev)
493 {
494         char *stdinname;
495         struct stdio_dev usb_kbd_dev;
496         int error;
497
498         /* Try probing the keyboard */
499         if (usb_kbd_probe(dev, 0) != 1)
500                 return -ENOENT;
501
502         /* Register the keyboard */
503         debug("USB KBD: register.\n");
504         memset(&usb_kbd_dev, 0, sizeof(struct stdio_dev));
505         strcpy(usb_kbd_dev.name, DEVNAME);
506         usb_kbd_dev.flags =  DEV_FLAGS_INPUT;
507         usb_kbd_dev.getc = usb_kbd_getc;
508         usb_kbd_dev.tstc = usb_kbd_testc;
509         usb_kbd_dev.priv = (void *)dev;
510         error = stdio_register(&usb_kbd_dev);
511         if (error)
512                 return error;
513
514         stdinname = getenv("stdin");
515 #ifdef CONFIG_CONSOLE_MUX
516         error = iomux_doenv(stdin, stdinname);
517         if (error)
518                 return error;
519 #else
520         /* Check if this is the standard input device. */
521         if (strcmp(stdinname, DEVNAME))
522                 return 1;
523
524         /* Reassign the console */
525         if (overwrite_console())
526                 return 1;
527
528         error = console_assign(stdin, DEVNAME);
529         if (error)
530                 return error;
531 #endif
532
533         return 0;
534 }
535
536 /* Search for keyboard and register it if found. */
537 int drv_usb_kbd_init(void)
538 {
539         int error, i;
540
541         debug("%s: Probing for keyboard\n", __func__);
542 #ifdef CONFIG_DM_USB
543         /*
544          * TODO: We should add U_BOOT_USB_DEVICE() declarations to each USB
545          * keyboard driver and then most of this file can be removed.
546          */
547         struct udevice *bus;
548         struct uclass *uc;
549         int ret;
550
551         ret = uclass_get(UCLASS_USB, &uc);
552         if (ret)
553                 return ret;
554         uclass_foreach_dev(bus, uc) {
555                 for (i = 0; i < USB_MAX_DEVICE; i++) {
556                         struct usb_device *dev;
557
558                         dev = usb_get_dev_index(bus, i); /* get device */
559                         debug("i=%d, %p\n", i, dev);
560                         if (!dev)
561                                 break; /* no more devices available */
562
563                         error = probe_usb_keyboard(dev);
564                         if (!error)
565                                 return 1;
566                         if (error && error != -ENOENT)
567                                 return error;
568                 } /* for */
569         }
570 #else
571         /* Scan all USB Devices */
572         for (i = 0; i < USB_MAX_DEVICE; i++) {
573                 struct usb_device *dev;
574
575                 /* Get USB device. */
576                 dev = usb_get_dev_index(i);
577                 if (!dev)
578                         break;
579
580                 if (dev->devnum == -1)
581                         continue;
582
583                 error = probe_usb_keyboard(dev);
584                 if (!error)
585                         return 1;
586                 if (error && error != -ENOENT)
587                         return error;
588         }
589 #endif
590
591         /* No USB Keyboard found */
592         return -1;
593 }
594
595 /* Deregister the keyboard. */
596 int usb_kbd_deregister(int force)
597 {
598 #ifdef CONFIG_SYS_STDIO_DEREGISTER
599         struct stdio_dev *dev;
600         struct usb_device *usb_kbd_dev;
601         struct usb_kbd_pdata *data;
602
603         dev = stdio_get_by_name(DEVNAME);
604         if (dev) {
605                 usb_kbd_dev = (struct usb_device *)dev->priv;
606                 data = usb_kbd_dev->privptr;
607                 if (stdio_deregister_dev(dev, force) != 0)
608                         return 1;
609 #ifdef CONFIG_CONSOLE_MUX
610                 if (iomux_doenv(stdin, getenv("stdin")) != 0)
611                         return 1;
612 #endif
613 #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
614                 destroy_int_queue(usb_kbd_dev, data->intq);
615 #endif
616                 free(data->new);
617                 free(data);
618         }
619
620         return 0;
621 #else
622         return 1;
623 #endif
624 }