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 #ifdef  USB_KBD_DEBUG
  35 #define USB_KBD_PRINTF(fmt, args...)    printf(fmt, ##args)
  36 #else
  37 #define USB_KBD_PRINTF(fmt, args...)
  38 #endif
  39
  40 /*
  41  * If overwrite_console returns 1, the stdin, stderr and stdout
  42  * are switched to the serial port, else the settings in the
  43  * environment are used
  44  */
  45 #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
  46 extern int overwrite_console(void);
  47 #else
  48 int overwrite_console(void)
  49 {
  50         return 0;
  51 }
  52 #endif
  53
  54 /* Keyboard sampling rate */
  55 #define REPEAT_RATE     (40 / 4)        /* 40msec -> 25cps */
  56 #define REPEAT_DELAY    10              /* 10 x REPEAT_RATE = 400msec */
  57
  58 #define NUM_LOCK        0x53
  59 #define CAPS_LOCK       0x39
  60 #define SCROLL_LOCK     0x47
  61
  62 /* Modifier bits */
  63 #define LEFT_CNTR       (1 << 0)
  64 #define LEFT_SHIFT      (1 << 1)
  65 #define LEFT_ALT        (1 << 2)
  66 #define LEFT_GUI        (1 << 3)
  67 #define RIGHT_CNTR      (1 << 4)
  68 #define RIGHT_SHIFT     (1 << 5)
  69 #define RIGHT_ALT       (1 << 6)
  70 #define RIGHT_GUI       (1 << 7)
  71
  72 /* Size of the keyboard buffer */
  73 #define USB_KBD_BUFFER_LEN      0x20
  74
  75 /* Device name */
  76 #define DEVNAME                 "usbkbd"
  77
  78 /* Keyboard maps */
  79 static const unsigned char usb_kbd_numkey[] = {
  80         '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
  81         '\r', 0x1b, '\b', '\t', ' ', '-', '=', '[', ']',
  82         '\\', '#', ';', '\'', '`', ',', '.', '/'
  83 };
  84 static const unsigned char usb_kbd_numkey_shifted[] = {
  85         '!', '@', '#', '$', '%', '^', '&', '*', '(', ')',
  86         '\r', 0x1b, '\b', '\t', ' ', '_', '+', '{', '}',
  87         '|', '~', ':', '"', '~', '<', '>', '?'
  88 };
  89
  90 /*
  91  * NOTE: It's important for the NUM, CAPS, SCROLL-lock bits to be in this
  92  *       order. See usb_kbd_setled() function!
  93  */
  94 #define USB_KBD_NUMLOCK         (1 << 0)
  95 #define USB_KBD_CAPSLOCK        (1 << 1)
  96 #define USB_KBD_SCROLLLOCK      (1 << 2)
  97 #define USB_KBD_CTRL            (1 << 3)
  98
  99 #define USB_KBD_LEDMASK         \
 100         (USB_KBD_NUMLOCK | USB_KBD_CAPSLOCK | USB_KBD_SCROLLLOCK)
 101
 102 struct usb_kbd_pdata {
 103         uint32_t        repeat_delay;
 104
 105         uint32_t        usb_in_pointer;
 106         uint32_t        usb_out_pointer;
 107         uint8_t         usb_kbd_buffer[USB_KBD_BUFFER_LEN];
 108
 109         uint8_t         new[8];
 110         uint8_t         old[8];
 111
 112         uint8_t         flags;
 113 };
 114
 115 /* Generic keyboard event polling. */
 116 void usb_kbd_generic_poll(void)
 117 {
 118         struct stdio_dev *dev;
 119         struct usb_device *usb_kbd_dev;
 120         struct usb_kbd_pdata *data;
 121         struct usb_interface *iface;
 122         struct usb_endpoint_descriptor *ep;
 123         int pipe;
 124         int maxp;
 125
 126         /* Get the pointer to USB Keyboard device pointer */
 127         dev = stdio_get_by_name(DEVNAME);
 128         usb_kbd_dev = (struct usb_device *)dev->priv;
 129         data = usb_kbd_dev->privptr;
 130         iface = &usb_kbd_dev->config.if_desc[0];
 131         ep = &iface->ep_desc[0];
 132         pipe = usb_rcvintpipe(usb_kbd_dev, ep->bEndpointAddress);
 133
 134         /* Submit a interrupt transfer request */
 135         maxp = usb_maxpacket(usb_kbd_dev, pipe);
 136         usb_submit_int_msg(usb_kbd_dev, pipe, data->new,
 137                         maxp > 8 ? 8 : maxp, ep->bInterval);
 138 }
 139
 140 /* Puts character in the queue and sets up the in and out pointer. */
 141 static void usb_kbd_put_queue(struct usb_kbd_pdata *data, char c)
 142 {
 143         if (data->usb_in_pointer == USB_KBD_BUFFER_LEN - 1) {
 144                 /* Check for buffer full. */
 145                 if (data->usb_out_pointer == 0)
 146                         return;
 147
 148                 data->usb_in_pointer = 0;
 149         } else {
 150                 /* Check for buffer full. */
 151                 if (data->usb_in_pointer == data->usb_out_pointer - 1)
 152                         return;
 153
 154                 data->usb_in_pointer++;
 155         }
 156
 157         data->usb_kbd_buffer[data->usb_in_pointer] = c;
 158 }
 159
 160 /*
 161  * Set the LEDs. Since this is used in the irq routine, the control job is
 162  * issued with a timeout of 0. This means, that the job is queued without
 163  * waiting for job completion.
 164  */
 165 static void usb_kbd_setled(struct usb_device *dev)
 166 {
 167         struct usb_interface *iface = &dev->config.if_desc[0];
 168         struct usb_kbd_pdata *data = dev->privptr;
 169         uint32_t leds = data->flags & USB_KBD_LEDMASK;
 170
 171         usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 172                 USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 173                 0x200, iface->desc.bInterfaceNumber, (void *)&leds, 1, 0);
 174 }
 175
 176 #define CAPITAL_MASK    0x20
 177 /* Translate the scancode in ASCII */
 178 static int usb_kbd_translate(struct usb_kbd_pdata *data, unsigned char scancode,
 179                                 unsigned char modifier, int pressed)
 180 {
 181         uint8_t keycode = 0;
 182
 183         /* Key released */
 184         if (pressed == 0) {
 185                 data->repeat_delay = 0;
 186                 return 0;
 187         }
 188
 189         if (pressed == 2) {
 190                 data->repeat_delay++;
 191                 if (data->repeat_delay < REPEAT_DELAY)
 192                         return 0;
 193
 194                 data->repeat_delay = REPEAT_DELAY;
 195         }
 196
 197         /* Alphanumeric values */
 198         if ((scancode > 3) && (scancode <= 0x1d)) {
 199                 keycode = scancode - 4 + 'a';
 200
 201                 if (data->flags & USB_KBD_CAPSLOCK)
 202                         keycode &= ~CAPITAL_MASK;
 203
 204                 if (modifier & (LEFT_SHIFT | RIGHT_SHIFT)) {
 205                         /* Handle CAPSLock + Shift pressed simultaneously */
 206                         if (keycode & CAPITAL_MASK)
 207                                 keycode &= ~CAPITAL_MASK;
 208                         else
 209                                 keycode |= CAPITAL_MASK;
 210                 }
 211         }
 212
 213         if ((scancode > 0x1d) && (scancode < 0x3a)) {
 214                 /* Shift pressed */
 215                 if (modifier & (LEFT_SHIFT | RIGHT_SHIFT))
 216                         keycode = usb_kbd_numkey_shifted[scancode - 0x1e];
 217                 else
 218                         keycode = usb_kbd_numkey[scancode - 0x1e];
 219         }
 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                 USB_KBD_PRINTF("%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                 USB_KBD_PRINTF("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         usb_event_poll();
 317         usb_kbd_irq_worker(dev);
 318 #elif   defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
 319         struct usb_interface *iface;
 320         struct usb_kbd_pdata *data = dev->privptr;
 321         iface = &dev->config.if_desc[0];
 322         usb_get_report(dev, iface->desc.bInterfaceNumber,
 323                         1, 1, data->new, sizeof(data->new));
 324         if (memcmp(data->old, data->new, sizeof(data->new)))
 325                 usb_kbd_irq_worker(dev);
 326 #endif
 327 }
 328
 329 /* test if a character is in the queue */
 330 static int usb_kbd_testc(void)
 331 {
 332         struct stdio_dev *dev;
 333         struct usb_device *usb_kbd_dev;
 334         struct usb_kbd_pdata *data;
 335
 336         dev = stdio_get_by_name(DEVNAME);
 337         usb_kbd_dev = (struct usb_device *)dev->priv;
 338         data = usb_kbd_dev->privptr;
 339
 340         usb_kbd_poll_for_event(usb_kbd_dev);
 341
 342         return !(data->usb_in_pointer == data->usb_out_pointer);
 343 }
 344
 345 /* gets the character from the queue */
 346 static int usb_kbd_getc(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         while (data->usb_in_pointer == data->usb_out_pointer)
 357                 usb_kbd_poll_for_event(usb_kbd_dev);
 358
 359         if (data->usb_out_pointer == USB_KBD_BUFFER_LEN - 1)
 360                 data->usb_out_pointer = 0;
 361         else
 362                 data->usb_out_pointer++;
 363
 364         return data->usb_kbd_buffer[data->usb_out_pointer];
 365 }
 366
 367 /* probes the USB device dev for keyboard type. */
 368 static int usb_kbd_probe(struct usb_device *dev, unsigned int ifnum)
 369 {
 370         struct usb_interface *iface;
 371         struct usb_endpoint_descriptor *ep;
 372         struct usb_kbd_pdata *data;
 373         int pipe, maxp;
 374
 375         if (dev->descriptor.bNumConfigurations != 1)
 376                 return 0;
 377
 378         iface = &dev->config.if_desc[ifnum];
 379
 380         if (iface->desc.bInterfaceClass != 3)
 381                 return 0;
 382
 383         if (iface->desc.bInterfaceSubClass != 1)
 384                 return 0;
 385
 386         if (iface->desc.bInterfaceProtocol != 1)
 387                 return 0;
 388
 389         if (iface->desc.bNumEndpoints != 1)
 390                 return 0;
 391
 392         ep = &iface->ep_desc[0];
 393
 394         /* Check if endpoint 1 is interrupt endpoint */
 395         if (!(ep->bEndpointAddress & 0x80))
 396                 return 0;
 397
 398         if ((ep->bmAttributes & 3) != 3)
 399                 return 0;
 400
 401         USB_KBD_PRINTF("USB KBD: found set protocol...\n");
 402
 403         data = malloc(sizeof(struct usb_kbd_pdata));
 404         if (!data) {
 405                 printf("USB KBD: Error allocating private data\n");
 406                 return 0;
 407         }
 408
 409         /* Clear private data */
 410         memset(data, 0, sizeof(struct usb_kbd_pdata));
 411
 412         /* Insert private data into USB device structure */
 413         dev->privptr = data;
 414
 415         /* Set IRQ handler */
 416         dev->irq_handle = usb_kbd_irq;
 417
 418         pipe = usb_rcvintpipe(dev, ep->bEndpointAddress);
 419         maxp = usb_maxpacket(dev, pipe);
 420
 421         /* We found a USB Keyboard, install it. */
 422         usb_set_protocol(dev, iface->desc.bInterfaceNumber, 0);
 423
 424         USB_KBD_PRINTF("USB KBD: found set idle...\n");
 425         usb_set_idle(dev, iface->desc.bInterfaceNumber, REPEAT_RATE, 0);
 426
 427         USB_KBD_PRINTF("USB KBD: enable interrupt pipe...\n");
 428         usb_submit_int_msg(dev, pipe, data->new, maxp > 8 ? 8 : maxp,
 429                                 ep->bInterval);
 430
 431         /* Success. */
 432         return 1;
 433 }
 434
 435 /* Search for keyboard and register it if found. */
 436 int drv_usb_kbd_init(void)
 437 {
 438         struct stdio_dev usb_kbd_dev, *old_dev;
 439         struct usb_device *dev;
 440         char *stdinname = getenv("stdin");
 441         int error, i;
 442
 443         /* Scan all USB Devices */
 444         for (i = 0; i < USB_MAX_DEVICE; i++) {
 445                 /* Get USB device. */
 446                 dev = usb_get_dev_index(i);
 447                 if (!dev)
 448                         return -1;
 449
 450                 if (dev->devnum == -1)
 451                         continue;
 452
 453                 /* Try probing the keyboard */
 454                 if (usb_kbd_probe(dev, 0) != 1)
 455                         continue;
 456
 457                 /* We found a keyboard, check if it is already registered. */
 458                 USB_KBD_PRINTF("USB KBD: found set up device.\n");
 459                 old_dev = stdio_get_by_name(DEVNAME);
 460                 if (old_dev) {
 461                         /* Already registered, just return ok. */
 462                         USB_KBD_PRINTF("USB KBD: is already registered.\n");
 463                         return 1;
 464                 }
 465
 466                 /* Register the keyboard */
 467                 USB_KBD_PRINTF("USB KBD: register.\n");
 468                 memset(&usb_kbd_dev, 0, sizeof(struct stdio_dev));
 469                 strcpy(usb_kbd_dev.name, DEVNAME);
 470                 usb_kbd_dev.flags =  DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
 471                 usb_kbd_dev.putc = NULL;
 472                 usb_kbd_dev.puts = NULL;
 473                 usb_kbd_dev.getc = usb_kbd_getc;
 474                 usb_kbd_dev.tstc = usb_kbd_testc;
 475                 usb_kbd_dev.priv = (void *)dev;
 476                 error = stdio_register(&usb_kbd_dev);
 477                 if (error)
 478                         return error;
 479
 480                 /* Check if this is the standard input device. */
 481                 if (strcmp(stdinname, DEVNAME))
 482                         return 1;
 483
 484                 /* Reassign the console */
 485                 if (overwrite_console())
 486                         return 1;
 487
 488                 error = console_assign(stdin, DEVNAME);
 489                 if (error)
 490                         return error;
 491
 492                 return 1;
 493         }
 494
 495         /* No USB Keyboard found */
 496         return -1;
 497 }
 498
 499 /* Deregister the keyboard. */
 500 int usb_kbd_deregister(void)
 501 {
 502 #ifdef CONFIG_SYS_STDIO_DEREGISTER
 503         return stdio_deregister(DEVNAME);
 504 #else
 505         return 1;
 506 #endif
 507 }
 508
 509 #if 0
 510 struct usb_hid_descriptor {
 511         unsigned char  bLength;
 512         unsigned char  bDescriptorType; /* 0x21 for HID */
 513         unsigned short bcdHID; /* release number */
 514         unsigned char  bCountryCode;
 515         unsigned char  bNumDescriptors;
 516         unsigned char  bReportDescriptorType;
 517         unsigned short wDescriptorLength;
 518 } __packed;
 519
 520 /*
 521  * We parse each description item into this structure. Short items data
 522  * values are expanded to 32-bit signed int, long items contain a pointer
 523  * into the data area.
 524  */
 525
 526 struct hid_item {
 527         unsigned char format;
 528         unsigned char size;
 529         unsigned char type;
 530         unsigned char tag;
 531         union {
 532             unsigned char   u8;
 533             char            s8;
 534             unsigned short  u16;
 535             short           s16;
 536             unsigned long   u32;
 537             long            s32;
 538             unsigned char  *longdata;
 539         } data;
 540 };
 541
 542 /*
 543  * HID report item format
 544  */
 545
 546 #define HID_ITEM_FORMAT_SHORT   0
 547 #define HID_ITEM_FORMAT_LONG    1
 548
 549 /*
 550  * Special tag indicating long items
 551  */
 552
 553 #define HID_ITEM_TAG_LONG       15
 554
 555
 556 static struct usb_hid_descriptor usb_kbd_hid_desc;
 557
 558 void usb_kbd_display_hid(struct usb_hid_descriptor *hid)
 559 {
 560         printf("USB_HID_DESC:\n");
 561         printf("  bLenght               0x%x\n", hid->bLength);
 562         printf("  bcdHID                0x%x\n", hid->bcdHID);
 563         printf("  bCountryCode          %d\n", hid->bCountryCode);
 564         printf("  bNumDescriptors       0x%x\n", hid->bNumDescriptors);
 565         printf("  bReportDescriptorType 0x%x\n", hid->bReportDescriptorType);
 566         printf("  wDescriptorLength     0x%x\n", hid->wDescriptorLength);
 567 }
 568
 569
 570 /*
 571  * Fetch a report description item from the data stream. We support long
 572  * items, though they are not used yet.
 573  */
 574
 575 static int fetch_item(unsigned char *start, unsigned char *end,
 576                         struct hid_item *item)
 577 {
 578         if ((end - start) > 0) {
 579                 unsigned char b = *start++;
 580                 item->type = (b >> 2) & 3;
 581                 item->tag  = (b >> 4) & 15;
 582                 if (item->tag == HID_ITEM_TAG_LONG) {
 583                         item->format = HID_ITEM_FORMAT_LONG;
 584                         if ((end - start) >= 2) {
 585                                 item->size = *start++;
 586                                 item->tag  = *start++;
 587                                 if ((end - start) >= item->size) {
 588                                         item->data.longdata = start;
 589                                         start += item->size;
 590                                         return item->size;
 591                                 }
 592                         }
 593                 } else {
 594                         item->format = HID_ITEM_FORMAT_SHORT;
 595                         item->size = b & 3;
 596                         switch (item->size) {
 597                         case 0:
 598                                 return item->size;
 599                         case 1:
 600                                 if ((end - start) >= 1) {
 601                                         item->data.u8 = *start++;
 602                                         return item->size;
 603                                 }
 604                                 break;
 605                         case 2:
 606                                 if ((end - start) >= 2) {
 607                                         item->data.u16 = le16_to_cpu(
 608                                                 (unsigned short *)start);
 609                                         start += 2;
 610                                         return item->size;
 611                                 }
 612                         case 3:
 613                                 item->size++;
 614                                 if ((end - start) >= 4) {
 615                                         item->data.u32 = le32_to_cpu(
 616                                                 (unsigned long *)start);
 617                                         start += 4;
 618                                         return item->size;
 619                                 }
 620                         }
 621                 }
 622         }
 623         return -1;
 624 }
 625
 626 /*
 627  * HID report descriptor item type (prefix bit 2, 3)
 628  */
 629
 630 #define HID_ITEM_TYPE_MAIN              0
 631 #define HID_ITEM_TYPE_GLOBAL            1
 632 #define HID_ITEM_TYPE_LOCAL             2
 633 #define HID_ITEM_TYPE_RESERVED          3
 634 /*
 635  * HID report descriptor main item tags
 636  */
 637
 638 #define HID_MAIN_ITEM_TAG_INPUT                 8
 639 #define HID_MAIN_ITEM_TAG_OUTPUT                9
 640 #define HID_MAIN_ITEM_TAG_FEATURE               11
 641 #define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION      10
 642 #define HID_MAIN_ITEM_TAG_END_COLLECTION        12
 643 /*
 644  * HID report descriptor main item contents
 645  */
 646
 647 #define HID_MAIN_ITEM_CONSTANT          0x001
 648 #define HID_MAIN_ITEM_VARIABLE          0x002
 649 #define HID_MAIN_ITEM_RELATIVE          0x004
 650 #define HID_MAIN_ITEM_WRAP              0x008
 651 #define HID_MAIN_ITEM_NONLINEAR         0x010
 652 #define HID_MAIN_ITEM_NO_PREFERRED      0x020
 653 #define HID_MAIN_ITEM_NULL_STATE        0x040
 654 #define HID_MAIN_ITEM_VOLATILE          0x080
 655 #define HID_MAIN_ITEM_BUFFERED_BYTE     0x100
 656
 657 /*
 658  * HID report descriptor collection item types
 659  */
 660
 661 #define HID_COLLECTION_PHYSICAL         0
 662 #define HID_COLLECTION_APPLICATION      1
 663 #define HID_COLLECTION_LOGICAL          2
 664 /*
 665  * HID report descriptor global item tags
 666  */
 667
 668 #define HID_GLOBAL_ITEM_TAG_USAGE_PAGE          0
 669 #define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM     1
 670 #define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM     2
 671 #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM    3
 672 #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM    4
 673 #define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT       5
 674 #define HID_GLOBAL_ITEM_TAG_UNIT                6
 675 #define HID_GLOBAL_ITEM_TAG_REPORT_SIZE         7
 676 #define HID_GLOBAL_ITEM_TAG_REPORT_ID           8
 677 #define HID_GLOBAL_ITEM_TAG_REPORT_COUNT        9
 678 #define HID_GLOBAL_ITEM_TAG_PUSH                10
 679 #define HID_GLOBAL_ITEM_TAG_POP                 11
 680
 681 /*
 682  * HID report descriptor local item tags
 683  */
 684
 685 #define HID_LOCAL_ITEM_TAG_USAGE                0
 686 #define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM        1
 687 #define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM        2
 688 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX     3
 689 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM   4
 690 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM   5
 691 #define HID_LOCAL_ITEM_TAG_STRING_INDEX         7
 692 #define HID_LOCAL_ITEM_TAG_STRING_MINIMUM       8
 693 #define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM       9
 694 #define HID_LOCAL_ITEM_TAG_DELIMITER            10
 695
 696
 697 static void usb_kbd_show_item(struct hid_item *item)
 698 {
 699         switch (item->type) {
 700         case HID_ITEM_TYPE_MAIN:
 701                 switch (item->tag) {
 702                 case HID_MAIN_ITEM_TAG_INPUT:
 703                         printf("Main Input");
 704                         break;
 705                 case HID_MAIN_ITEM_TAG_OUTPUT:
 706                         printf("Main Output");
 707                         break;
 708                 case HID_MAIN_ITEM_TAG_FEATURE:
 709                         printf("Main Feature");
 710                         break;
 711                 case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
 712                         printf("Main Begin Collection");
 713                         break;
 714                 case HID_MAIN_ITEM_TAG_END_COLLECTION:
 715                         printf("Main End Collection");
 716                         break;
 717                 default:
 718                         printf("Main reserved %d", item->tag);
 719                         break;
 720                 }
 721                 break;
 722         case HID_ITEM_TYPE_GLOBAL:
 723                 switch (item->tag) {
 724                 case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
 725                         printf("- Global Usage Page");
 726                         break;
 727                 case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
 728                         printf("- Global Logical Minimum");
 729                         break;
 730                 case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
 731                         printf("- Global Logical Maximum");
 732                         break;
 733                 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
 734                         printf("- Global physical Minimum");
 735                         break;
 736                 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
 737                         printf("- Global physical Maximum");
 738                         break;
 739                 case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
 740                         printf("- Global Unit Exponent");
 741                         break;
 742                 case HID_GLOBAL_ITEM_TAG_UNIT:
 743                         printf("- Global Unit");
 744                         break;
 745                 case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
 746                         printf("- Global Report Size");
 747                         break;
 748                 case HID_GLOBAL_ITEM_TAG_REPORT_ID:
 749                         printf("- Global Report ID");
 750                         break;
 751                 case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
 752                         printf("- Global Report Count");
 753                         break;
 754                 case HID_GLOBAL_ITEM_TAG_PUSH:
 755                         printf("- Global Push");
 756                         break;
 757                 case HID_GLOBAL_ITEM_TAG_POP:
 758                         printf("- Global Pop");
 759                         break;
 760                 default:
 761                         printf("- Global reserved %d", item->tag);
 762                         break;
 763                 }
 764                 break;
 765         case HID_ITEM_TYPE_LOCAL:
 766                 switch (item->tag) {
 767                 case HID_LOCAL_ITEM_TAG_USAGE:
 768                         printf("-- Local Usage");
 769                         break;
 770                 case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
 771                         printf("-- Local Usage Minimum");
 772                         break;
 773                 case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
 774                         printf("-- Local Usage Maximum");
 775                         break;
 776                 case HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX:
 777                         printf("-- Local Designator Index");
 778                         break;
 779                 case HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM:
 780                         printf("-- Local Designator Minimum");
 781                         break;
 782                 case HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM:
 783                         printf("-- Local Designator Maximum");
 784                         break;
 785                 case HID_LOCAL_ITEM_TAG_STRING_INDEX:
 786                         printf("-- Local String Index");
 787                         break;
 788                 case HID_LOCAL_ITEM_TAG_STRING_MINIMUM:
 789                         printf("-- Local String Minimum");
 790                         break;
 791                 case HID_LOCAL_ITEM_TAG_STRING_MAXIMUM:
 792                         printf("-- Local String Maximum");
 793                         break;
 794                 case HID_LOCAL_ITEM_TAG_DELIMITER:
 795                         printf("-- Local Delimiter");
 796                         break;
 797                 default:
 798                         printf("-- Local reserved %d", item->tag);
 799                         break;
 800                 }
 801                 break;
 802         default:
 803                 printf("--- reserved %d", item->type);
 804                 break;
 805         }
 806         switch (item->size) {
 807         case 1:
 808                 printf("  %d", item->data.u8);
 809                 break;
 810         case 2:
 811                 printf("  %d", item->data.u16);
 812                 break;
 813         case 4:
 814                 printf("  %ld", item->data.u32);
 815                 break;
 816         }
 817         printf("\n");
 818 }
 819
 820
 821 static int usb_kbd_get_hid_desc(struct usb_device *dev)
 822 {
 823         unsigned char buffer[256];
 824         struct usb_descriptor_header *head;
 825         struct usb_config_descriptor *config;
 826         int index, len, i;
 827         unsigned char *start, *end;
 828         struct hid_item item;
 829
 830         if (usb_get_configuration_no(dev, &buffer[0], 0) == -1)
 831                 return -1;
 832         head = (struct usb_descriptor_header *)&buffer[0];
 833         if (head->bDescriptorType != USB_DT_CONFIG) {
 834                 printf(" ERROR: NOT USB_CONFIG_DESC %x\n",
 835                                 head->bDescriptorType);
 836                 return -1;
 837         }
 838         index = head->bLength;
 839         config = (struct usb_config_descriptor *)&buffer[0];
 840         len = le16_to_cpu(config->wTotalLength);
 841         /*
 842          * Ok the first entry must be a configuration entry,
 843          * now process the others
 844          */
 845         head = (struct usb_descriptor_header *)&buffer[index];
 846         while (index+1 < len) {
 847                 if (head->bDescriptorType == USB_DT_HID) {
 848                         printf("HID desc found\n");
 849                         memcpy(&usb_kbd_hid_desc, &buffer[index],
 850                                         buffer[index]);
 851                         le16_to_cpus(&usb_kbd_hid_desc.bcdHID);
 852                         le16_to_cpus(&usb_kbd_hid_desc.wDescriptorLength);
 853                         usb_kbd_display_hid(&usb_kbd_hid_desc);
 854                         len = 0;
 855                         break;
 856                 }
 857                 index += head->bLength;
 858                 head = (struct usb_descriptor_header *)&buffer[index];
 859         }
 860         if (len > 0)
 861                 return -1;
 862         len = usb_kbd_hid_desc.wDescriptorLength;
 863         index = usb_get_class_descriptor(dev, 0, USB_DT_REPORT, 0, &buffer[0],
 864                                                 len);
 865         if (index < 0) {
 866                 printf("reading report descriptor failed\n");
 867                 return -1;
 868         }
 869         printf(" report descriptor (size %u, read %d)\n", len, index);
 870         start = &buffer[0];
 871         end = &buffer[len];
 872         i = 0;
 873         do {
 874                 index = fetch_item(start, end, &item);
 875                 i += index;
 876                 i++;
 877                 if (index >= 0)
 878                         usb_kbd_show_item(&item);
 879
 880                 start += index;
 881                 start++;
 882         } while (index >= 0);
 883
 884 }
 885
 886 #endif