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