Initial revision
[platform/kernel/u-boot.git] / 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 <devices.h>
29
30 #ifdef CONFIG_USB_KEYBOARD
31
32 #include <usb.h>
33
34 #undef USB_KBD_DEBUG
35 /*
36  * if overwrite_console returns 1, the stdin, stderr and stdout
37  * are switched to the serial port, else the settings in the
38  * environment are used
39  */
40 #ifdef CFG_CONSOLE_OVERWRITE_ROUTINE
41 extern int overwrite_console (void);
42 #else
43 int overwrite_console (void)
44 {
45         return (0);
46 }
47 #endif
48
49 #ifdef  USB_KBD_DEBUG
50 #define USB_KBD_PRINTF(fmt,args...)     printf (fmt ,##args)
51 #else
52 #define USB_KBD_PRINTF(fmt,args...)
53 #endif
54
55
56 #define REPEAT_RATE  40/4 /* 40msec -> 25cps */
57 #define REPEAT_DELAY 10 /* 10 x REAPEAT_RATE = 400msec */
58
59 #define NUM_LOCK        0x53
60 #define CAPS_LOCK 0x39
61 #define SCROLL_LOCK 0x47
62
63
64 /* Modifier bits */
65 #define LEFT_CNTR               0
66 #define LEFT_SHIFT      1
67 #define LEFT_ALT                2
68 #define LEFT_GUI                3
69 #define RIGHT_CNTR      4
70 #define RIGHT_SHIFT     5
71 #define RIGHT_ALT               6
72 #define RIGHT_GUI               7
73
74 #define USB_KBD_BUFFER_LEN 0x20  /* size of the keyboardbuffer */
75
76 static volatile char usb_kbd_buffer[USB_KBD_BUFFER_LEN];
77 static volatile int usb_in_pointer = 0;
78 static volatile int usb_out_pointer = 0;
79
80 unsigned char new[8];
81 unsigned char old[8];
82 int repeat_delay;
83 #define DEVNAME "usbkbd"
84 static unsigned char num_lock = 0;
85 static unsigned char caps_lock = 0;
86 static unsigned char scroll_lock = 0;
87
88 static unsigned char leds __attribute__ ((aligned (0x4)));
89
90 static unsigned char usb_kbd_numkey[] = {
91          '1', '2', '3', '4', '5', '6', '7', '8', '9', '0','\r',0x1b,'\b','\t',' ', '-',
92          '=', '[', ']','\\', '#', ';', '\'', '`', ',', '.', '/'
93 };
94 static unsigned char usb_kbd_numkey_shifted[] = {
95          '!', '@', '#', '$', '%', '^', '&', '*', '(', ')','\r',0x1b,'\b','\t',' ', '_',
96          '+', '{', '}', '|', '~', ':', '"', '~', '<', '>', '?'
97 };
98
99 /******************************************************************
100  * Queue handling
101  ******************************************************************/
102 /* puts character in the queue and sets up the in and out pointer */
103 static void usb_kbd_put_queue(char data)
104 {
105         if((usb_in_pointer+1)==USB_KBD_BUFFER_LEN) {
106                 if(usb_out_pointer==0) {
107                         return; /* buffer full */
108                 } else{
109                         usb_in_pointer=0;
110                 }
111         } else {
112                 if((usb_in_pointer+1)==usb_out_pointer)
113                         return; /* buffer full */
114                 usb_in_pointer++;
115         }
116         usb_kbd_buffer[usb_in_pointer]=data;
117         return;
118 }
119
120 /* test if a character is in the queue */
121 static int usb_kbd_testc(void)
122 {
123         if(usb_in_pointer==usb_out_pointer)
124                 return(0); /* no data */
125         else
126                 return(1);
127 }
128 /* gets the character from the queue */
129 static int usb_kbd_getc(void)
130 {
131         char c;
132         while(usb_in_pointer==usb_out_pointer);
133         if((usb_out_pointer+1)==USB_KBD_BUFFER_LEN)
134                 usb_out_pointer=0;
135         else
136                 usb_out_pointer++;
137         c=usb_kbd_buffer[usb_out_pointer];
138         return (int)c;
139
140 }
141
142 /* forward decleration */
143 static int usb_kbd_probe(struct usb_device *dev, unsigned int ifnum);
144
145 /* search for keyboard and register it if found */
146 int drv_usb_kbd_init(void)
147 {
148         int error,i,index;
149         device_t usb_kbd_dev,*old_dev;
150         struct usb_device *dev;
151         char *stdinname  = getenv ("stdin");
152
153         usb_in_pointer=0;
154         usb_out_pointer=0;
155         /* scan all USB Devices */
156         for(i=0;i<USB_MAX_DEVICE;i++) {
157                 dev=usb_get_dev_index(i); /* get device */
158                 if(dev->devnum!=-1) {
159                         if(usb_kbd_probe(dev,0)==1) { /* Ok, we found a keyboard */
160                                 /* check, if it is already registered */
161                                 USB_KBD_PRINTF("USB KBD found set up device.\n");
162                                 for (index=1; index<=ListNumItems(devlist); index++) {
163                                         old_dev = ListGetPtrToItem(devlist, index);
164                                         if(strcmp(old_dev->name,DEVNAME)==0) {
165                                                 /* ok, already registered, just return ok */
166                                                 USB_KBD_PRINTF("USB KBD is already registered.\n");
167                                                 return 1;
168                                         }
169                                 }
170                                 /* register the keyboard */
171                                 USB_KBD_PRINTF("USB KBD register.\n");
172                                 memset (&usb_kbd_dev, 0, sizeof(device_t));
173                                 strcpy(usb_kbd_dev.name, DEVNAME);
174                                 usb_kbd_dev.flags =  DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
175                                 usb_kbd_dev.putc = NULL;
176                                 usb_kbd_dev.puts = NULL;
177                                 usb_kbd_dev.getc = usb_kbd_getc;
178                                 usb_kbd_dev.tstc = usb_kbd_testc;
179                                 error = device_register (&usb_kbd_dev);
180                                 if(error==0) {
181                                         /* check if this is the standard input device */
182                                         if(strcmp(stdinname,DEVNAME)==0) {
183                                                 /* reassign the console */
184                                                 if(overwrite_console()) {
185                                                         return 1;
186                                                 }
187                                                 error=console_assign(stdin,DEVNAME);
188                                                 if(error==0)
189                                                         return 1;
190                                                 else
191                                                         return error;
192                                         }
193                                         return 1;
194                                 }
195                                 return error;
196                         }
197                 }
198         }
199         /* no USB Keyboard found */
200         return -1;
201 }
202
203
204 /* deregistering the keyboard */
205 int usb_kbd_deregister(void)
206 {
207         return device_deregister(DEVNAME);
208 }
209
210 /**************************************************************************
211  * Low Level drivers
212  */
213
214 /* set the LEDs. Since this is used in the irq routine, the control job
215    is issued with a timeout of 0. This means, that the job is queued without
216    waiting for job completion */
217
218 static void usb_kbd_setled(struct usb_device *dev)
219 {
220         struct usb_interface_descriptor *iface;
221         iface = &dev->config.if_desc[0];
222         leds=0;
223         if(scroll_lock!=0)
224                 leds|=1;
225         leds<<=1;
226         if(caps_lock!=0)
227                 leds|=1;
228         leds<<=1;
229         if(num_lock!=0)
230                 leds|=1;
231         usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
232                 USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
233                 0x200, iface->bInterfaceNumber,(void *)&leds, 1, 0);
234
235 }
236
237
238 #define CAPITAL_MASK 0x20
239 /* Translate the scancode in ASCII */
240 static int usb_kbd_translate(unsigned char scancode,unsigned char modifier,int pressed)
241 {
242         unsigned char keycode;
243
244         if(pressed==0) {
245                 /* key released */
246                 repeat_delay=0;
247                 return 0;
248         }
249         if(pressed==2) {
250                 repeat_delay++;
251                 if(repeat_delay<REPEAT_DELAY)
252                         return 0;
253                 repeat_delay=REPEAT_DELAY;
254         }
255         keycode=0;
256         if((scancode>3) && (scancode<0x1d)) { /* alpha numeric values */
257                 keycode=scancode-4 + 0x61;
258                 if(caps_lock)
259                         keycode&=~CAPITAL_MASK; /* switch to capital Letters */
260                 if(((modifier&(1<<LEFT_SHIFT))!=0)||((modifier&(1<<RIGHT_SHIFT))!=0)) {
261                         if(keycode & CAPITAL_MASK)
262                                 keycode&=~CAPITAL_MASK; /* switch to capital Letters */
263                         else
264                                 keycode|=CAPITAL_MASK; /* switch to non capital Letters */
265                 }
266         }
267         if((scancode>0x1d) && (scancode<0x3A)) {
268                 if(((modifier&(1<<LEFT_SHIFT))!=0)||((modifier&(1<<RIGHT_SHIFT))!=0))  /* shifted */
269                         keycode=usb_kbd_numkey_shifted[scancode-0x1e];
270                 else /* non shifted */
271                         keycode=usb_kbd_numkey[scancode-0x1e];
272         }
273         if(pressed==1) {
274                 if(scancode==NUM_LOCK) {
275                         num_lock=~num_lock;
276                         return 1;
277                 }
278                 if(scancode==CAPS_LOCK) {
279                         caps_lock=~caps_lock;
280                         return 1;
281                 }
282                 if(scancode==SCROLL_LOCK) {
283                         scroll_lock=~scroll_lock;
284                         return 1;
285                 }
286         }
287         if(keycode!=0) {
288                 USB_KBD_PRINTF("%c",keycode);
289                 usb_kbd_put_queue(keycode);
290         }
291         return 0;
292 }
293
294 /* Interrupt service routine */
295 static int usb_kbd_irq(struct usb_device *dev)
296 {
297         int i,res;
298
299         if((dev->irq_status!=0)||(dev->irq_act_len!=8))
300         {
301                 USB_KBD_PRINTF("usb_keyboard Error %lX, len %d\n",dev->irq_status,dev->irq_act_len);
302                 return 1;
303         }
304         res=0;
305         for (i = 2; i < 8; i++) {
306                 if (old[i] > 3 && memscan(&new[2], old[i], 6) == &new[8]) {
307                         res|=usb_kbd_translate(old[i],new[0],0);
308                 }
309                 if (new[i] > 3 && memscan(&old[2], new[i], 6) == &old[8]) {
310                         res|=usb_kbd_translate(new[i],new[0],1);
311                 }
312         }
313         if((new[2]>3) && (old[2]==new[2])) /* still pressed */
314                 res|=usb_kbd_translate(new[2],new[0],2);
315         if(res==1)
316                 usb_kbd_setled(dev);
317         memcpy(&old[0],&new[0], 8);
318         return 1; /* install IRQ Handler again */
319 }
320
321 /* probes the USB device dev for keyboard type */
322 static int usb_kbd_probe(struct usb_device *dev, unsigned int ifnum)
323 {
324         struct usb_interface_descriptor *iface;
325         struct usb_endpoint_descriptor *ep;
326         int pipe,maxp;
327
328         if (dev->descriptor.bNumConfigurations != 1) return 0;
329         iface = &dev->config.if_desc[ifnum];
330
331         if (iface->bInterfaceClass != 3) return 0;
332         if (iface->bInterfaceSubClass != 1) return 0;
333         if (iface->bInterfaceProtocol != 1) return 0;
334         if (iface->bNumEndpoints != 1) return 0;
335
336         ep = &iface->ep_desc[0];
337
338         if (!(ep->bEndpointAddress & 0x80)) return 0;
339         if ((ep->bmAttributes & 3) != 3) return 0;
340         USB_KBD_PRINTF("USB KBD found set protocol...\n");
341         /* ok, we found a USB Keyboard, install it */
342         /* usb_kbd_get_hid_desc(dev); */
343         usb_set_protocol(dev, iface->bInterfaceNumber, 0);
344         USB_KBD_PRINTF("USB KBD found set idle...\n");
345         usb_set_idle(dev, iface->bInterfaceNumber, REPEAT_RATE, 0);
346         memset(&new[0], 0, 8);
347         memset(&old[0], 0, 8);
348         repeat_delay=0;
349         pipe = usb_rcvintpipe(dev, ep->bEndpointAddress);
350         maxp = usb_maxpacket(dev, pipe);
351         dev->irq_handle=usb_kbd_irq;
352         USB_KBD_PRINTF("USB KBD enable interrupt pipe...\n");
353         usb_submit_int_msg(dev,pipe,&new[0], maxp > 8 ? 8 : maxp,ep->bInterval);
354         return 1;
355 }
356
357
358 #if 0
359 struct usb_hid_descriptor {
360         unsigned char  bLength;
361         unsigned char  bDescriptorType; /* 0x21 for HID */
362         unsigned short bcdHID; /* release number */
363         unsigned char  bCountryCode;
364         unsigned char  bNumDescriptors;
365         unsigned char  bReportDescriptorType;
366         unsigned short wDescriptorLength;
367 } __attribute__ ((packed));
368
369 /*
370  * We parse each description item into this structure. Short items data
371  * values are expanded to 32-bit signed int, long items contain a pointer
372  * into the data area.
373  */
374
375 struct hid_item {
376         unsigned char format;
377         unsigned char size;
378         unsigned char type;
379         unsigned char tag;
380         union {
381             unsigned char   u8;
382             char            s8;
383             unsigned short  u16;
384             short           s16;
385             unsigned long   u32;
386             long            s32;
387             unsigned char  *longdata;
388         } data;
389 };
390
391 /*
392  * HID report item format
393  */
394
395 #define HID_ITEM_FORMAT_SHORT   0
396 #define HID_ITEM_FORMAT_LONG    1
397
398 /*
399  * Special tag indicating long items
400  */
401
402 #define HID_ITEM_TAG_LONG       15
403
404
405
406 static struct usb_hid_descriptor usb_kbd_hid_desc;
407
408 void usb_kbd_display_hid(struct usb_hid_descriptor *hid)
409 {
410         printf("USB_HID_DESC:\n");
411         printf("  bLenght               0x%x\n",hid->bLength);
412         printf("  bcdHID                0x%x\n",hid->bcdHID);
413         printf("  bCountryCode          %d\n",hid->bCountryCode);
414         printf("  bNumDescriptors       0x%x\n",hid->bNumDescriptors);
415         printf("  bReportDescriptorType 0x%x\n",hid->bReportDescriptorType);
416         printf("  wDescriptorLength     0x%x\n",hid->wDescriptorLength);
417 }
418
419
420 /*
421  * Fetch a report description item from the data stream. We support long
422  * items, though they are not used yet.
423  */
424
425 static int fetch_item(unsigned char *start,unsigned char *end, struct hid_item *item)
426 {
427         if((end - start) > 0) {
428                 unsigned char b = *start++;
429                 item->type = (b >> 2) & 3;
430                 item->tag  = (b >> 4) & 15;
431                 if (item->tag == HID_ITEM_TAG_LONG) {
432                         item->format = HID_ITEM_FORMAT_LONG;
433                         if ((end - start) >= 2) {
434                                 item->size = *start++;
435                                 item->tag  = *start++;
436                                 if ((end - start) >= item->size) {
437                                         item->data.longdata = start;
438                                         start += item->size;
439                                         return item->size;
440                                 }
441                         }
442                 } else {
443                         item->format = HID_ITEM_FORMAT_SHORT;
444                         item->size = b & 3;
445                         switch (item->size) {
446                                 case 0:
447                                         return item->size;
448                                 case 1:
449                                         if ((end - start) >= 1) {
450                                                 item->data.u8 = *start++;
451                                                 return item->size;
452                                         }
453                                         break;
454                                 case 2:
455                                         if ((end - start) >= 2) {
456                                                 item->data.u16 = swap_16((unsigned short *)start);
457                                                 start+=2;
458                                                 return item->size;
459                                         }
460                                 case 3:
461                                         item->size++;
462                                         if ((end - start) >= 4) {
463                                                 item->data.u32 = swap_32((unsigned long *)start);
464                                                 start+=4;
465                                                 return item->size;
466                                         }
467                         }
468                 }
469         }
470         return -1;
471 }
472
473 /*
474  * HID report descriptor item type (prefix bit 2,3)
475  */
476
477 #define HID_ITEM_TYPE_MAIN              0
478 #define HID_ITEM_TYPE_GLOBAL            1
479 #define HID_ITEM_TYPE_LOCAL             2
480 #define HID_ITEM_TYPE_RESERVED          3
481 /*
482  * HID report descriptor main item tags
483  */
484
485 #define HID_MAIN_ITEM_TAG_INPUT                 8
486 #define HID_MAIN_ITEM_TAG_OUTPUT                9
487 #define HID_MAIN_ITEM_TAG_FEATURE               11
488 #define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION      10
489 #define HID_MAIN_ITEM_TAG_END_COLLECTION        12
490 /*
491  * HID report descriptor main item contents
492  */
493
494 #define HID_MAIN_ITEM_CONSTANT          0x001
495 #define HID_MAIN_ITEM_VARIABLE          0x002
496 #define HID_MAIN_ITEM_RELATIVE          0x004
497 #define HID_MAIN_ITEM_WRAP              0x008
498 #define HID_MAIN_ITEM_NONLINEAR         0x010
499 #define HID_MAIN_ITEM_NO_PREFERRED      0x020
500 #define HID_MAIN_ITEM_NULL_STATE        0x040
501 #define HID_MAIN_ITEM_VOLATILE          0x080
502 #define HID_MAIN_ITEM_BUFFERED_BYTE     0x100
503
504 /*
505  * HID report descriptor collection item types
506  */
507
508 #define HID_COLLECTION_PHYSICAL         0
509 #define HID_COLLECTION_APPLICATION      1
510 #define HID_COLLECTION_LOGICAL          2
511 /*
512  * HID report descriptor global item tags
513  */
514
515 #define HID_GLOBAL_ITEM_TAG_USAGE_PAGE          0
516 #define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM     1
517 #define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM     2
518 #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM    3
519 #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM    4
520 #define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT       5
521 #define HID_GLOBAL_ITEM_TAG_UNIT                6
522 #define HID_GLOBAL_ITEM_TAG_REPORT_SIZE         7
523 #define HID_GLOBAL_ITEM_TAG_REPORT_ID           8
524 #define HID_GLOBAL_ITEM_TAG_REPORT_COUNT        9
525 #define HID_GLOBAL_ITEM_TAG_PUSH                10
526 #define HID_GLOBAL_ITEM_TAG_POP                 11
527
528 /*
529  * HID report descriptor local item tags
530  */
531
532 #define HID_LOCAL_ITEM_TAG_USAGE                0
533 #define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM        1
534 #define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM        2
535 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX     3
536 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM   4
537 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM   5
538 #define HID_LOCAL_ITEM_TAG_STRING_INDEX         7
539 #define HID_LOCAL_ITEM_TAG_STRING_MINIMUM       8
540 #define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM       9
541 #define HID_LOCAL_ITEM_TAG_DELIMITER            10
542
543
544
545 static void usb_kbd_show_item(struct hid_item *item)
546 {
547         switch(item->type) {
548                 case HID_ITEM_TYPE_MAIN:
549                         switch(item->tag) {
550                                 case HID_MAIN_ITEM_TAG_INPUT:
551                                         printf("Main Input");
552                                         break;
553                                 case HID_MAIN_ITEM_TAG_OUTPUT:
554                                         printf("Main Output");
555                                         break;
556                                 case HID_MAIN_ITEM_TAG_FEATURE:
557                                         printf("Main Feature");
558                                         break;
559                                 case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
560                                         printf("Main Begin Collection");
561                                         break;
562                                 case HID_MAIN_ITEM_TAG_END_COLLECTION:
563                                         printf("Main End Collection");
564                                         break;
565                                 default:
566                                         printf("Main reserved %d",item->tag);
567                                         break;
568                         }
569                         break;
570                 case HID_ITEM_TYPE_GLOBAL:
571                         switch(item->tag) {
572                                 case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
573                                         printf("- Global Usage Page");
574                                         break;
575                                 case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
576                                         printf("- Global Logical Minimum");
577                                         break;
578                                 case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
579                                         printf("- Global Logical Maximum");
580                                         break;
581                                 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
582                                         printf("- Global physical Minimum");
583                                         break;
584                                 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
585                                         printf("- Global physical Maximum");
586                                         break;
587                                 case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
588                                         printf("- Global Unit Exponent");
589                                         break;
590                                 case HID_GLOBAL_ITEM_TAG_UNIT:
591                                         printf("- Global Unit");
592                                         break;
593                                 case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
594                                         printf("- Global Report Size");
595                                         break;
596                                 case HID_GLOBAL_ITEM_TAG_REPORT_ID:
597                                         printf("- Global Report ID");
598                                         break;
599                                 case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
600                                         printf("- Global Report Count");
601                                         break;
602                                 case HID_GLOBAL_ITEM_TAG_PUSH:
603                                         printf("- Global Push");
604                                         break;
605                                 case HID_GLOBAL_ITEM_TAG_POP:
606                                         printf("- Global Pop");
607                                         break;
608                                 default:
609                                         printf("- Global reserved %d",item->tag);
610                                         break;
611                         }
612                         break;
613                 case HID_ITEM_TYPE_LOCAL:
614                         switch(item->tag) {
615                                 case HID_LOCAL_ITEM_TAG_USAGE:
616                                         printf("-- Local Usage");
617                                         break;
618                                 case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
619                                         printf("-- Local Usage Minimum");
620                                         break;
621                                 case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
622                                         printf("-- Local Usage Maximum");
623                                         break;
624                                 case HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX:
625                                         printf("-- Local Designator Index");
626                                         break;
627                                 case HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM:
628                                         printf("-- Local Designator Minimum");
629                                         break;
630                                 case HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM:
631                                         printf("-- Local Designator Maximum");
632                                         break;
633                                 case HID_LOCAL_ITEM_TAG_STRING_INDEX:
634                                         printf("-- Local String Index");
635                                         break;
636                                 case HID_LOCAL_ITEM_TAG_STRING_MINIMUM:
637                                         printf("-- Local String Minimum");
638                                         break;
639                                 case HID_LOCAL_ITEM_TAG_STRING_MAXIMUM:
640                                         printf("-- Local String Maximum");
641                                         break;
642                                 case HID_LOCAL_ITEM_TAG_DELIMITER:
643                                         printf("-- Local Delimiter");
644                                         break;
645                                 default:
646                                         printf("-- Local reserved %d",item->tag);
647                                         break;
648                         }
649                         break;
650                 default:
651                         printf("--- reserved %d",item->type);
652                         break;
653         }
654         switch(item->size) {
655                 case 1:
656                         printf("  %d",item->data.u8);
657                         break;
658                 case 2:
659                         printf("  %d",item->data.u16);
660                         break;
661                 case 4:
662                         printf("  %ld",item->data.u32);
663                         break;
664         }
665         printf("\n");
666 }
667
668
669
670 static int usb_kbd_get_hid_desc(struct usb_device *dev)
671 {
672         unsigned char buffer[256];
673         struct usb_descriptor_header *head;
674         struct usb_config_descriptor *config;
675         int index,len,i;
676         unsigned char *start, *end;
677         struct hid_item item;
678
679         if(usb_get_configuration_no(dev,&buffer[0],0)==-1)
680                 return -1;
681         head =(struct usb_descriptor_header *)&buffer[0];
682         if(head->bDescriptorType!=USB_DT_CONFIG) {
683                 printf(" ERROR: NOT USB_CONFIG_DESC %x\n",head->bDescriptorType);
684                 return -1;
685         }
686         index=head->bLength;
687         config=(struct usb_config_descriptor *)&buffer[0];
688         len=swap_16(config->wTotalLength);
689         /* Ok the first entry must be a configuration entry, now process the others */
690         head=(struct usb_descriptor_header *)&buffer[index];
691         while(index+1 < len) {
692                 if(head->bDescriptorType==USB_DT_HID) {
693                         printf("HID desc found\n");
694                         memcpy(&usb_kbd_hid_desc,&buffer[index],buffer[index]);
695                         usb_kbd_hid_desc.bcdHID=swap_16(usb_kbd_hid_desc.bcdHID);
696                         usb_kbd_hid_desc.wDescriptorLength=swap_16(usb_kbd_hid_desc.wDescriptorLength);
697                         usb_kbd_display_hid(&usb_kbd_hid_desc);
698                         len=0;
699                         break;
700                 }
701                 index+=head->bLength;
702                 head=(struct usb_descriptor_header *)&buffer[index];
703         }
704         if(len>0)
705                 return -1;
706         len=usb_kbd_hid_desc.wDescriptorLength;
707         if((index = usb_get_class_descriptor(dev, 0, USB_DT_REPORT, 0, &buffer[0], len)) < 0) {
708                 printf("reading report descriptor failed\n");
709                 return -1;
710         }
711         printf(" report descriptor (size %u, read %d)\n", len, index);
712         start=&buffer[0];
713         end=&buffer[len];
714         i=0;
715         do {
716                 index=fetch_item(start,end,&item);
717                 i+=index;
718                 i++;
719                 if(index>=0)
720                         usb_kbd_show_item(&item);
721
722                 start+=index;
723                 start++;
724         } while(index>=0);
725
726 }
727
728
729 #endif
730
731 #endif /* CONFIG_USB_KEYBOARD */
732
733 /* eof */
734