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