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 error
= device_register (&usb_kbd_dev
);
188 /* check if this is the standard input device */
189 if(strcmp(stdinname
,DEVNAME
)==0) {
190 /* reassign the console */
191 if(overwrite_console()) {
194 error
=console_assign(stdin
,DEVNAME
);
206 /* no USB Keyboard found */
211 /* deregistering the keyboard */
212 int usb_kbd_deregister(void)
214 return device_deregister(DEVNAME
);
217 /**************************************************************************
221 /* set the LEDs. Since this is used in the irq routine, the control job
222 is issued with a timeout of 0. This means, that the job is queued without
223 waiting for job completion */
225 static void usb_kbd_setled(struct usb_device
*dev
)
227 struct usb_interface_descriptor
*iface
;
228 iface
= &dev
->config
.if_desc
[0];
238 usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
239 USB_REQ_SET_REPORT
, USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
240 0x200, iface
->bInterfaceNumber
,(void *)&leds
, 1, 0);
245 #define CAPITAL_MASK 0x20
246 /* Translate the scancode in ASCII */
247 static int usb_kbd_translate(unsigned char scancode
,unsigned char modifier
,int pressed
)
249 unsigned char keycode
;
258 if(repeat_delay
<REPEAT_DELAY
)
260 repeat_delay
=REPEAT_DELAY
;
263 if((scancode
>3) && (scancode
<=0x1d)) { /* alpha numeric values */
264 keycode
=scancode
-4 + 0x61;
266 keycode
&=~CAPITAL_MASK
; /* switch to capital Letters */
267 if(((modifier
&(1<<LEFT_SHIFT
))!=0)||((modifier
&(1<<RIGHT_SHIFT
))!=0)) {
268 if(keycode
& CAPITAL_MASK
)
269 keycode
&=~CAPITAL_MASK
; /* switch to capital Letters */
271 keycode
|=CAPITAL_MASK
; /* switch to non capital Letters */
274 if((scancode
>0x1d) && (scancode
<0x3A)) {
275 if(((modifier
&(1<<LEFT_SHIFT
))!=0)||((modifier
&(1<<RIGHT_SHIFT
))!=0)) /* shifted */
276 keycode
=usb_kbd_numkey_shifted
[scancode
-0x1e];
277 else /* non shifted */
278 keycode
=usb_kbd_numkey
[scancode
-0x1e];
282 keycode
= scancode
- 0x3;
285 if(scancode
==NUM_LOCK
) {
289 if(scancode
==CAPS_LOCK
) {
290 caps_lock
=~caps_lock
;
293 if(scancode
==SCROLL_LOCK
) {
294 scroll_lock
=~scroll_lock
;
299 USB_KBD_PRINTF("%c",keycode
);
300 usb_kbd_put_queue(keycode
);
305 /* Interrupt service routine */
306 static int usb_kbd_irq(struct usb_device
*dev
)
310 if((dev
->irq_status
!=0)||(dev
->irq_act_len
!=8))
312 USB_KBD_PRINTF("usb_keyboard Error %lX, len %d\n",dev
->irq_status
,dev
->irq_act_len
);
318 case 0x0: /* No combo key pressed */
321 case 0x01: /* Left Ctrl pressed */
322 case 0x10: /* Right Ctrl pressed */
327 for (i
= 2; i
< 8; i
++) {
328 if (old
[i
] > 3 && memscan(&new[2], old
[i
], 6) == &new[8]) {
329 res
|=usb_kbd_translate(old
[i
],new[0],0);
331 if (new[i
] > 3 && memscan(&old
[2], new[i
], 6) == &old
[8]) {
332 res
|=usb_kbd_translate(new[i
],new[0],1);
335 if((new[2]>3) && (old
[2]==new[2])) /* still pressed */
336 res
|=usb_kbd_translate(new[2],new[0],2);
339 memcpy(&old
[0],&new[0], 8);
340 return 1; /* install IRQ Handler again */
343 /* probes the USB device dev for keyboard type */
344 static int usb_kbd_probe(struct usb_device
*dev
, unsigned int ifnum
)
346 struct usb_interface_descriptor
*iface
;
347 struct usb_endpoint_descriptor
*ep
;
350 if (dev
->descriptor
.bNumConfigurations
!= 1) return 0;
351 iface
= &dev
->config
.if_desc
[ifnum
];
353 if (iface
->bInterfaceClass
!= 3) return 0;
354 if (iface
->bInterfaceSubClass
!= 1) return 0;
355 if (iface
->bInterfaceProtocol
!= 1) return 0;
356 if (iface
->bNumEndpoints
!= 1) return 0;
358 ep
= &iface
->ep_desc
[0];
360 if (!(ep
->bEndpointAddress
& 0x80)) return 0;
361 if ((ep
->bmAttributes
& 3) != 3) return 0;
362 USB_KBD_PRINTF("USB KBD found set protocol...\n");
363 /* ok, we found a USB Keyboard, install it */
364 /* usb_kbd_get_hid_desc(dev); */
365 usb_set_protocol(dev
, iface
->bInterfaceNumber
, 0);
366 USB_KBD_PRINTF("USB KBD found set idle...\n");
367 usb_set_idle(dev
, iface
->bInterfaceNumber
, REPEAT_RATE
, 0);
368 memset(&new[0], 0, 8);
369 memset(&old
[0], 0, 8);
371 pipe
= usb_rcvintpipe(dev
, ep
->bEndpointAddress
);
372 maxp
= usb_maxpacket(dev
, pipe
);
373 dev
->irq_handle
=usb_kbd_irq
;
374 USB_KBD_PRINTF("USB KBD enable interrupt pipe...\n");
375 usb_submit_int_msg(dev
,pipe
,&new[0], maxp
> 8 ? 8 : maxp
,ep
->bInterval
);
381 struct usb_hid_descriptor
{
382 unsigned char bLength
;
383 unsigned char bDescriptorType
; /* 0x21 for HID */
384 unsigned short bcdHID
; /* release number */
385 unsigned char bCountryCode
;
386 unsigned char bNumDescriptors
;
387 unsigned char bReportDescriptorType
;
388 unsigned short wDescriptorLength
;
389 } __attribute__ ((packed
));
392 * We parse each description item into this structure. Short items data
393 * values are expanded to 32-bit signed int, long items contain a pointer
394 * into the data area.
398 unsigned char format
;
409 unsigned char *longdata
;
414 * HID report item format
417 #define HID_ITEM_FORMAT_SHORT 0
418 #define HID_ITEM_FORMAT_LONG 1
421 * Special tag indicating long items
424 #define HID_ITEM_TAG_LONG 15
427 static struct usb_hid_descriptor usb_kbd_hid_desc
;
429 void usb_kbd_display_hid(struct usb_hid_descriptor
*hid
)
431 printf("USB_HID_DESC:\n");
432 printf(" bLenght 0x%x\n",hid
->bLength
);
433 printf(" bcdHID 0x%x\n",hid
->bcdHID
);
434 printf(" bCountryCode %d\n",hid
->bCountryCode
);
435 printf(" bNumDescriptors 0x%x\n",hid
->bNumDescriptors
);
436 printf(" bReportDescriptorType 0x%x\n",hid
->bReportDescriptorType
);
437 printf(" wDescriptorLength 0x%x\n",hid
->wDescriptorLength
);
442 * Fetch a report description item from the data stream. We support long
443 * items, though they are not used yet.
446 static int fetch_item(unsigned char *start
,unsigned char *end
, struct hid_item
*item
)
448 if((end
- start
) > 0) {
449 unsigned char b
= *start
++;
450 item
->type
= (b
>> 2) & 3;
451 item
->tag
= (b
>> 4) & 15;
452 if (item
->tag
== HID_ITEM_TAG_LONG
) {
453 item
->format
= HID_ITEM_FORMAT_LONG
;
454 if ((end
- start
) >= 2) {
455 item
->size
= *start
++;
456 item
->tag
= *start
++;
457 if ((end
- start
) >= item
->size
) {
458 item
->data
.longdata
= start
;
464 item
->format
= HID_ITEM_FORMAT_SHORT
;
466 switch (item
->size
) {
470 if ((end
- start
) >= 1) {
471 item
->data
.u8
= *start
++;
476 if ((end
- start
) >= 2) {
477 item
->data
.u16
= le16_to_cpu((unsigned short *)start
);
483 if ((end
- start
) >= 4) {
484 item
->data
.u32
= le32_to_cpu((unsigned long *)start
);
495 * HID report descriptor item type (prefix bit 2,3)
498 #define HID_ITEM_TYPE_MAIN 0
499 #define HID_ITEM_TYPE_GLOBAL 1
500 #define HID_ITEM_TYPE_LOCAL 2
501 #define HID_ITEM_TYPE_RESERVED 3
503 * HID report descriptor main item tags
506 #define HID_MAIN_ITEM_TAG_INPUT 8
507 #define HID_MAIN_ITEM_TAG_OUTPUT 9
508 #define HID_MAIN_ITEM_TAG_FEATURE 11
509 #define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION 10
510 #define HID_MAIN_ITEM_TAG_END_COLLECTION 12
512 * HID report descriptor main item contents
515 #define HID_MAIN_ITEM_CONSTANT 0x001
516 #define HID_MAIN_ITEM_VARIABLE 0x002
517 #define HID_MAIN_ITEM_RELATIVE 0x004
518 #define HID_MAIN_ITEM_WRAP 0x008
519 #define HID_MAIN_ITEM_NONLINEAR 0x010
520 #define HID_MAIN_ITEM_NO_PREFERRED 0x020
521 #define HID_MAIN_ITEM_NULL_STATE 0x040
522 #define HID_MAIN_ITEM_VOLATILE 0x080
523 #define HID_MAIN_ITEM_BUFFERED_BYTE 0x100
526 * HID report descriptor collection item types
529 #define HID_COLLECTION_PHYSICAL 0
530 #define HID_COLLECTION_APPLICATION 1
531 #define HID_COLLECTION_LOGICAL 2
533 * HID report descriptor global item tags
536 #define HID_GLOBAL_ITEM_TAG_USAGE_PAGE 0
537 #define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM 1
538 #define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM 2
539 #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM 3
540 #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM 4
541 #define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT 5
542 #define HID_GLOBAL_ITEM_TAG_UNIT 6
543 #define HID_GLOBAL_ITEM_TAG_REPORT_SIZE 7
544 #define HID_GLOBAL_ITEM_TAG_REPORT_ID 8
545 #define HID_GLOBAL_ITEM_TAG_REPORT_COUNT 9
546 #define HID_GLOBAL_ITEM_TAG_PUSH 10
547 #define HID_GLOBAL_ITEM_TAG_POP 11
550 * HID report descriptor local item tags
553 #define HID_LOCAL_ITEM_TAG_USAGE 0
554 #define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM 1
555 #define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM 2
556 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX 3
557 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM 4
558 #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM 5
559 #define HID_LOCAL_ITEM_TAG_STRING_INDEX 7
560 #define HID_LOCAL_ITEM_TAG_STRING_MINIMUM 8
561 #define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM 9
562 #define HID_LOCAL_ITEM_TAG_DELIMITER 10
565 static void usb_kbd_show_item(struct hid_item
*item
)
568 case HID_ITEM_TYPE_MAIN
:
570 case HID_MAIN_ITEM_TAG_INPUT
:
571 printf("Main Input");
573 case HID_MAIN_ITEM_TAG_OUTPUT
:
574 printf("Main Output");
576 case HID_MAIN_ITEM_TAG_FEATURE
:
577 printf("Main Feature");
579 case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION
:
580 printf("Main Begin Collection");
582 case HID_MAIN_ITEM_TAG_END_COLLECTION
:
583 printf("Main End Collection");
586 printf("Main reserved %d",item
->tag
);
590 case HID_ITEM_TYPE_GLOBAL
:
592 case HID_GLOBAL_ITEM_TAG_USAGE_PAGE
:
593 printf("- Global Usage Page");
595 case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM
:
596 printf("- Global Logical Minimum");
598 case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM
:
599 printf("- Global Logical Maximum");
601 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM
:
602 printf("- Global physical Minimum");
604 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM
:
605 printf("- Global physical Maximum");
607 case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT
:
608 printf("- Global Unit Exponent");
610 case HID_GLOBAL_ITEM_TAG_UNIT
:
611 printf("- Global Unit");
613 case HID_GLOBAL_ITEM_TAG_REPORT_SIZE
:
614 printf("- Global Report Size");
616 case HID_GLOBAL_ITEM_TAG_REPORT_ID
:
617 printf("- Global Report ID");
619 case HID_GLOBAL_ITEM_TAG_REPORT_COUNT
:
620 printf("- Global Report Count");
622 case HID_GLOBAL_ITEM_TAG_PUSH
:
623 printf("- Global Push");
625 case HID_GLOBAL_ITEM_TAG_POP
:
626 printf("- Global Pop");
629 printf("- Global reserved %d",item
->tag
);
633 case HID_ITEM_TYPE_LOCAL
:
635 case HID_LOCAL_ITEM_TAG_USAGE
:
636 printf("-- Local Usage");
638 case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM
:
639 printf("-- Local Usage Minimum");
641 case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM
:
642 printf("-- Local Usage Maximum");
644 case HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX
:
645 printf("-- Local Designator Index");
647 case HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM
:
648 printf("-- Local Designator Minimum");
650 case HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM
:
651 printf("-- Local Designator Maximum");
653 case HID_LOCAL_ITEM_TAG_STRING_INDEX
:
654 printf("-- Local String Index");
656 case HID_LOCAL_ITEM_TAG_STRING_MINIMUM
:
657 printf("-- Local String Minimum");
659 case HID_LOCAL_ITEM_TAG_STRING_MAXIMUM
:
660 printf("-- Local String Maximum");
662 case HID_LOCAL_ITEM_TAG_DELIMITER
:
663 printf("-- Local Delimiter");
666 printf("-- Local reserved %d",item
->tag
);
671 printf("--- reserved %d",item
->type
);
676 printf(" %d",item
->data
.u8
);
679 printf(" %d",item
->data
.u16
);
682 printf(" %ld",item
->data
.u32
);
689 static int usb_kbd_get_hid_desc(struct usb_device
*dev
)
691 unsigned char buffer
[256];
692 struct usb_descriptor_header
*head
;
693 struct usb_config_descriptor
*config
;
695 unsigned char *start
, *end
;
696 struct hid_item item
;
698 if(usb_get_configuration_no(dev
,&buffer
[0],0)==-1)
700 head
=(struct usb_descriptor_header
*)&buffer
[0];
701 if(head
->bDescriptorType
!=USB_DT_CONFIG
) {
702 printf(" ERROR: NOT USB_CONFIG_DESC %x\n",head
->bDescriptorType
);
706 config
=(struct usb_config_descriptor
*)&buffer
[0];
707 len
=le16_to_cpu(config
->wTotalLength
);
708 /* Ok the first entry must be a configuration entry, now process the others */
709 head
=(struct usb_descriptor_header
*)&buffer
[index
];
710 while(index
+1 < len
) {
711 if(head
->bDescriptorType
==USB_DT_HID
) {
712 printf("HID desc found\n");
713 memcpy(&usb_kbd_hid_desc
,&buffer
[index
],buffer
[index
]);
714 le16_to_cpus(&usb_kbd_hid_desc
.bcdHID
);
715 le16_to_cpus(&usb_kbd_hid_desc
.wDescriptorLength
);
716 usb_kbd_display_hid(&usb_kbd_hid_desc
);
720 index
+=head
->bLength
;
721 head
=(struct usb_descriptor_header
*)&buffer
[index
];
725 len
=usb_kbd_hid_desc
.wDescriptorLength
;
726 if((index
= usb_get_class_descriptor(dev
, 0, USB_DT_REPORT
, 0, &buffer
[0], len
)) < 0) {
727 printf("reading report descriptor failed\n");
730 printf(" report descriptor (size %u, read %d)\n", len
, index
);
735 index
=fetch_item(start
,end
,&item
);
739 usb_kbd_show_item(&item
);