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