common/usb_kbd.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2001
   4  * Denis Peter, MPL AG Switzerland
   5  *
   6  * Part of this source has been derived from the Linux USB
   7  * project.
   8  */
   9 #include <common.h>
  10 #include <console.h>
  11 #include <dm.h>
  12 #include <errno.h>
  13 #include <malloc.h>
  14 #include <memalign.h>
  15 #include <stdio_dev.h>
  16 #include <watchdog.h>
  17 #include <asm/byteorder.h>
  18
  19 #include <usb.h>
  20
  21 /*
  22  * If overwrite_console returns 1, the stdin, stderr and stdout
  23  * are switched to the serial port, else the settings in the
  24  * environment are used
  25  */
  26 #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
  27 extern int overwrite_console(void);
  28 #else
  29 int overwrite_console(void)
  30 {
  31         return 0;
  32 }
  33 #endif
  34
  35 /* Keyboard sampling rate */
  36 #define REPEAT_RATE     40              /* 40msec -> 25cps */
  37 #define REPEAT_DELAY    10              /* 10 x REPEAT_RATE = 400msec */
  38
  39 #define NUM_LOCK        0x53
  40 #define CAPS_LOCK       0x39
  41 #define SCROLL_LOCK     0x47
  42
  43 /* Modifier bits */
  44 #define LEFT_CNTR       (1 << 0)
  45 #define LEFT_SHIFT      (1 << 1)
  46 #define LEFT_ALT        (1 << 2)
  47 #define LEFT_GUI        (1 << 3)
  48 #define RIGHT_CNTR      (1 << 4)
  49 #define RIGHT_SHIFT     (1 << 5)
  50 #define RIGHT_ALT       (1 << 6)
  51 #define RIGHT_GUI       (1 << 7)
  52
  53 /* Size of the keyboard buffer */
  54 #define USB_KBD_BUFFER_LEN      0x20
  55
  56 /* Device name */
  57 #define DEVNAME                 "usbkbd"
  58
  59 /* Keyboard maps */
  60 static const unsigned char usb_kbd_numkey[] = {
  61         '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
  62         '\r', 0x1b, '\b', '\t', ' ', '-', '=', '[', ']',
  63         '\\', '#', ';', '\'', '`', ',', '.', '/'
  64 };
  65 static const unsigned char usb_kbd_numkey_shifted[] = {
  66         '!', '@', '#', '$', '%', '^', '&', '*', '(', ')',
  67         '\r', 0x1b, '\b', '\t', ' ', '_', '+', '{', '}',
  68         '|', '~', ':', '"', '~', '<', '>', '?'
  69 };
  70
  71 static const unsigned char usb_kbd_num_keypad[] = {
  72         '/', '*', '-', '+', '\r',
  73         '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
  74         '.', 0, 0, 0, '='
  75 };
  76
  77 /*
  78  * map arrow keys to ^F/^B ^N/^P, can't really use the proper
  79  * ANSI sequence for arrow keys because the queuing code breaks
  80  * when a single keypress expands to 3 queue elements
  81  */
  82 static const unsigned char usb_kbd_arrow[] = {
  83         0x6, 0x2, 0xe, 0x10
  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 /*
  99  * USB Keyboard reports are 8 bytes in boot protocol.
 100  * Appendix B of HID Device Class Definition 1.11
 101  */
 102 #define USB_KBD_BOOT_REPORT_SIZE 8
 103
 104 struct usb_kbd_pdata {
 105         unsigned long   intpipe;
 106         int             intpktsize;
 107         int             intinterval;
 108         unsigned long   last_report;
 109         struct int_queue *intq;
 110
 111         uint32_t        repeat_delay;
 112
 113         uint32_t        usb_in_pointer;
 114         uint32_t        usb_out_pointer;
 115         uint8_t         usb_kbd_buffer[USB_KBD_BUFFER_LEN];
 116
 117         uint8_t         *new;
 118         uint8_t         old[USB_KBD_BOOT_REPORT_SIZE];
 119
 120         uint8_t         flags;
 121 };
 122
 123 extern int __maybe_unused net_busy_flag;
 124
 125 /* The period of time between two calls of usb_kbd_testc(). */
 126 static unsigned long __maybe_unused kbd_testc_tms;
 127
 128 /* Puts character in the queue and sets up the in and out pointer. */
 129 static void usb_kbd_put_queue(struct usb_kbd_pdata *data, char c)
 130 {
 131         if (data->usb_in_pointer == USB_KBD_BUFFER_LEN - 1) {
 132                 /* Check for buffer full. */
 133                 if (data->usb_out_pointer == 0)
 134                         return;
 135
 136                 data->usb_in_pointer = 0;
 137         } else {
 138                 /* Check for buffer full. */
 139                 if (data->usb_in_pointer == data->usb_out_pointer - 1)
 140                         return;
 141
 142                 data->usb_in_pointer++;
 143         }
 144
 145         data->usb_kbd_buffer[data->usb_in_pointer] = c;
 146 }
 147
 148 static void usb_kbd_put_sequence(struct usb_kbd_pdata *data, char *s)
 149 {
 150         for (; *s; s++)
 151                 usb_kbd_put_queue(data, *s);
 152 }
 153
 154 /*
 155  * Set the LEDs. Since this is used in the irq routine, the control job is
 156  * issued with a timeout of 0. This means, that the job is queued without
 157  * waiting for job completion.
 158  */
 159 static void usb_kbd_setled(struct usb_device *dev)
 160 {
 161         struct usb_interface *iface = &dev->config.if_desc[0];
 162         struct usb_kbd_pdata *data = dev->privptr;
 163         ALLOC_ALIGN_BUFFER(uint32_t, leds, 1, USB_DMA_MINALIGN);
 164
 165         *leds = data->flags & USB_KBD_LEDMASK;
 166         usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 167                 USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 168                 0x200, iface->desc.bInterfaceNumber, leds, 1, 0);
 169 }
 170
 171 #define CAPITAL_MASK    0x20
 172 /* Translate the scancode in ASCII */
 173 static int usb_kbd_translate(struct usb_kbd_pdata *data, unsigned char scancode,
 174                                 unsigned char modifier, int pressed)
 175 {
 176         uint8_t keycode = 0;
 177
 178         /* Key released */
 179         if (pressed == 0) {
 180                 data->repeat_delay = 0;
 181                 return 0;
 182         }
 183
 184         if (pressed == 2) {
 185                 data->repeat_delay++;
 186                 if (data->repeat_delay < REPEAT_DELAY)
 187                         return 0;
 188
 189                 data->repeat_delay = REPEAT_DELAY;
 190         }
 191
 192         /* Alphanumeric values */
 193         if ((scancode > 3) && (scancode <= 0x1d)) {
 194                 keycode = scancode - 4 + 'a';
 195
 196                 if (data->flags & USB_KBD_CAPSLOCK)
 197                         keycode &= ~CAPITAL_MASK;
 198
 199                 if (modifier & (LEFT_SHIFT | RIGHT_SHIFT)) {
 200                         /* Handle CAPSLock + Shift pressed simultaneously */
 201                         if (keycode & CAPITAL_MASK)
 202                                 keycode &= ~CAPITAL_MASK;
 203                         else
 204                                 keycode |= CAPITAL_MASK;
 205                 }
 206         }
 207
 208         if ((scancode > 0x1d) && (scancode < 0x39)) {
 209                 /* Shift pressed */
 210                 if (modifier & (LEFT_SHIFT | RIGHT_SHIFT))
 211                         keycode = usb_kbd_numkey_shifted[scancode - 0x1e];
 212                 else
 213                         keycode = usb_kbd_numkey[scancode - 0x1e];
 214         }
 215
 216         /* Arrow keys */
 217         if ((scancode >= 0x4f) && (scancode <= 0x52))
 218                 keycode = usb_kbd_arrow[scancode - 0x4f];
 219
 220         /* Numeric keypad */
 221         if ((scancode >= 0x54) && (scancode <= 0x67))
 222                 keycode = usb_kbd_num_keypad[scancode - 0x54];
 223
 224         if (data->flags & USB_KBD_CTRL)
 225                 keycode = scancode - 0x3;
 226
 227         if (pressed == 1) {
 228                 if (scancode == NUM_LOCK) {
 229                         data->flags ^= USB_KBD_NUMLOCK;
 230                         return 1;
 231                 }
 232
 233                 if (scancode == CAPS_LOCK) {
 234                         data->flags ^= USB_KBD_CAPSLOCK;
 235                         return 1;
 236                 }
 237                 if (scancode == SCROLL_LOCK) {
 238                         data->flags ^= USB_KBD_SCROLLLOCK;
 239                         return 1;
 240                 }
 241         }
 242
 243         /* Report keycode if any */
 244         if (keycode)
 245                 debug("%c", keycode);
 246
 247         switch (keycode) {
 248         case 0x0e:                                      /* Down arrow key */
 249                 usb_kbd_put_sequence(data, "\e[B");
 250                 break;
 251         case 0x10:                                      /* Up arrow key */
 252                 usb_kbd_put_sequence(data, "\e[A");
 253                 break;
 254         case 0x06:                                      /* Right arrow key */
 255                 usb_kbd_put_sequence(data, "\e[C");
 256                 break;
 257         case 0x02:                                      /* Left arrow key */
 258                 usb_kbd_put_sequence(data, "\e[D");
 259                 break;
 260         default:
 261                 usb_kbd_put_queue(data, keycode);
 262                 break;
 263         }
 264
 265         return 0;
 266 }
 267
 268 static uint32_t usb_kbd_service_key(struct usb_device *dev, int i, int up)
 269 {
 270         uint32_t res = 0;
 271         struct usb_kbd_pdata *data = dev->privptr;
 272         uint8_t *new;
 273         uint8_t *old;
 274
 275         if (up) {
 276                 new = data->old;
 277                 old = data->new;
 278         } else {
 279                 new = data->new;
 280                 old = data->old;
 281         }
 282
 283         if ((old[i] > 3) &&
 284             (memscan(new + 2, old[i], USB_KBD_BOOT_REPORT_SIZE - 2) ==
 285                         new + USB_KBD_BOOT_REPORT_SIZE)) {
 286                 res |= usb_kbd_translate(data, old[i], data->new[0], up);
 287         }
 288
 289         return res;
 290 }
 291
 292 /* Interrupt service routine */
 293 static int usb_kbd_irq_worker(struct usb_device *dev)
 294 {
 295         struct usb_kbd_pdata *data = dev->privptr;
 296         int i, res = 0;
 297
 298         /* No combo key pressed */
 299         if (data->new[0] == 0x00)
 300                 data->flags &= ~USB_KBD_CTRL;
 301         /* Left or Right Ctrl pressed */
 302         else if ((data->new[0] == LEFT_CNTR) || (data->new[0] == RIGHT_CNTR))
 303                 data->flags |= USB_KBD_CTRL;
 304
 305         for (i = 2; i < USB_KBD_BOOT_REPORT_SIZE; i++) {
 306                 res |= usb_kbd_service_key(dev, i, 0);
 307                 res |= usb_kbd_service_key(dev, i, 1);
 308         }
 309
 310         /* Key is still pressed */
 311         if ((data->new[2] > 3) && (data->old[2] == data->new[2]))
 312                 res |= usb_kbd_translate(data, data->new[2], data->new[0], 2);
 313
 314         if (res == 1)
 315                 usb_kbd_setled(dev);
 316
 317         memcpy(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE);
 318
 319         return 1;
 320 }
 321
 322 /* Keyboard interrupt handler */
 323 static int usb_kbd_irq(struct usb_device *dev)
 324 {
 325         if ((dev->irq_status != 0) ||
 326             (dev->irq_act_len != USB_KBD_BOOT_REPORT_SIZE)) {
 327                 debug("USB KBD: Error %lX, len %d\n",
 328                       dev->irq_status, dev->irq_act_len);
 329                 return 1;
 330         }
 331
 332         return usb_kbd_irq_worker(dev);
 333 }
 334
 335 /* Interrupt polling */
 336 static inline void usb_kbd_poll_for_event(struct usb_device *dev)
 337 {
 338 #if defined(CONFIG_SYS_USB_EVENT_POLL)
 339         struct usb_kbd_pdata *data = dev->privptr;
 340
 341         /* Submit a interrupt transfer request */
 342         usb_submit_int_msg(dev, data->intpipe, &data->new[0], data->intpktsize,
 343                            data->intinterval);
 344
 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_submit_int_msg(dev, data->intpipe, data->new, data->intpktsize,
 508                                data->intinterval) < 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