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