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         if (usb_int_msg(dev, data->intpipe, &data->new[0],
 344                         data->intpktsize, data->intinterval, true) >= 0)
 345                 usb_kbd_irq_worker(dev);
 346 #elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) || \
 347       defined(CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE)
 348 #if defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
 349         struct usb_interface *iface;
 350         struct usb_kbd_pdata *data = dev->privptr;
 351         iface = &dev->config.if_desc[0];
 352         usb_get_report(dev, iface->desc.bInterfaceNumber,
 353                        1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE);
 354         if (memcmp(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE)) {
 355                 usb_kbd_irq_worker(dev);
 356 #else
 357         struct usb_kbd_pdata *data = dev->privptr;
 358         if (poll_int_queue(dev, data->intq)) {
 359                 usb_kbd_irq_worker(dev);
 360                 /* We've consumed all queued int packets, create new */
 361                 destroy_int_queue(dev, data->intq);
 362                 data->intq = create_int_queue(dev, data->intpipe, 1,
 363                                       USB_KBD_BOOT_REPORT_SIZE, data->new,
 364                                       data->intinterval);
 365 #endif
 366                 data->last_report = get_timer(0);
 367         /* Repeat last usb hid report every REPEAT_RATE ms for keyrepeat */
 368         } else if (data->last_report != -1 &&
 369                    get_timer(data->last_report) > REPEAT_RATE) {
 370                 usb_kbd_irq_worker(dev);
 371                 data->last_report = get_timer(0);
 372         }
 373 #endif
 374 }
 375
 376 /* test if a character is in the queue */
 377 static int usb_kbd_testc(struct stdio_dev *sdev)
 378 {
 379         struct stdio_dev *dev;
 380         struct usb_device *usb_kbd_dev;
 381         struct usb_kbd_pdata *data;
 382
 383 #ifdef CONFIG_CMD_NET
 384         /*
 385          * If net_busy_flag is 1, NET transfer is running,
 386          * then we check key-pressed every second (first check may be
 387          * less than 1 second) to improve TFTP booting performance.
 388          */
 389         if (net_busy_flag && (get_timer(kbd_testc_tms) < CONFIG_SYS_HZ))
 390                 return 0;
 391         kbd_testc_tms = get_timer(0);
 392 #endif
 393         dev = stdio_get_by_name(sdev->name);
 394         usb_kbd_dev = (struct usb_device *)dev->priv;
 395         data = usb_kbd_dev->privptr;
 396
 397         usb_kbd_poll_for_event(usb_kbd_dev);
 398
 399         return !(data->usb_in_pointer == data->usb_out_pointer);
 400 }
 401
 402 /* gets the character from the queue */
 403 static int usb_kbd_getc(struct stdio_dev *sdev)
 404 {
 405         struct stdio_dev *dev;
 406         struct usb_device *usb_kbd_dev;
 407         struct usb_kbd_pdata *data;
 408
 409         dev = stdio_get_by_name(sdev->name);
 410         usb_kbd_dev = (struct usb_device *)dev->priv;
 411         data = usb_kbd_dev->privptr;
 412
 413         while (data->usb_in_pointer == data->usb_out_pointer) {
 414                 WATCHDOG_RESET();
 415                 usb_kbd_poll_for_event(usb_kbd_dev);
 416         }
 417
 418         if (data->usb_out_pointer == USB_KBD_BUFFER_LEN - 1)
 419                 data->usb_out_pointer = 0;
 420         else
 421                 data->usb_out_pointer++;
 422
 423         return data->usb_kbd_buffer[data->usb_out_pointer];
 424 }
 425
 426 /* probes the USB device dev for keyboard type. */
 427 static int usb_kbd_probe_dev(struct usb_device *dev, unsigned int ifnum)
 428 {
 429         struct usb_interface *iface;
 430         struct usb_endpoint_descriptor *ep;
 431         struct usb_kbd_pdata *data;
 432
 433         if (dev->descriptor.bNumConfigurations != 1)
 434                 return 0;
 435
 436         iface = &dev->config.if_desc[ifnum];
 437
 438         if (iface->desc.bInterfaceClass != USB_CLASS_HID)
 439                 return 0;
 440
 441         if (iface->desc.bInterfaceSubClass != USB_SUB_HID_BOOT)
 442                 return 0;
 443
 444         if (iface->desc.bInterfaceProtocol != USB_PROT_HID_KEYBOARD)
 445                 return 0;
 446
 447         if (iface->desc.bNumEndpoints != 1)
 448                 return 0;
 449
 450         ep = &iface->ep_desc[0];
 451
 452         /* Check if endpoint 1 is interrupt endpoint */
 453         if (!(ep->bEndpointAddress & 0x80))
 454                 return 0;
 455
 456         if ((ep->bmAttributes & 3) != 3)
 457                 return 0;
 458
 459         debug("USB KBD: found set protocol...\n");
 460
 461         data = malloc(sizeof(struct usb_kbd_pdata));
 462         if (!data) {
 463                 printf("USB KBD: Error allocating private data\n");
 464                 return 0;
 465         }
 466
 467         /* Clear private data */
 468         memset(data, 0, sizeof(struct usb_kbd_pdata));
 469
 470         /* allocate input buffer aligned and sized to USB DMA alignment */
 471         data->new = memalign(USB_DMA_MINALIGN,
 472                 roundup(USB_KBD_BOOT_REPORT_SIZE, USB_DMA_MINALIGN));
 473
 474         /* Insert private data into USB device structure */
 475         dev->privptr = data;
 476
 477         /* Set IRQ handler */
 478         dev->irq_handle = usb_kbd_irq;
 479
 480         data->intpipe = usb_rcvintpipe(dev, ep->bEndpointAddress);
 481         data->intpktsize = min(usb_maxpacket(dev, data->intpipe),
 482                                USB_KBD_BOOT_REPORT_SIZE);
 483         data->intinterval = ep->bInterval;
 484         data->last_report = -1;
 485
 486         /* We found a USB Keyboard, install it. */
 487         usb_set_protocol(dev, iface->desc.bInterfaceNumber, 0);
 488
 489         debug("USB KBD: found set idle...\n");
 490 #if !defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) && \
 491     !defined(CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE)
 492         usb_set_idle(dev, iface->desc.bInterfaceNumber, REPEAT_RATE / 4, 0);
 493 #else
 494         usb_set_idle(dev, iface->desc.bInterfaceNumber, 0, 0);
 495 #endif
 496
 497         debug("USB KBD: enable interrupt pipe...\n");
 498 #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
 499         data->intq = create_int_queue(dev, data->intpipe, 1,
 500                                       USB_KBD_BOOT_REPORT_SIZE, data->new,
 501                                       data->intinterval);
 502         if (!data->intq) {
 503 #elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
 504         if (usb_get_report(dev, iface->desc.bInterfaceNumber,
 505                            1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE) < 0) {
 506 #else
 507         if (usb_int_msg(dev, data->intpipe, data->new, data->intpktsize,
 508                         data->intinterval, false) < 0) {
 509 #endif
 510                 printf("Failed to get keyboard state from device %04x:%04x\n",
 511                        dev->descriptor.idVendor, dev->descriptor.idProduct);
 512                 /* Abort, we don't want to use that non-functional keyboard. */
 513                 return 0;
 514         }
 515
 516         /* Success. */
 517         return 1;
 518 }
 519
 520 static int probe_usb_keyboard(struct usb_device *dev)
 521 {
 522         char *stdinname;
 523         struct stdio_dev usb_kbd_dev;
 524         int error;
 525
 526         /* Try probing the keyboard */
 527         if (usb_kbd_probe_dev(dev, 0) != 1)
 528                 return -ENOENT;
 529
 530         /* Register the keyboard */
 531         debug("USB KBD: register.\n");
 532         memset(&usb_kbd_dev, 0, sizeof(struct stdio_dev));
 533         strcpy(usb_kbd_dev.name, DEVNAME);
 534         usb_kbd_dev.flags =  DEV_FLAGS_INPUT;
 535         usb_kbd_dev.getc = usb_kbd_getc;
 536         usb_kbd_dev.tstc = usb_kbd_testc;
 537         usb_kbd_dev.priv = (void *)dev;
 538         error = stdio_register(&usb_kbd_dev);
 539         if (error)
 540                 return error;
 541
 542         stdinname = env_get("stdin");
 543 #if CONFIG_IS_ENABLED(CONSOLE_MUX)
 544         error = iomux_doenv(stdin, stdinname);
 545         if (error)
 546                 return error;
 547 #else
 548         /* Check if this is the standard input device. */
 549         if (strcmp(stdinname, DEVNAME))
 550                 return 1;
 551
 552         /* Reassign the console */
 553         if (overwrite_console())
 554                 return 1;
 555
 556         error = console_assign(stdin, DEVNAME);
 557         if (error)
 558                 return error;
 559 #endif
 560
 561         return 0;
 562 }
 563
 564 #if !CONFIG_IS_ENABLED(DM_USB)
 565 /* Search for keyboard and register it if found. */
 566 int drv_usb_kbd_init(void)
 567 {
 568         int error, i;
 569
 570         debug("%s: Probing for keyboard\n", __func__);
 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
 590         /* No USB Keyboard found */
 591         return -1;
 592 }
 593
 594 /* Deregister the keyboard. */
 595 int usb_kbd_deregister(int force)
 596 {
 597 #if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER)
 598         struct stdio_dev *dev;
 599         struct usb_device *usb_kbd_dev;
 600         struct usb_kbd_pdata *data;
 601
 602         dev = stdio_get_by_name(DEVNAME);
 603         if (dev) {
 604                 usb_kbd_dev = (struct usb_device *)dev->priv;
 605                 data = usb_kbd_dev->privptr;
 606                 if (stdio_deregister_dev(dev, force) != 0)
 607                         return 1;
 608 #if CONFIG_IS_ENABLED(CONSOLE_MUX)
 609                 if (iomux_doenv(stdin, env_get("stdin")) != 0)
 610                         return 1;
 611 #endif
 612 #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
 613                 destroy_int_queue(usb_kbd_dev, data->intq);
 614 #endif
 615                 free(data->new);
 616                 free(data);
 617         }
 618
 619         return 0;
 620 #else
 621         return 1;
 622 #endif
 623 }
 624
 625 #endif
 626
 627 #if CONFIG_IS_ENABLED(DM_USB)
 628
 629 static int usb_kbd_probe(struct udevice *dev)
 630 {
 631         struct usb_device *udev = dev_get_parent_priv(dev);
 632
 633         return probe_usb_keyboard(udev);
 634 }
 635
 636 static int usb_kbd_remove(struct udevice *dev)
 637 {
 638         struct usb_device *udev = dev_get_parent_priv(dev);
 639         struct usb_kbd_pdata *data;
 640         struct stdio_dev *sdev;
 641         int ret;
 642
 643         sdev = stdio_get_by_name(DEVNAME);
 644         if (!sdev) {
 645                 ret = -ENXIO;
 646                 goto err;
 647         }
 648         data = udev->privptr;
 649         if (stdio_deregister_dev(sdev, true)) {
 650                 ret = -EPERM;
 651                 goto err;
 652         }
 653 #if CONFIG_IS_ENABLED(CONSOLE_MUX)
 654         if (iomux_doenv(stdin, env_get("stdin"))) {
 655                 ret = -ENOLINK;
 656                 goto err;
 657         }
 658 #endif
 659 #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
 660         destroy_int_queue(udev, data->intq);
 661 #endif
 662         free(data->new);
 663         free(data);
 664
 665         return 0;
 666 err:
 667         printf("%s: warning, ret=%d", __func__, ret);
 668         return ret;
 669 }
 670
 671 static const struct udevice_id usb_kbd_ids[] = {
 672         { .compatible = "usb-keyboard" },
 673         { }
 674 };
 675
 676 U_BOOT_DRIVER(usb_kbd) = {
 677         .name   = "usb_kbd",
 678         .id     = UCLASS_KEYBOARD,
 679         .of_match = usb_kbd_ids,
 680         .probe = usb_kbd_probe,
 681         .remove = usb_kbd_remove,
 682 };
 683
 684 static const struct usb_device_id kbd_id_table[] = {
 685         {
 686                 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
 687                         USB_DEVICE_ID_MATCH_INT_SUBCLASS |
 688                         USB_DEVICE_ID_MATCH_INT_PROTOCOL,
 689                 .bInterfaceClass = USB_CLASS_HID,
 690                 .bInterfaceSubClass = USB_SUB_HID_BOOT,
 691                 .bInterfaceProtocol = USB_PROT_HID_KEYBOARD,
 692         },
 693         { }             /* Terminating entry */
 694 };
 695
 696 U_BOOT_USB_DEVICE(usb_kbd, kbd_id_table);
 697
 698 #endif