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