common/usb_kbd.c

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