qemu/roms/SLOF/lib/libusb/usb-hid.c

   1 /*****************************************************************************
   2  * Copyright (c) 2013 IBM Corporation
   3  * All rights reserved.
   4  * This program and the accompanying materials
   5  * are made available under the terms of the BSD License
   6  * which accompanies this distribution, and is available at
   7  * http://www.opensource.org/licenses/bsd-license.php
   8  *
   9  * Contributors:
  10  *     IBM Corporation - initial implementation
  11  *****************************************************************************/
  12
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <termctrl.h>
  16
  17 #include "usb-core.h"
  18 #include "usb-key.h"
  19
  20 /*
  21  * HID Spec Version 1.11
  22  */
  23
  24 #define HID_REQ_GET_REPORT              0x01
  25 #define HID_REQ_GET_IDLE                0x02
  26 #define HID_REQ_GET_PROTOCOL            0x03
  27 #define HID_REQ_SET_REPORT              0x09
  28 #define HID_REQ_SET_IDLE                0x0A
  29 #define HID_REQ_SET_PROTOCOL            0x0B
  30
  31 //key position for latin letters
  32 #define KEYP_LATIN_A 4
  33 #define KEYP_LATIN_Z 29
  34
  35 //#define KEY_DEBUG
  36
  37 /* HID SPEC - 7.2.6 Set_Protocol Request */
  38 static int usb_hid_set_protocol(struct usb_dev *dev, uint16_t value)
  39 {
  40         struct usb_dev_req req;
  41         if (!dev)
  42                 return false;
  43         req.bmRequestType = REQT_TYPE_CLASS | REQT_REC_INTERFACE | REQT_DIR_OUT;
  44         req.bRequest = HID_REQ_SET_PROTOCOL;
  45         req.wValue = cpu_to_le16(value);
  46         req.wIndex = cpu_to_le16(dev->intf_num);
  47         req.wLength = 0;
  48         return usb_send_ctrl(dev->control, &req, NULL);
  49 }
  50
  51 /* HID SPEC - 7.2.4 Set_Idle Request */
  52 static int usb_hid_set_idle(struct usb_dev *dev, uint16_t ms_delay)
  53 {
  54         struct usb_dev_req req;
  55         if (!dev)
  56                 return false;
  57         req.bmRequestType = REQT_TYPE_CLASS | REQT_REC_INTERFACE | REQT_DIR_OUT;
  58         req.bRequest = HID_REQ_SET_IDLE;
  59         req.wValue = cpu_to_le16((ms_delay/4) << 8);
  60         req.wIndex = cpu_to_le16(dev->intf_num);
  61         req.wLength = 0;
  62         return usb_send_ctrl(dev->control, &req, NULL);
  63 }
  64
  65 /* HID SPEC - 7.2.1 Get Report Request */
  66 static int usb_hid_get_report(struct usb_dev *dev, void *data, size_t size)
  67 {
  68         struct usb_dev_req req;
  69         if (!dev)
  70                 return false;
  71         req.bmRequestType = REQT_TYPE_CLASS | REQT_REC_INTERFACE | REQT_DIR_IN;
  72         req.bRequest = HID_REQ_GET_REPORT;
  73         req.wIndex = cpu_to_le16(dev->intf_num);
  74
  75         req.wLength = cpu_to_le16((uint16_t)size);
  76         req.wValue = cpu_to_le16(1 << 8);
  77         return usb_send_ctrl(dev->control, &req, data);
  78 }
  79
  80 /* ring buffer with RD/WR indices for key buffering */
  81 static uint8_t keybuf[256];     /* size fixed to byte range !   */
  82 uint8_t r_ptr = 0;              /* RD-index for Keyboard-Buffer */
  83 uint8_t w_ptr = 0;              /* WR-index for Keyboard-Buffer */
  84
  85 /* variables for LED status */
  86 uint8_t set_leds;
  87 const uint8_t *key_std       = NULL;
  88 const uint8_t *key_std_shift = NULL;
  89
  90 uint8_t ctrl; /* modifiers */
  91
  92 /**
  93  * read character from Keyboard-Buffer
  94  *
  95  * @param   -
  96  * @return  > 0  Keycode
  97  *          = 0  if no key available
  98  */
  99 static int read_key(void)
 100 {
 101         if (r_ptr != w_ptr)
 102                 return (int)keybuf[r_ptr++];
 103         else
 104                 return false;
 105 }
 106
 107 /**
 108  * Store character into Keyboard-Buffer
 109  *
 110  * @param   Key = detected ASCII-Key (> 0)
 111  * @return  -
 112  */
 113 static void write_key(uint8_t key)
 114 {
 115         if ((w_ptr + 1) != r_ptr)
 116                 keybuf[w_ptr++] = key;
 117 }
 118
 119 /**
 120  * Checks if keypos is a latin key
 121  * @param  keypos
 122  * @return -
 123  */
 124 static bool is_latin(uint8_t keypos)
 125 {
 126         return keypos >= KEYP_LATIN_A && keypos <= KEYP_LATIN_Z;
 127 }
 128
 129 /**
 130  * Convert keyboard usage-ID to ANSI-Code
 131  *
 132  * @param   Ctrl=Modifier Byte
 133  *          Key =Usage ID from USB Keyboard
 134  * @return  -
 135  */
 136 static void get_char(uint8_t ctrl, uint8_t keypos)
 137 {
 138         uint8_t ch;
 139         bool caps = false;
 140
 141 #ifdef KEY_DEBUG
 142         printf("pos %02X\n", keypos);
 143 #endif
 144
 145         if (set_leds & LED_CAPS_LOCK)                   /* is CAPS Lock set ? */
 146                 caps = true;
 147
 148         /* caps is a shift only for latin chars */
 149         if ((!caps && ctrl == 0) || (caps && !is_latin(keypos))) {
 150                 ch = key_std[keypos];
 151                 if (ch != 0)
 152                         write_key(ch);
 153                 return;
 154         }
 155
 156         if ((ctrl & MODIFIER_SHIFT) || caps) {
 157                 ch = key_std_shift[keypos];
 158                 if (ch != 0)
 159                         write_key(ch);
 160                 return;
 161         }
 162
 163         if (ctrl & MODIFIER_CTRL) {
 164                 ch = keycodes_ctrl[keypos];
 165                 if (ch != 0)
 166                         write_key(ch);
 167                 return;
 168         }
 169
 170         if (ctrl == MODIFIER_ALT_GR) {
 171                 ch = keycodes_alt_GR[keypos];
 172                 if (ch != 0)
 173                         write_key(ch);
 174                 return;
 175         }
 176 }
 177
 178 static void check_key_code(uint8_t *buf)
 179 {
 180         static uint8_t key_last[6];                 /* list of processed keys */
 181         uint8_t i, j, key_pos;
 182
 183         /* set translation table to defaults */
 184         if ((key_std == NULL) || (key_std_shift == NULL)) {
 185                 key_std       = keycodes_std_US;
 186                 key_std_shift = keycodes_shift_US;
 187         }
 188
 189         if (buf[0] & MODIFIER_SHIFT)       /* any shift key pressed ? */
 190                 set_leds &= ~LED_CAPS_LOCK;       /* CAPS-LOCK-LED always off */
 191
 192         i = 2;  /* skip modifier byte and reserved byte */
 193         while (i < 8) {
 194                 key_pos = buf[i];
 195                 if ((key_pos != 0) && (key_pos <= 100)) {    /* support for 101 keys */
 196                         j = 0;
 197                         /* search if already processed */
 198                         while ((j < 6) && (key_pos != key_last[j]))
 199                                 j++;
 200
 201                         if (j >= 6) {          /* not found (= not processed) */
 202                                 switch (key_pos) {
 203                                 case 0x39:                 /* caps-lock key ? */
 204                                 case 0x32:                 /* caps-lock key ? */
 205                                         set_leds ^= LED_CAPS_LOCK;
 206                                         break;
 207
 208                                 case 0x36:                              /*Shift pressed*/
 209                                         ctrl |= MODIFIER_SHIFT;
 210                                         break;
 211                                 case 0xb6:                              /*Shift unpressed*/
 212                                         ctrl &= ~MODIFIER_SHIFT;
 213                                         break;
 214                                 case 0x3a:                              /* F1 */
 215                                         write_key(0x1b);
 216                                         write_key(0x5b);
 217                                         write_key(0x4f);
 218                                         write_key(0x50);
 219                                         break;
 220
 221                                 case 0x3b:                              /* F2 */
 222                                         write_key(0x1b);
 223                                         write_key(0x5b);
 224                                         write_key(0x4f);
 225                                         write_key(0x51);
 226                                         break;
 227
 228                                 case 0x3c:
 229                                         write_key(0x1b);               /* F3 */
 230                                         write_key(0x5b);
 231                                         write_key(0x4f);
 232                                         write_key(0x52);
 233                                         break;
 234
 235                                 case 0x3d:
 236                                         write_key(0x1b);                /* F4 */
 237                                         write_key(0x5b);
 238                                         write_key(0x4f);
 239                                         write_key(0x53);
 240                                         break;
 241
 242                                 case 0x3e:
 243                                         write_key(0x1b);                /* F5 */
 244                                         write_key(0x5b);
 245                                         write_key(0x31);
 246                                         write_key(0x35);
 247                                         write_key(0x7e);
 248                                         break;
 249
 250                                 case 0x3f:
 251                                         write_key(0x1b);                /* F6 */
 252                                         write_key(0x5b);
 253                                         write_key(0x31);
 254                                         write_key(0x37);
 255                                         write_key(0x7e);
 256                                         break;
 257
 258                                 case 0x40:
 259                                         write_key(0x1b);                /* F7 */
 260                                         write_key(0x5b);
 261                                         write_key(0x31);
 262                                         write_key(0x38);
 263                                         write_key(0x7e);
 264                                         break;
 265
 266                                 case 0x41:
 267                                         write_key(0x1b);                /* F8 */
 268                                         write_key(0x5b);
 269                                         write_key(0x31);
 270                                         write_key(0x39);
 271                                         write_key(0x7e);
 272                                         break;
 273
 274                                 case 0x42:
 275                                         write_key(0x1b);                /* F9 */
 276                                         write_key(0x5b);
 277                                         write_key(0x32);
 278                                         write_key(0x30);
 279                                         write_key(0x7e);
 280                                         break;
 281
 282                                 case 0x43:
 283                                         write_key(0x1b);               /* F10 */
 284                                         write_key(0x5b);
 285                                         write_key(0x32);
 286                                         write_key(0x31);
 287                                         write_key(0x7e);
 288                                         break;
 289
 290                                 case 0x44:
 291                                         write_key(0x1b);               /* F11 */
 292                                         write_key(0x5b);
 293                                         write_key(0x32);
 294                                         write_key(0x33);
 295                                         write_key(0x7e);
 296                                         break;
 297
 298                                 case 0x45:
 299                                         write_key(0x1b);               /* F12 */
 300                                         write_key(0x5b);
 301                                         write_key(0x32);
 302                                         write_key(0x34);
 303                                         write_key(0x7e);
 304                                         break;
 305
 306                                 case 0x47:               /* scroll-lock key ? */
 307                                         set_leds ^= LED_SCROLL_LOCK;
 308                                         break;
 309
 310                                 case 0x49:
 311                                         write_key(0x1b);               /* INS */
 312                                         write_key(0x5b);
 313                                         write_key(0x32);
 314                                         write_key(0x7e);
 315                                         break;
 316
 317                                 case 0x4a:
 318                                         write_key(0x1b);              /* HOME */
 319                                         write_key(0x4f);
 320                                         write_key(0x48);
 321                                         break;
 322
 323                                 case 0x4b:
 324                                         write_key(0x1b);              /* PgUp */
 325                                         write_key(0x5b);
 326                                         write_key(0x35);
 327                                         write_key(0x7e);
 328                                         break;
 329
 330                                 case 0x4c:
 331                                         write_key(0x1b);               /* DEL */
 332                                         write_key(0x5b);
 333                                         write_key(0x33);
 334                                         write_key(0x7e);
 335                                         break;
 336
 337                                 case 0x4d:
 338                                         write_key(0x1b);               /* END */
 339                                         write_key(0x4f);
 340                                         write_key(0x46);
 341                                         break;
 342
 343                                 case 0x4e:
 344                                         write_key(0x1b);              /* PgDn */
 345                                         write_key(0x5b);
 346                                         write_key(0x36);
 347                                         write_key(0x7e);
 348                                         break;
 349
 350                                 case 0x4f:
 351                                         write_key(0x1b);           /* R-Arrow */
 352                                         write_key(0x5b);
 353                                         write_key(0x43);
 354                                         break;
 355
 356                                 case 0x50:
 357                                         write_key(0x1b);           /* L-Arrow */
 358                                         write_key(0x5b);
 359                                         write_key(0x44);
 360                                         break;
 361
 362                                 case 0x51:
 363                                         write_key(0x1b);           /* D-Arrow */
 364                                         write_key(0x5b);
 365                                         write_key(0x42);
 366                                         break;
 367
 368                                 case 0x52:
 369                                         write_key(0x1b);           /* U-Arrow */
 370                                         write_key(0x5b);
 371                                         write_key(0x41);
 372                                         break;
 373
 374                                 case 0x53:                  /* num-lock key ? */
 375                                         set_leds ^= LED_NUM_LOCK;
 376                                         break;
 377
 378                                 default:
 379                                         /* convert key position to ASCII code */
 380                                         get_char(buf[0], key_pos);
 381                                         break;
 382                                 }
 383                         }
 384                 }
 385                 i++;
 386         }
 387         /*****************************************/
 388         /* all keys are processed, create a copy */
 389         /* to flag them as processed             */
 390         /*****************************************/
 391         for (i = 2, j = 0; j < 6; i++, j++)
 392                 key_last[j] = buf[i];      /* copy all actual keys to last */
 393 }
 394
 395 #define USB_HID_SIZE 128
 396 uint32_t *kbd_buffer;
 397
 398 int usb_hid_kbd_init(struct usb_dev *dev)
 399 {
 400         int i;
 401         uint8_t key[8];
 402
 403         usb_hid_set_protocol(dev, 0);
 404         usb_hid_set_idle(dev, 500);
 405
 406         memset(key, 0, 8);
 407         if (usb_hid_get_report(dev, key, 8))
 408                 check_key_code(key);
 409
 410         kbd_buffer = SLOF_dma_alloc(USB_HID_SIZE);
 411         if (!kbd_buffer) {
 412                 printf("%s: unable to allocate keyboard buffer\n", __func__);
 413                 return false;
 414         }
 415
 416 #ifdef KEY_DEBUG
 417         printf("HID kbd init %d\n", dev->ep_cnt);
 418 #endif
 419         for (i = 0; i < dev->ep_cnt; i++) {
 420                 if ((dev->ep[i].bmAttributes & USB_EP_TYPE_MASK)
 421                         == USB_EP_TYPE_INTR)
 422                         usb_dev_populate_pipe(dev, &dev->ep[i], kbd_buffer, USB_HID_SIZE);
 423         }
 424         return true;
 425 }
 426
 427 int usb_hid_kbd_exit(struct usb_dev *dev)
 428 {
 429         if (dev->intr) {
 430                 usb_put_pipe(dev->intr);
 431                 dev->intr = NULL;
 432         }
 433         SLOF_dma_free(kbd_buffer, USB_HID_SIZE);
 434         return true;
 435 }
 436
 437 static int usb_poll_key(void *vdev)
 438 {
 439         struct usb_dev *dev = vdev;
 440         uint8_t key[8];
 441         int rc;
 442
 443         memset(key, 0, 8);
 444         rc = usb_poll_intr(dev->intr, key);
 445         if (rc)
 446                 check_key_code(key);
 447         return rc;
 448 }
 449
 450 unsigned char usb_key_available(void *dev)
 451 {
 452         if (!dev)
 453                 return false;
 454
 455         usb_poll_key(dev);
 456         if (r_ptr != w_ptr)
 457                 return true;
 458         else
 459                 return false;
 460 }
 461
 462 unsigned char usb_read_keyb(void *vdev)
 463 {
 464         if (usb_key_available(vdev))
 465                 return read_key();
 466         else
 467                 return 0;
 468 }