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 <errno.h> 12 #include <malloc.h> 13 #include <stdio_dev.h> 14 #include <asm/byteorder.h> 15 16 #include <usb.h> 17 18 /* 19 * If overwrite_console returns 1, the stdin, stderr and stdout 20 * are switched to the serial port, else the settings in the 21 * environment are used 22 */ 23 #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE 24 extern int overwrite_console(void); 25 #else 26 int overwrite_console(void) 27 { 28 return 0; 29 } 30 #endif 31 32 /* Keyboard sampling rate */ 33 #define REPEAT_RATE (40 / 4) /* 40msec -> 25cps */ 34 #define REPEAT_DELAY 10 /* 10 x REPEAT_RATE = 400msec */ 35 36 #define NUM_LOCK 0x53 37 #define CAPS_LOCK 0x39 38 #define SCROLL_LOCK 0x47 39 40 /* Modifier bits */ 41 #define LEFT_CNTR (1 << 0) 42 #define LEFT_SHIFT (1 << 1) 43 #define LEFT_ALT (1 << 2) 44 #define LEFT_GUI (1 << 3) 45 #define RIGHT_CNTR (1 << 4) 46 #define RIGHT_SHIFT (1 << 5) 47 #define RIGHT_ALT (1 << 6) 48 #define RIGHT_GUI (1 << 7) 49 50 /* Size of the keyboard buffer */ 51 #define USB_KBD_BUFFER_LEN 0x20 52 53 /* Device name */ 54 #define DEVNAME "usbkbd" 55 56 /* Keyboard maps */ 57 static const unsigned char usb_kbd_numkey[] = { 58 '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 59 '\r', 0x1b, '\b', '\t', ' ', '-', '=', '[', ']', 60 '\\', '#', ';', '\'', '`', ',', '.', '/' 61 }; 62 static const unsigned char usb_kbd_numkey_shifted[] = { 63 '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', 64 '\r', 0x1b, '\b', '\t', ' ', '_', '+', '{', '}', 65 '|', '~', ':', '"', '~', '<', '>', '?' 66 }; 67 68 static const unsigned char usb_kbd_num_keypad[] = { 69 '/', '*', '-', '+', '\r', 70 '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 71 '.', 0, 0, 0, '=' 72 }; 73 74 /* 75 * map arrow keys to ^F/^B ^N/^P, can't really use the proper 76 * ANSI sequence for arrow keys because the queuing code breaks 77 * when a single keypress expands to 3 queue elements 78 */ 79 static const unsigned char usb_kbd_arrow[] = { 80 0x6, 0x2, 0xe, 0x10 81 }; 82 83 /* 84 * NOTE: It's important for the NUM, CAPS, SCROLL-lock bits to be in this 85 * order. See usb_kbd_setled() function! 86 */ 87 #define USB_KBD_NUMLOCK (1 << 0) 88 #define USB_KBD_CAPSLOCK (1 << 1) 89 #define USB_KBD_SCROLLLOCK (1 << 2) 90 #define USB_KBD_CTRL (1 << 3) 91 92 #define USB_KBD_LEDMASK \ 93 (USB_KBD_NUMLOCK | USB_KBD_CAPSLOCK | USB_KBD_SCROLLLOCK) 94 95 /* 96 * USB Keyboard reports are 8 bytes in boot protocol. 97 * Appendix B of HID Device Class Definition 1.11 98 */ 99 #define USB_KBD_BOOT_REPORT_SIZE 8 100 101 struct usb_kbd_pdata { 102 uint32_t repeat_delay; 103 104 uint32_t usb_in_pointer; 105 uint32_t usb_out_pointer; 106 uint8_t usb_kbd_buffer[USB_KBD_BUFFER_LEN]; 107 108 uint8_t *new; 109 uint8_t old[USB_KBD_BOOT_REPORT_SIZE]; 110 111 uint8_t flags; 112 }; 113 114 extern int __maybe_unused net_busy_flag; 115 116 /* The period of time between two calls of usb_kbd_testc(). */ 117 static unsigned long __maybe_unused kbd_testc_tms; 118 119 /* Puts character in the queue and sets up the in and out pointer. */ 120 static void usb_kbd_put_queue(struct usb_kbd_pdata *data, char c) 121 { 122 if (data->usb_in_pointer == USB_KBD_BUFFER_LEN - 1) { 123 /* Check for buffer full. */ 124 if (data->usb_out_pointer == 0) 125 return; 126 127 data->usb_in_pointer = 0; 128 } else { 129 /* Check for buffer full. */ 130 if (data->usb_in_pointer == data->usb_out_pointer - 1) 131 return; 132 133 data->usb_in_pointer++; 134 } 135 136 data->usb_kbd_buffer[data->usb_in_pointer] = c; 137 } 138 139 /* 140 * Set the LEDs. Since this is used in the irq routine, the control job is 141 * issued with a timeout of 0. This means, that the job is queued without 142 * waiting for job completion. 143 */ 144 static void usb_kbd_setled(struct usb_device *dev) 145 { 146 struct usb_interface *iface = &dev->config.if_desc[0]; 147 struct usb_kbd_pdata *data = dev->privptr; 148 ALLOC_ALIGN_BUFFER(uint32_t, leds, 1, USB_DMA_MINALIGN); 149 150 *leds = data->flags & USB_KBD_LEDMASK; 151 usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 152 USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 153 0x200, iface->desc.bInterfaceNumber, leds, 1, 0); 154 } 155 156 #define CAPITAL_MASK 0x20 157 /* Translate the scancode in ASCII */ 158 static int usb_kbd_translate(struct usb_kbd_pdata *data, unsigned char scancode, 159 unsigned char modifier, int pressed) 160 { 161 uint8_t keycode = 0; 162 163 /* Key released */ 164 if (pressed == 0) { 165 data->repeat_delay = 0; 166 return 0; 167 } 168 169 if (pressed == 2) { 170 data->repeat_delay++; 171 if (data->repeat_delay < REPEAT_DELAY) 172 return 0; 173 174 data->repeat_delay = REPEAT_DELAY; 175 } 176 177 /* Alphanumeric values */ 178 if ((scancode > 3) && (scancode <= 0x1d)) { 179 keycode = scancode - 4 + 'a'; 180 181 if (data->flags & USB_KBD_CAPSLOCK) 182 keycode &= ~CAPITAL_MASK; 183 184 if (modifier & (LEFT_SHIFT | RIGHT_SHIFT)) { 185 /* Handle CAPSLock + Shift pressed simultaneously */ 186 if (keycode & CAPITAL_MASK) 187 keycode &= ~CAPITAL_MASK; 188 else 189 keycode |= CAPITAL_MASK; 190 } 191 } 192 193 if ((scancode > 0x1d) && (scancode < 0x3a)) { 194 /* Shift pressed */ 195 if (modifier & (LEFT_SHIFT | RIGHT_SHIFT)) 196 keycode = usb_kbd_numkey_shifted[scancode - 0x1e]; 197 else 198 keycode = usb_kbd_numkey[scancode - 0x1e]; 199 } 200 201 /* Arrow keys */ 202 if ((scancode >= 0x4f) && (scancode <= 0x52)) 203 keycode = usb_kbd_arrow[scancode - 0x4f]; 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 } 233 234 return 0; 235 } 236 237 static uint32_t usb_kbd_service_key(struct usb_device *dev, int i, int up) 238 { 239 uint32_t res = 0; 240 struct usb_kbd_pdata *data = dev->privptr; 241 uint8_t *new; 242 uint8_t *old; 243 244 if (up) { 245 new = data->old; 246 old = data->new; 247 } else { 248 new = data->new; 249 old = data->old; 250 } 251 252 if ((old[i] > 3) && 253 (memscan(new + 2, old[i], USB_KBD_BOOT_REPORT_SIZE - 2) == 254 new + USB_KBD_BOOT_REPORT_SIZE)) { 255 res |= usb_kbd_translate(data, old[i], data->new[0], up); 256 } 257 258 return res; 259 } 260 261 /* Interrupt service routine */ 262 static int usb_kbd_irq_worker(struct usb_device *dev) 263 { 264 struct usb_kbd_pdata *data = dev->privptr; 265 int i, res = 0; 266 267 /* No combo key pressed */ 268 if (data->new[0] == 0x00) 269 data->flags &= ~USB_KBD_CTRL; 270 /* Left or Right Ctrl pressed */ 271 else if ((data->new[0] == LEFT_CNTR) || (data->new[0] == RIGHT_CNTR)) 272 data->flags |= USB_KBD_CTRL; 273 274 for (i = 2; i < USB_KBD_BOOT_REPORT_SIZE; i++) { 275 res |= usb_kbd_service_key(dev, i, 0); 276 res |= usb_kbd_service_key(dev, i, 1); 277 } 278 279 /* Key is still pressed */ 280 if ((data->new[2] > 3) && (data->old[2] == data->new[2])) 281 res |= usb_kbd_translate(data, data->new[2], data->new[0], 2); 282 283 if (res == 1) 284 usb_kbd_setled(dev); 285 286 memcpy(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE); 287 288 return 1; 289 } 290 291 /* Keyboard interrupt handler */ 292 static int usb_kbd_irq(struct usb_device *dev) 293 { 294 if ((dev->irq_status != 0) || 295 (dev->irq_act_len != USB_KBD_BOOT_REPORT_SIZE)) { 296 debug("USB KBD: Error %lX, len %d\n", 297 dev->irq_status, dev->irq_act_len); 298 return 1; 299 } 300 301 return usb_kbd_irq_worker(dev); 302 } 303 304 /* Interrupt polling */ 305 static inline void usb_kbd_poll_for_event(struct usb_device *dev) 306 { 307 #if defined(CONFIG_SYS_USB_EVENT_POLL) 308 struct usb_interface *iface; 309 struct usb_endpoint_descriptor *ep; 310 struct usb_kbd_pdata *data; 311 int pipe; 312 int maxp; 313 314 /* Get the pointer to USB Keyboard device pointer */ 315 data = dev->privptr; 316 iface = &dev->config.if_desc[0]; 317 ep = &iface->ep_desc[0]; 318 pipe = usb_rcvintpipe(dev, ep->bEndpointAddress); 319 320 /* Submit a interrupt transfer request */ 321 maxp = usb_maxpacket(dev, pipe); 322 usb_submit_int_msg(dev, pipe, &data->new[0], 323 min(maxp, USB_KBD_BOOT_REPORT_SIZE), 324 ep->bInterval); 325 326 usb_kbd_irq_worker(dev); 327 #elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) 328 struct usb_interface *iface; 329 struct usb_kbd_pdata *data = dev->privptr; 330 iface = &dev->config.if_desc[0]; 331 usb_get_report(dev, iface->desc.bInterfaceNumber, 332 1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE); 333 if (memcmp(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE)) 334 usb_kbd_irq_worker(dev); 335 #endif 336 } 337 338 /* test if a character is in the queue */ 339 static int usb_kbd_testc(struct stdio_dev *sdev) 340 { 341 struct stdio_dev *dev; 342 struct usb_device *usb_kbd_dev; 343 struct usb_kbd_pdata *data; 344 345 #ifdef CONFIG_CMD_NET 346 /* 347 * If net_busy_flag is 1, NET transfer is running, 348 * then we check key-pressed every second (first check may be 349 * less than 1 second) to improve TFTP booting performance. 350 */ 351 if (net_busy_flag && (get_timer(kbd_testc_tms) < CONFIG_SYS_HZ)) 352 return 0; 353 kbd_testc_tms = get_timer(0); 354 #endif 355 dev = stdio_get_by_name(DEVNAME); 356 usb_kbd_dev = (struct usb_device *)dev->priv; 357 data = usb_kbd_dev->privptr; 358 359 usb_kbd_poll_for_event(usb_kbd_dev); 360 361 return !(data->usb_in_pointer == data->usb_out_pointer); 362 } 363 364 /* gets the character from the queue */ 365 static int usb_kbd_getc(struct stdio_dev *sdev) 366 { 367 struct stdio_dev *dev; 368 struct usb_device *usb_kbd_dev; 369 struct usb_kbd_pdata *data; 370 371 dev = stdio_get_by_name(DEVNAME); 372 usb_kbd_dev = (struct usb_device *)dev->priv; 373 data = usb_kbd_dev->privptr; 374 375 while (data->usb_in_pointer == data->usb_out_pointer) 376 usb_kbd_poll_for_event(usb_kbd_dev); 377 378 if (data->usb_out_pointer == USB_KBD_BUFFER_LEN - 1) 379 data->usb_out_pointer = 0; 380 else 381 data->usb_out_pointer++; 382 383 return data->usb_kbd_buffer[data->usb_out_pointer]; 384 } 385 386 /* probes the USB device dev for keyboard type. */ 387 static int usb_kbd_probe(struct usb_device *dev, unsigned int ifnum) 388 { 389 struct usb_interface *iface; 390 struct usb_endpoint_descriptor *ep; 391 struct usb_kbd_pdata *data; 392 int pipe, maxp; 393 394 if (dev->descriptor.bNumConfigurations != 1) 395 return 0; 396 397 iface = &dev->config.if_desc[ifnum]; 398 399 if (iface->desc.bInterfaceClass != 3) 400 return 0; 401 402 if (iface->desc.bInterfaceSubClass != 1) 403 return 0; 404 405 if (iface->desc.bInterfaceProtocol != 1) 406 return 0; 407 408 if (iface->desc.bNumEndpoints != 1) 409 return 0; 410 411 ep = &iface->ep_desc[0]; 412 413 /* Check if endpoint 1 is interrupt endpoint */ 414 if (!(ep->bEndpointAddress & 0x80)) 415 return 0; 416 417 if ((ep->bmAttributes & 3) != 3) 418 return 0; 419 420 debug("USB KBD: found set protocol...\n"); 421 422 data = malloc(sizeof(struct usb_kbd_pdata)); 423 if (!data) { 424 printf("USB KBD: Error allocating private data\n"); 425 return 0; 426 } 427 428 /* Clear private data */ 429 memset(data, 0, sizeof(struct usb_kbd_pdata)); 430 431 /* allocate input buffer aligned and sized to USB DMA alignment */ 432 data->new = memalign(USB_DMA_MINALIGN, 433 roundup(USB_KBD_BOOT_REPORT_SIZE, USB_DMA_MINALIGN)); 434 435 /* Insert private data into USB device structure */ 436 dev->privptr = data; 437 438 /* Set IRQ handler */ 439 dev->irq_handle = usb_kbd_irq; 440 441 pipe = usb_rcvintpipe(dev, ep->bEndpointAddress); 442 maxp = usb_maxpacket(dev, pipe); 443 444 /* We found a USB Keyboard, install it. */ 445 usb_set_protocol(dev, iface->desc.bInterfaceNumber, 0); 446 447 debug("USB KBD: found set idle...\n"); 448 usb_set_idle(dev, iface->desc.bInterfaceNumber, REPEAT_RATE, 0); 449 450 debug("USB KBD: enable interrupt pipe...\n"); 451 if (usb_submit_int_msg(dev, pipe, data->new, 452 min(maxp, USB_KBD_BOOT_REPORT_SIZE), 453 ep->bInterval) < 0) { 454 printf("Failed to get keyboard state from device %04x:%04x\n", 455 dev->descriptor.idVendor, dev->descriptor.idProduct); 456 /* Abort, we don't want to use that non-functional keyboard. */ 457 return 0; 458 } 459 460 /* Success. */ 461 return 1; 462 } 463 464 /* Search for keyboard and register it if found. */ 465 int drv_usb_kbd_init(void) 466 { 467 struct stdio_dev usb_kbd_dev; 468 struct usb_device *dev; 469 char *stdinname = getenv("stdin"); 470 int error, i; 471 472 /* Scan all USB Devices */ 473 for (i = 0; i < USB_MAX_DEVICE; i++) { 474 /* Get USB device. */ 475 dev = usb_get_dev_index(i); 476 if (!dev) 477 return -1; 478 479 if (dev->devnum == -1) 480 continue; 481 482 /* Try probing the keyboard */ 483 if (usb_kbd_probe(dev, 0) != 1) 484 continue; 485 486 /* Register the keyboard */ 487 debug("USB KBD: register.\n"); 488 memset(&usb_kbd_dev, 0, sizeof(struct stdio_dev)); 489 strcpy(usb_kbd_dev.name, DEVNAME); 490 usb_kbd_dev.flags = DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM; 491 usb_kbd_dev.getc = usb_kbd_getc; 492 usb_kbd_dev.tstc = usb_kbd_testc; 493 usb_kbd_dev.priv = (void *)dev; 494 error = stdio_register(&usb_kbd_dev); 495 if (error) 496 return error; 497 498 #ifdef CONFIG_CONSOLE_MUX 499 error = iomux_doenv(stdin, stdinname); 500 if (error) 501 return error; 502 #else 503 /* Check if this is the standard input device. */ 504 if (strcmp(stdinname, DEVNAME)) 505 return 1; 506 507 /* Reassign the console */ 508 if (overwrite_console()) 509 return 1; 510 511 error = console_assign(stdin, DEVNAME); 512 if (error) 513 return error; 514 #endif 515 516 return 1; 517 } 518 519 /* No USB Keyboard found */ 520 return -1; 521 } 522 523 /* Deregister the keyboard. */ 524 int usb_kbd_deregister(int force) 525 { 526 #ifdef CONFIG_SYS_STDIO_DEREGISTER 527 struct stdio_dev *dev; 528 struct usb_device *usb_kbd_dev; 529 struct usb_kbd_pdata *data; 530 531 dev = stdio_get_by_name(DEVNAME); 532 if (dev) { 533 usb_kbd_dev = (struct usb_device *)dev->priv; 534 data = usb_kbd_dev->privptr; 535 if (stdio_deregister_dev(dev, force) != 0) 536 return 1; 537 free(data->new); 538 free(data); 539 } 540 541 return 0; 542 #else 543 return 1; 544 #endif 545 } 546