3 * Denis Peter, MPL AG Switzerland
5 * Part of this source has been derived from the Linux USB
8 * See file CREDITS for list of people who contributed to this
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.
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.
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,
29 #include <asm/byteorder.h>
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
39 #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
40 extern int overwrite_console (void);
42 int overwrite_console (void)
49 #define USB_KBD_PRINTF(fmt,args...) printf (fmt ,##args)
51 #define USB_KBD_PRINTF(fmt,args...)
55 #define REPEAT_RATE 40/4 /* 40msec -> 25cps */
56 #define REPEAT_DELAY 10 /* 10 x REAPEAT_RATE = 400msec */
59 #define CAPS_LOCK 0x39
60 #define SCROLL_LOCK 0x47
73 #define USB_KBD_BUFFER_LEN 0x20 /* size of the keyboardbuffer */
75 static volatile char usb_kbd_buffer
[USB_KBD_BUFFER_LEN
];
76 static volatile int usb_in_pointer
= 0;
77 static volatile int usb_out_pointer
= 0;
82 #define DEVNAME "usbkbd"
83 static unsigned char num_lock
= 0;
84 static unsigned char caps_lock
= 0;
85 static unsigned char scroll_lock
= 0;
86 static unsigned char ctrl
= 0;
88 static unsigned char leds
__attribute__ ((aligned (0x4)));
90 static unsigned char usb_kbd_numkey
[] = {
91 '1', '2', '3', '4', '5', '6', '7', '8', '9', '0','\r',0x1b,'\b','\t',' ', '-',
92 '=', '[', ']','\\', '#', ';', '\'', '`', ',', '.', '/'
94 static unsigned char usb_kbd_numkey_shifted
[] = {
95 '!', '@', '#', '$', '%', '^', '&', '*', '(', ')','\r',0x1b,'\b','\t',' ', '_',
96 '+', '{', '}', '|', '~', ':', '"', '~', '<', '>', '?'
99 /******************************************************************
101 ******************************************************************/
102 /* puts character in the queue and sets up the in and out pointer */
103 static void usb_kbd_put_queue(char data
)
105 if((usb_in_pointer
+1)==USB_KBD_BUFFER_LEN
) {
106 if(usb_out_pointer
==0) {
107 return; /* buffer full */
112 if((usb_in_pointer
+1)==usb_out_pointer
)
113 return; /* buffer full */
116 usb_kbd_buffer
[usb_in_pointer
]=data
;
120 /* test if a character is in the queue */
121 static int usb_kbd_testc(void)
123 #ifdef CONFIG_SYS_USB_EVENT_POLL
126 if(usb_in_pointer
==usb_out_pointer
)
127 return(0); /* no data */
131 /* gets the character from the queue */
132 static int usb_kbd_getc(void)
135 while(usb_in_pointer
==usb_out_pointer
) {
136 #ifdef CONFIG_SYS_USB_EVENT_POLL
140 if((usb_out_pointer
+1)==USB_KBD_BUFFER_LEN
)
144 c
=usb_kbd_buffer
[usb_out_pointer
];
149 /* forward decleration */
150 static int usb_kbd_probe(struct usb_device
*dev
, unsigned int ifnum
);
152 /* search for keyboard and register it if found */
153 int drv_usb_kbd_init(void)
156 device_t usb_kbd_dev
,*old_dev
;
157 struct usb_device
*dev
;
158 char *stdinname
= getenv ("stdin");
162 /* scan all USB Devices */
163 for(i
=0;i
<USB_MAX_DEVICE
;i
++) {
164 dev
=usb_get_dev_index(i
); /* get device */
167 if(dev
->devnum
!=-1) {
168 if(usb_kbd_probe(dev
,0)==1) { /* Ok, we found a keyboard */
169 /* check, if it is already registered */
170 USB_KBD_PRINTF("USB KBD found set up device.\n");
171 old_dev
= device_get_by_name(DEVNAME
);
173 /* ok, already registered, just return ok */
174 USB_KBD_PRINTF("USB KBD is already registered.\n");
177 /* register the keyboard */
178 USB_KBD_PRINTF("USB KBD register.\n");
179 memset (&usb_kbd_dev
, 0, sizeof(device_t
));
180 strcpy(usb_kbd_dev
.name
, DEVNAME
);
181 usb_kbd_dev
.flags
= DEV_FLAGS_INPUT
| DEV_FLAGS_SYSTEM
;
182 usb_kbd_dev
.putc
= NULL
;
183 usb_kbd_dev
.puts
= NULL
;
184 usb_kbd_dev
.getc
= usb_kbd_getc
;
185 usb_kbd_dev
.tstc
= usb_kbd_testc
;
186 usb_kbd_dev
.priv
= (void *)dev
;
187 error
= device_register (&usb_kbd_dev
);
189 /* check if this is the standard input device */
190 if(strcmp(stdinname
,DEVNAME
)==0) {
191 /* reassign the console */
192 if(overwrite_console()) {
195 error
=console_assign(stdin
,DEVNAME
);
207 /* no USB Keyboard found */
212 /* deregistering the keyboard */
213 int usb_kbd_deregister(void)
215 #ifdef CONFIG_SYS_DEVICE_DEREGISTER
216 return device_deregister(DEVNAME
);
222 /**************************************************************************
226 /* set the LEDs. Since this is used in the irq routine, the control job
227 is issued with a timeout of 0. This means, that the job is queued without
228 waiting for job completion */
230 static void usb_kbd_setled(struct usb_device
*dev
)
232 struct usb_interface_descriptor
*iface
;
233 iface
= &dev
->config
.if_desc
[0];
243 usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
244 USB_REQ_SET_REPORT
, USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
245 0x200, iface
->bInterfaceNumber
,(void *)&leds
, 1, 0);
250 #define CAPITAL_MASK 0x20
251 /* Translate the scancode in ASCII */
252 static int usb_kbd_translate(unsigned char scancode
,unsigned char modifier
,int pressed
)
254 unsigned char keycode
;
263 if(repeat_delay
<REPEAT_DELAY
)
265 repeat_delay
=REPEAT_DELAY
;
268 if((scancode
>3) && (scancode
<=0x1d)) { /* alpha numeric values */
269 keycode
=scancode
-4 + 0x61;
271 keycode
&=~CAPITAL_MASK
; /* switch to capital Letters */
272 if(((modifier
&(1<<LEFT_SHIFT
))!=0)||((modifier
&(1<<RIGHT_SHIFT
))!=0)) {
273 if(keycode
& CAPITAL_MASK
)
274 keycode
&=~CAPITAL_MASK
; /* switch to capital Letters */
276 keycode
|=CAPITAL_MASK
; /* switch to non capital Letters */
279 if((scancode
>0x1d) && (scancode
<0x3A)) {
280 if(((modifier
&(1<<LEFT_SHIFT
))!=0)||((modifier
&(1<<RIGHT_SHIFT
))!=0)) /* shifted */
281 keycode
=usb_kbd_numkey_shifted
[scancode
-0x1e];
282 else /* non shifted */
283 keycode
=usb_kbd_numkey
[scancode
-0x1e];
287 keycode
= scancode
- 0x3;
290 if(scancode
==NUM_LOCK
) {
294 if(scancode
==CAPS_LOCK
) {
295 caps_lock
=~caps_lock
;
298 if(scancode
==SCROLL_LOCK
) {
299 scroll_lock
=~scroll_lock
;
304 USB_KBD_PRINTF("%c",keycode
);
305 usb_kbd_put_queue(keycode
);
310 /* Interrupt service routine */
311 static int usb_kbd_irq(struct usb_device
*dev
)
315 if((dev
->irq_status
!=0)||(dev
->irq_act_len
!=8))
317 USB_KBD_PRINTF("usb_keyboard Error %lX, len %d\n",dev
->irq_status
,dev
->irq_act_len
);
323 case 0x0: /* No combo key pressed */
326 case 0x01: /* Left Ctrl pressed */
327 case 0x10: /* Right Ctrl pressed */
332 for (i
= 2; i
< 8; i
++) {
333 if (old
[i
] > 3 && memscan(&new[2], old
[i
], 6) == &new[8]) {
334 res
|=usb_kbd_translate(old
[i
],new[0],0);
336 if (new[i
] > 3 && memscan(&old
[2], new[i
], 6) == &old
[8]) {
337 res
|=usb_kbd_translate(new[i
],new[0],1);
340 if((new[2]>3) && (old
[2]==new[2])) /* still pressed */
341 res
|=usb_kbd_translate(new[2],new[0],2);
344 memcpy(&old
[0],&new[0], 8);
345 return 1; /* install IRQ Handler again */
348 /* probes the USB device dev for keyboard type */
349 static int usb_kbd_probe(struct usb_device
*dev
, unsigned int ifnum
)
351 struct usb_interface_descriptor
*iface
;
352 struct usb_endpoint_descriptor
*ep
;
355 if (dev
->descriptor
.bNumConfigurations
!= 1) return 0;
356 iface
= &dev
->config
.if_desc
[ifnum
];
358 if (iface
->bInterfaceClass
!= 3) return 0;
359 if (iface
->bInterfaceSubClass
!= 1) return 0;
360 if (iface
->bInterfaceProtocol
!= 1) return 0;
361 if (iface
->bNumEndpoints
!= 1) return 0;
363 ep
= &iface
->ep_desc
[0];
365 if (!(ep
->bEndpointAddress
& 0x80)) return 0;
366 if ((ep
->bmAttributes
& 3) != 3) return 0;
367 USB_KBD_PRINTF("USB KBD found set protocol...\n");
368 /* ok, we found a USB Keyboard, install it */
369 /* usb_kbd_get_hid_desc(dev); */
370 usb_set_protocol(dev
, iface
->bInterfaceNumber
, 0);
371 USB_KBD_PRINTF("USB KBD found set idle...\n");
372 usb_set_idle(dev
, iface
->bInterfaceNumber
, REPEAT_RATE
, 0);
373 memset(&new[0], 0, 8);
374 memset(&old
[0], 0, 8);
376 pipe
= usb_rcvintpipe(dev
, ep
->bEndpointAddress
);
377 maxp
= usb_maxpacket(dev
, pipe
);
378 dev
->irq_handle
=usb_kbd_irq
;
379 USB_KBD_PRINTF("USB KBD enable interrupt pipe...\n");
380 usb_submit_int_msg(dev
,pipe
,&new[0], maxp
> 8 ? 8 : maxp
,ep
->bInterval
);
386 struct usb_hid_descriptor
{
387 unsigned char bLength
;
388 unsigned char bDescriptorType
; /* 0x21 for HID */
389 unsigned short bcdHID
; /* release number */
390 unsigned char bCountryCode
;
391 unsigned char bNumDescriptors
;
392 unsigned char bReportDescriptorType
;
393 unsigned short wDescriptorLength
;
394 } __attribute__ ((packed
));
397 * We parse each description item into this structure. Short items data
398 * values are expanded to 32-bit signed int, long items contain a pointer
399 * into the data area.
403 unsigned char format
;
414 unsigned char *longdata
;
419 * HID report item format
422 #define HID_ITEM_FORMAT_SHORT 0
423 #define HID_ITEM_FORMAT_LONG 1
426 * Special tag indicating long items
429 #define HID_ITEM_TAG_LONG 15
432 static struct usb_hid_descriptor usb_kbd_hid_desc
;
434 void usb_kbd_display_hid(struct usb_hid_descriptor
*hid
)
436 printf("USB_HID_DESC:\n");
437 printf(" bLenght 0x%x\n",hid
->bLength
);
438 printf(" bcdHID 0x%x\n",hid
->bcdHID
);
439 printf(" bCountryCode %d\n",hid
->bCountryCode
);
440 printf(" bNumDescriptors 0x%x\n",hid
->bNumDescriptors
);
441 printf(" bReportDescriptorType 0x%x\n",hid
->bReportDescriptorType
);
442 printf(" wDescriptorLength 0x%x\n",hid
->wDescriptorLength
);
447 * Fetch a report description item from the data stream. We support long
448 * items, though they are not used yet.
451 static int fetch_item(unsigned char *start
,unsigned char *end
, struct hid_item
*item
)
453 if((end
- start
) > 0) {
454 unsigned char b
= *start
++;
455 item
->type
= (b
>> 2) & 3;
456 item
->tag
= (b
>> 4) & 15;
457 if (item
->tag
== HID_ITEM_TAG_LONG
) {
458 item
->format
= HID_ITEM_FORMAT_LONG
;
459 if ((end
- start
) >= 2) {
460 item
->size
= *start
++;
461 item
->tag
= *start
++;
462 if ((end
- start
) >= item
->size
) {
463 item
->data
.longdata
= start
;
469 item
->format
= HID_ITEM_FORMAT_SHORT
;
471 switch (item
->size
) {
475 if ((end
- start
) >= 1) {
476 item
->data
.u8
= *start
++;
481 if ((end
- start
) >= 2) {
482 item
->data
.u16
= le16_to_cpu((unsigned short *)start
);
488 if ((end
- start
) >= 4) {
489 item
->data
.u32
= le32_to_cpu((unsigned long *)start
);
500 * HID report descriptor item type (prefix bit 2,3)
503 #define HID_ITEM_TYPE_MAIN 0
504 #define HID_ITEM_TYPE_GLOBAL 1
505 #define HID_ITEM_TYPE_LOCAL 2
506 #define HID_ITEM_TYPE_RESERVED 3
508 * HID report descriptor main item tags
511 #define HID_MAIN_ITEM_TAG_INPUT 8
512 #define HID_MAIN_ITEM_TAG_OUTPUT 9
513 #define HID_MAIN_ITEM_TAG_FEATURE 11
514 #define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION 10
515 #define HID_MAIN_ITEM_TAG_END_COLLECTION 12
517 * HID report descriptor main item contents
520 #define HID_MAIN_ITEM_CONSTANT 0x001
521 #define HID_MAIN_ITEM_VARIABLE 0x002
522 #define HID_MAIN_ITEM_RELATIVE 0x004
523 #define HID_MAIN_ITEM_WRAP 0x008
524 #define HID_MAIN_ITEM_NONLINEAR 0x010
525 #define HID_MAIN_ITEM_NO_PREFERRED 0x020
526 #define HID_MAIN_ITEM_NULL_STATE 0x040
527 #define HID_MAIN_ITEM_VOLATILE 0x080
528 #define HID_MAIN_ITEM_BUFFERED_BYTE 0x100
531 * HID report descriptor collection item types
534 #define HID_COLLECTION_PHYSICAL 0
535 #define HID_COLLECTION_APPLICATION 1
536 #define HID_COLLECTION_LOGICAL 2
538 * HID report descriptor global item tags
541 #define HID_GLOBAL_ITEM_TAG_USAGE_PAGE 0
542 #define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM 1
543 #define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM 2
544 #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM 3
545 #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM 4
546 #define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT 5
547 #define HID_GLOBAL_ITEM_TAG_UNIT 6
548 #define HID_GLOBAL_ITEM_TAG_REPORT_SIZE 7
549 #define HID_GLOBAL_ITEM_TAG_REPORT_ID 8
550 #define HID_GLOBAL_ITEM_TAG_REPORT_COUNT 9
551 #define HID_GLOBAL_ITEM_TAG_PUSH 10
552 #define HID_GLOBAL_ITEM_TAG_POP 11
555 * HID report descriptor local item tags
558 #define HID_LOCAL_ITEM_TAG_USAGE 0
559 #define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM 1
560 #define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM 2
561 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX 3
562 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM 4
563 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM 5
564 #define HID_LOCAL_ITEM_TAG_STRING_INDEX 7
565 #define HID_LOCAL_ITEM_TAG_STRING_MINIMUM 8
566 #define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM 9
567 #define HID_LOCAL_ITEM_TAG_DELIMITER 10
570 static void usb_kbd_show_item(struct hid_item
*item
)
573 case HID_ITEM_TYPE_MAIN
:
575 case HID_MAIN_ITEM_TAG_INPUT
:
576 printf("Main Input");
578 case HID_MAIN_ITEM_TAG_OUTPUT
:
579 printf("Main Output");
581 case HID_MAIN_ITEM_TAG_FEATURE
:
582 printf("Main Feature");
584 case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION
:
585 printf("Main Begin Collection");
587 case HID_MAIN_ITEM_TAG_END_COLLECTION
:
588 printf("Main End Collection");
591 printf("Main reserved %d",item
->tag
);
595 case HID_ITEM_TYPE_GLOBAL
:
597 case HID_GLOBAL_ITEM_TAG_USAGE_PAGE
:
598 printf("- Global Usage Page");
600 case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM
:
601 printf("- Global Logical Minimum");
603 case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM
:
604 printf("- Global Logical Maximum");
606 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM
:
607 printf("- Global physical Minimum");
609 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM
:
610 printf("- Global physical Maximum");
612 case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT
:
613 printf("- Global Unit Exponent");
615 case HID_GLOBAL_ITEM_TAG_UNIT
:
616 printf("- Global Unit");
618 case HID_GLOBAL_ITEM_TAG_REPORT_SIZE
:
619 printf("- Global Report Size");
621 case HID_GLOBAL_ITEM_TAG_REPORT_ID
:
622 printf("- Global Report ID");
624 case HID_GLOBAL_ITEM_TAG_REPORT_COUNT
:
625 printf("- Global Report Count");
627 case HID_GLOBAL_ITEM_TAG_PUSH
:
628 printf("- Global Push");
630 case HID_GLOBAL_ITEM_TAG_POP
:
631 printf("- Global Pop");
634 printf("- Global reserved %d",item
->tag
);
638 case HID_ITEM_TYPE_LOCAL
:
640 case HID_LOCAL_ITEM_TAG_USAGE
:
641 printf("-- Local Usage");
643 case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM
:
644 printf("-- Local Usage Minimum");
646 case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM
:
647 printf("-- Local Usage Maximum");
649 case HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX
:
650 printf("-- Local Designator Index");
652 case HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM
:
653 printf("-- Local Designator Minimum");
655 case HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM
:
656 printf("-- Local Designator Maximum");
658 case HID_LOCAL_ITEM_TAG_STRING_INDEX
:
659 printf("-- Local String Index");
661 case HID_LOCAL_ITEM_TAG_STRING_MINIMUM
:
662 printf("-- Local String Minimum");
664 case HID_LOCAL_ITEM_TAG_STRING_MAXIMUM
:
665 printf("-- Local String Maximum");
667 case HID_LOCAL_ITEM_TAG_DELIMITER
:
668 printf("-- Local Delimiter");
671 printf("-- Local reserved %d",item
->tag
);
676 printf("--- reserved %d",item
->type
);
681 printf(" %d",item
->data
.u8
);
684 printf(" %d",item
->data
.u16
);
687 printf(" %ld",item
->data
.u32
);
694 static int usb_kbd_get_hid_desc(struct usb_device
*dev
)
696 unsigned char buffer
[256];
697 struct usb_descriptor_header
*head
;
698 struct usb_config_descriptor
*config
;
700 unsigned char *start
, *end
;
701 struct hid_item item
;
703 if(usb_get_configuration_no(dev
,&buffer
[0],0)==-1)
705 head
=(struct usb_descriptor_header
*)&buffer
[0];
706 if(head
->bDescriptorType
!=USB_DT_CONFIG
) {
707 printf(" ERROR: NOT USB_CONFIG_DESC %x\n",head
->bDescriptorType
);
711 config
=(struct usb_config_descriptor
*)&buffer
[0];
712 len
=le16_to_cpu(config
->wTotalLength
);
713 /* Ok the first entry must be a configuration entry, now process the others */
714 head
=(struct usb_descriptor_header
*)&buffer
[index
];
715 while(index
+1 < len
) {
716 if(head
->bDescriptorType
==USB_DT_HID
) {
717 printf("HID desc found\n");
718 memcpy(&usb_kbd_hid_desc
,&buffer
[index
],buffer
[index
]);
719 le16_to_cpus(&usb_kbd_hid_desc
.bcdHID
);
720 le16_to_cpus(&usb_kbd_hid_desc
.wDescriptorLength
);
721 usb_kbd_display_hid(&usb_kbd_hid_desc
);
725 index
+=head
->bLength
;
726 head
=(struct usb_descriptor_header
*)&buffer
[index
];
730 len
=usb_kbd_hid_desc
.wDescriptorLength
;
731 if((index
= usb_get_class_descriptor(dev
, 0, USB_DT_REPORT
, 0, &buffer
[0], len
)) < 0) {
732 printf("reading report descriptor failed\n");
735 printf(" report descriptor (size %u, read %d)\n", len
, index
);
740 index
=fetch_item(start
,end
,&item
);
744 usb_kbd_show_item(&item
);