]> git.sur5r.net Git - u-boot/blob - common/usb_kbd.c
ddr: altera: Drop custom dram_bank_mmu_setup() on Arria10
[u-boot] / common / usb_kbd.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * (C) Copyright 2001
4  * Denis Peter, MPL AG Switzerland
5  *
6  * Part of this source has been derived from the Linux USB
7  * project.
8  */
9 #include <common.h>
10 #include <console.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 < 0x39)) {
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_dev(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 != USB_CLASS_HID)
414                 return 0;
415
416         if (iface->desc.bInterfaceSubClass != USB_SUB_HID_BOOT)
417                 return 0;
418
419         if (iface->desc.bInterfaceProtocol != USB_PROT_HID_KEYBOARD)
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 #elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
479         if (usb_get_report(dev, iface->desc.bInterfaceNumber,
480                            1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE) < 0) {
481 #else
482         if (usb_submit_int_msg(dev, data->intpipe, data->new, data->intpktsize,
483                                data->intinterval) < 0) {
484 #endif
485                 printf("Failed to get keyboard state from device %04x:%04x\n",
486                        dev->descriptor.idVendor, dev->descriptor.idProduct);
487                 /* Abort, we don't want to use that non-functional keyboard. */
488                 return 0;
489         }
490
491         /* Success. */
492         return 1;
493 }
494
495 static int probe_usb_keyboard(struct usb_device *dev)
496 {
497         char *stdinname;
498         struct stdio_dev usb_kbd_dev;
499         int error;
500
501         /* Try probing the keyboard */
502         if (usb_kbd_probe_dev(dev, 0) != 1)
503                 return -ENOENT;
504
505         /* Register the keyboard */
506         debug("USB KBD: register.\n");
507         memset(&usb_kbd_dev, 0, sizeof(struct stdio_dev));
508         strcpy(usb_kbd_dev.name, DEVNAME);
509         usb_kbd_dev.flags =  DEV_FLAGS_INPUT;
510         usb_kbd_dev.getc = usb_kbd_getc;
511         usb_kbd_dev.tstc = usb_kbd_testc;
512         usb_kbd_dev.priv = (void *)dev;
513         error = stdio_register(&usb_kbd_dev);
514         if (error)
515                 return error;
516
517         stdinname = env_get("stdin");
518 #if CONFIG_IS_ENABLED(CONSOLE_MUX)
519         error = iomux_doenv(stdin, stdinname);
520         if (error)
521                 return error;
522 #else
523         /* Check if this is the standard input device. */
524         if (strcmp(stdinname, DEVNAME))
525                 return 1;
526
527         /* Reassign the console */
528         if (overwrite_console())
529                 return 1;
530
531         error = console_assign(stdin, DEVNAME);
532         if (error)
533                 return error;
534 #endif
535
536         return 0;
537 }
538
539 #ifndef CONFIG_DM_USB
540 /* Search for keyboard and register it if found. */
541 int drv_usb_kbd_init(void)
542 {
543         int error, i;
544
545         debug("%s: Probing for keyboard\n", __func__);
546         /* Scan all USB Devices */
547         for (i = 0; i < USB_MAX_DEVICE; i++) {
548                 struct usb_device *dev;
549
550                 /* Get USB device. */
551                 dev = usb_get_dev_index(i);
552                 if (!dev)
553                         break;
554
555                 if (dev->devnum == -1)
556                         continue;
557
558                 error = probe_usb_keyboard(dev);
559                 if (!error)
560                         return 1;
561                 if (error && error != -ENOENT)
562                         return error;
563         }
564
565         /* No USB Keyboard found */
566         return -1;
567 }
568
569 /* Deregister the keyboard. */
570 int usb_kbd_deregister(int force)
571 {
572 #if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER)
573         struct stdio_dev *dev;
574         struct usb_device *usb_kbd_dev;
575         struct usb_kbd_pdata *data;
576
577         dev = stdio_get_by_name(DEVNAME);
578         if (dev) {
579                 usb_kbd_dev = (struct usb_device *)dev->priv;
580                 data = usb_kbd_dev->privptr;
581                 if (stdio_deregister_dev(dev, force) != 0)
582                         return 1;
583 #if CONFIG_IS_ENABLED(CONSOLE_MUX)
584                 if (iomux_doenv(stdin, env_get("stdin")) != 0)
585                         return 1;
586 #endif
587 #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
588                 destroy_int_queue(usb_kbd_dev, data->intq);
589 #endif
590                 free(data->new);
591                 free(data);
592         }
593
594         return 0;
595 #else
596         return 1;
597 #endif
598 }
599
600 #endif
601
602 #ifdef CONFIG_DM_USB
603
604 static int usb_kbd_probe(struct udevice *dev)
605 {
606         struct usb_device *udev = dev_get_parent_priv(dev);
607
608         return probe_usb_keyboard(udev);
609 }
610
611 static int usb_kbd_remove(struct udevice *dev)
612 {
613         struct usb_device *udev = dev_get_parent_priv(dev);
614         struct usb_kbd_pdata *data;
615         struct stdio_dev *sdev;
616         int ret;
617
618         sdev = stdio_get_by_name(DEVNAME);
619         if (!sdev) {
620                 ret = -ENXIO;
621                 goto err;
622         }
623         data = udev->privptr;
624         if (stdio_deregister_dev(sdev, true)) {
625                 ret = -EPERM;
626                 goto err;
627         }
628 #if CONFIG_IS_ENABLED(CONSOLE_MUX)
629         if (iomux_doenv(stdin, env_get("stdin"))) {
630                 ret = -ENOLINK;
631                 goto err;
632         }
633 #endif
634 #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
635         destroy_int_queue(udev, data->intq);
636 #endif
637         free(data->new);
638         free(data);
639
640         return 0;
641 err:
642         printf("%s: warning, ret=%d", __func__, ret);
643         return ret;
644 }
645
646 static const struct udevice_id usb_kbd_ids[] = {
647         { .compatible = "usb-keyboard" },
648         { }
649 };
650
651 U_BOOT_DRIVER(usb_kbd) = {
652         .name   = "usb_kbd",
653         .id     = UCLASS_KEYBOARD,
654         .of_match = usb_kbd_ids,
655         .probe = usb_kbd_probe,
656         .remove = usb_kbd_remove,
657 };
658
659 static const struct usb_device_id kbd_id_table[] = {
660         {
661                 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
662                         USB_DEVICE_ID_MATCH_INT_SUBCLASS |
663                         USB_DEVICE_ID_MATCH_INT_PROTOCOL,
664                 .bInterfaceClass = USB_CLASS_HID,
665                 .bInterfaceSubClass = USB_SUB_HID_BOOT,
666                 .bInterfaceProtocol = USB_PROT_HID_KEYBOARD,
667         },
668         { }             /* Terminating entry */
669 };
670
671 U_BOOT_USB_DEVICE(usb_kbd, kbd_id_table);
672
673 #endif