]>
git.ipfire.org Git - people/ms/u-boot.git/blob - common/usb_kbd.c
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 <stdio_dev.h>
30 #include <asm/byteorder.h>
35 #define USB_KBD_PRINTF(fmt, args...) printf(fmt, ##args)
37 #define USB_KBD_PRINTF(fmt, args...)
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
45 #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
46 extern int overwrite_console(void);
48 int overwrite_console(void)
54 /* Keyboard sampling rate */
55 #define REPEAT_RATE (40 / 4) /* 40msec -> 25cps */
56 #define REPEAT_DELAY 10 /* 10 x REPEAT_RATE = 400msec */
59 #define CAPS_LOCK 0x39
60 #define SCROLL_LOCK 0x47
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)
72 /* Size of the keyboard buffer */
73 #define USB_KBD_BUFFER_LEN 0x20
76 #define DEVNAME "usbkbd"
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 '\\', '#', ';', '\'', '`', ',', '.', '/'
84 static const unsigned char usb_kbd_numkey_shifted
[] = {
85 '!', '@', '#', '$', '%', '^', '&', '*', '(', ')',
86 '\r', 0x1b, '\b', '\t', ' ', '_', '+', '{', '}',
87 '|', '~', ':', '"', '~', '<', '>', '?'
90 static const unsigned char usb_kbd_num_keypad
[] = {
91 '/', '*', '-', '+', '\r',
92 '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
97 * map arrow keys to ^F/^B ^N/^P, can't really use the proper
98 * ANSI sequence for arrow keys because the queuing code breaks
99 * when a single keypress expands to 3 queue elements
101 static const unsigned char usb_kbd_arrow
[] = {
106 * NOTE: It's important for the NUM, CAPS, SCROLL-lock bits to be in this
107 * order. See usb_kbd_setled() function!
109 #define USB_KBD_NUMLOCK (1 << 0)
110 #define USB_KBD_CAPSLOCK (1 << 1)
111 #define USB_KBD_SCROLLLOCK (1 << 2)
112 #define USB_KBD_CTRL (1 << 3)
114 #define USB_KBD_LEDMASK \
115 (USB_KBD_NUMLOCK | USB_KBD_CAPSLOCK | USB_KBD_SCROLLLOCK)
117 struct usb_kbd_pdata
{
118 uint32_t repeat_delay
;
120 uint32_t usb_in_pointer
;
121 uint32_t usb_out_pointer
;
122 uint8_t usb_kbd_buffer
[USB_KBD_BUFFER_LEN
];
130 /* Generic keyboard event polling. */
131 void usb_kbd_generic_poll(void)
133 struct stdio_dev
*dev
;
134 struct usb_device
*usb_kbd_dev
;
135 struct usb_kbd_pdata
*data
;
136 struct usb_interface
*iface
;
137 struct usb_endpoint_descriptor
*ep
;
141 /* Get the pointer to USB Keyboard device pointer */
142 dev
= stdio_get_by_name(DEVNAME
);
143 usb_kbd_dev
= (struct usb_device
*)dev
->priv
;
144 data
= usb_kbd_dev
->privptr
;
145 iface
= &usb_kbd_dev
->config
.if_desc
[0];
146 ep
= &iface
->ep_desc
[0];
147 pipe
= usb_rcvintpipe(usb_kbd_dev
, ep
->bEndpointAddress
);
149 /* Submit a interrupt transfer request */
150 maxp
= usb_maxpacket(usb_kbd_dev
, pipe
);
151 usb_submit_int_msg(usb_kbd_dev
, pipe
, data
->new,
152 maxp
> 8 ? 8 : maxp
, ep
->bInterval
);
155 /* Puts character in the queue and sets up the in and out pointer. */
156 static void usb_kbd_put_queue(struct usb_kbd_pdata
*data
, char c
)
158 if (data
->usb_in_pointer
== USB_KBD_BUFFER_LEN
- 1) {
159 /* Check for buffer full. */
160 if (data
->usb_out_pointer
== 0)
163 data
->usb_in_pointer
= 0;
165 /* Check for buffer full. */
166 if (data
->usb_in_pointer
== data
->usb_out_pointer
- 1)
169 data
->usb_in_pointer
++;
172 data
->usb_kbd_buffer
[data
->usb_in_pointer
] = c
;
176 * Set the LEDs. Since this is used in the irq routine, the control job is
177 * issued with a timeout of 0. This means, that the job is queued without
178 * waiting for job completion.
180 static void usb_kbd_setled(struct usb_device
*dev
)
182 struct usb_interface
*iface
= &dev
->config
.if_desc
[0];
183 struct usb_kbd_pdata
*data
= dev
->privptr
;
184 uint32_t leds
= data
->flags
& USB_KBD_LEDMASK
;
186 usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
187 USB_REQ_SET_REPORT
, USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
188 0x200, iface
->desc
.bInterfaceNumber
, (void *)&leds
, 1, 0);
191 #define CAPITAL_MASK 0x20
192 /* Translate the scancode in ASCII */
193 static int usb_kbd_translate(struct usb_kbd_pdata
*data
, unsigned char scancode
,
194 unsigned char modifier
, int pressed
)
200 data
->repeat_delay
= 0;
205 data
->repeat_delay
++;
206 if (data
->repeat_delay
< REPEAT_DELAY
)
209 data
->repeat_delay
= REPEAT_DELAY
;
212 /* Alphanumeric values */
213 if ((scancode
> 3) && (scancode
<= 0x1d)) {
214 keycode
= scancode
- 4 + 'a';
216 if (data
->flags
& USB_KBD_CAPSLOCK
)
217 keycode
&= ~CAPITAL_MASK
;
219 if (modifier
& (LEFT_SHIFT
| RIGHT_SHIFT
)) {
220 /* Handle CAPSLock + Shift pressed simultaneously */
221 if (keycode
& CAPITAL_MASK
)
222 keycode
&= ~CAPITAL_MASK
;
224 keycode
|= CAPITAL_MASK
;
228 if ((scancode
> 0x1d) && (scancode
< 0x3a)) {
230 if (modifier
& (LEFT_SHIFT
| RIGHT_SHIFT
))
231 keycode
= usb_kbd_numkey_shifted
[scancode
- 0x1e];
233 keycode
= usb_kbd_numkey
[scancode
- 0x1e];
237 if ((scancode
>= 0x4f) && (scancode
<= 0x52))
238 keycode
= usb_kbd_arrow
[scancode
- 0x4f];
241 if ((scancode
>= 0x54) && (scancode
<= 0x67))
242 keycode
= usb_kbd_num_keypad
[scancode
- 0x54];
244 if (data
->flags
& USB_KBD_CTRL
)
245 keycode
= scancode
- 0x3;
248 if (scancode
== NUM_LOCK
) {
249 data
->flags
^= USB_KBD_NUMLOCK
;
253 if (scancode
== CAPS_LOCK
) {
254 data
->flags
^= USB_KBD_CAPSLOCK
;
257 if (scancode
== SCROLL_LOCK
) {
258 data
->flags
^= USB_KBD_SCROLLLOCK
;
263 /* Report keycode if any */
265 USB_KBD_PRINTF("%c", keycode
);
266 usb_kbd_put_queue(data
, keycode
);
272 static uint32_t usb_kbd_service_key(struct usb_device
*dev
, int i
, int up
)
275 struct usb_kbd_pdata
*data
= dev
->privptr
;
287 if ((old
[i
] > 3) && (memscan(new + 2, old
[i
], 6) == new + 8))
288 res
|= usb_kbd_translate(data
, old
[i
], data
->new[0], up
);
293 /* Interrupt service routine */
294 static int usb_kbd_irq_worker(struct usb_device
*dev
)
296 struct usb_kbd_pdata
*data
= dev
->privptr
;
299 /* No combo key pressed */
300 if (data
->new[0] == 0x00)
301 data
->flags
&= ~USB_KBD_CTRL
;
302 /* Left or Right Ctrl pressed */
303 else if ((data
->new[0] == LEFT_CNTR
) || (data
->new[0] == RIGHT_CNTR
))
304 data
->flags
|= USB_KBD_CTRL
;
306 for (i
= 2; i
< 8; i
++) {
307 res
|= usb_kbd_service_key(dev
, i
, 0);
308 res
|= usb_kbd_service_key(dev
, i
, 1);
311 /* Key is still pressed */
312 if ((data
->new[2] > 3) && (data
->old
[2] == data
->new[2]))
313 res
|= usb_kbd_translate(data
, data
->new[2], data
->new[0], 2);
318 memcpy(data
->old
, data
->new, 8);
323 /* Keyboard interrupt handler */
324 static int usb_kbd_irq(struct usb_device
*dev
)
326 if ((dev
->irq_status
!= 0) || (dev
->irq_act_len
!= 8)) {
327 USB_KBD_PRINTF("USB KBD: Error %lX, len %d\n",
328 dev
->irq_status
, dev
->irq_act_len
);
332 return usb_kbd_irq_worker(dev
);
335 /* Interrupt polling */
336 static inline void usb_kbd_poll_for_event(struct usb_device
*dev
)
338 #if defined(CONFIG_SYS_USB_EVENT_POLL)
339 struct usb_interface
*iface
;
340 struct usb_endpoint_descriptor
*ep
;
341 struct usb_kbd_pdata
*data
;
345 /* Get the pointer to USB Keyboard device pointer */
347 iface
= &dev
->config
.if_desc
[0];
348 ep
= &iface
->ep_desc
[0];
349 pipe
= usb_rcvintpipe(dev
, ep
->bEndpointAddress
);
351 /* Submit a interrupt transfer request */
352 maxp
= usb_maxpacket(dev
, pipe
);
353 usb_submit_int_msg(dev
, pipe
, &data
->new[0],
354 maxp
> 8 ? 8 : maxp
, ep
->bInterval
);
356 usb_kbd_irq_worker(dev
);
357 #elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
358 struct usb_interface
*iface
;
359 struct usb_kbd_pdata
*data
= dev
->privptr
;
360 iface
= &dev
->config
.if_desc
[0];
361 usb_get_report(dev
, iface
->desc
.bInterfaceNumber
,
362 1, 0, data
->new, sizeof(data
->new));
363 if (memcmp(data
->old
, data
->new, sizeof(data
->new)))
364 usb_kbd_irq_worker(dev
);
368 /* test if a character is in the queue */
369 static int usb_kbd_testc(void)
371 struct stdio_dev
*dev
;
372 struct usb_device
*usb_kbd_dev
;
373 struct usb_kbd_pdata
*data
;
375 dev
= stdio_get_by_name(DEVNAME
);
376 usb_kbd_dev
= (struct usb_device
*)dev
->priv
;
377 data
= usb_kbd_dev
->privptr
;
379 usb_kbd_poll_for_event(usb_kbd_dev
);
381 return !(data
->usb_in_pointer
== data
->usb_out_pointer
);
384 /* gets the character from the queue */
385 static int usb_kbd_getc(void)
387 struct stdio_dev
*dev
;
388 struct usb_device
*usb_kbd_dev
;
389 struct usb_kbd_pdata
*data
;
391 dev
= stdio_get_by_name(DEVNAME
);
392 usb_kbd_dev
= (struct usb_device
*)dev
->priv
;
393 data
= usb_kbd_dev
->privptr
;
395 while (data
->usb_in_pointer
== data
->usb_out_pointer
)
396 usb_kbd_poll_for_event(usb_kbd_dev
);
398 if (data
->usb_out_pointer
== USB_KBD_BUFFER_LEN
- 1)
399 data
->usb_out_pointer
= 0;
401 data
->usb_out_pointer
++;
403 return data
->usb_kbd_buffer
[data
->usb_out_pointer
];
406 /* probes the USB device dev for keyboard type. */
407 static int usb_kbd_probe(struct usb_device
*dev
, unsigned int ifnum
)
409 struct usb_interface
*iface
;
410 struct usb_endpoint_descriptor
*ep
;
411 struct usb_kbd_pdata
*data
;
414 if (dev
->descriptor
.bNumConfigurations
!= 1)
417 iface
= &dev
->config
.if_desc
[ifnum
];
419 if (iface
->desc
.bInterfaceClass
!= 3)
422 if (iface
->desc
.bInterfaceSubClass
!= 1)
425 if (iface
->desc
.bInterfaceProtocol
!= 1)
428 if (iface
->desc
.bNumEndpoints
!= 1)
431 ep
= &iface
->ep_desc
[0];
433 /* Check if endpoint 1 is interrupt endpoint */
434 if (!(ep
->bEndpointAddress
& 0x80))
437 if ((ep
->bmAttributes
& 3) != 3)
440 USB_KBD_PRINTF("USB KBD: found set protocol...\n");
442 data
= malloc(sizeof(struct usb_kbd_pdata
));
444 printf("USB KBD: Error allocating private data\n");
448 /* Clear private data */
449 memset(data
, 0, sizeof(struct usb_kbd_pdata
));
451 /* allocate input buffer aligned and sized to USB DMA alignment */
452 data
->new = memalign(USB_DMA_MINALIGN
, roundup(8, USB_DMA_MINALIGN
));
454 /* Insert private data into USB device structure */
457 /* Set IRQ handler */
458 dev
->irq_handle
= usb_kbd_irq
;
460 pipe
= usb_rcvintpipe(dev
, ep
->bEndpointAddress
);
461 maxp
= usb_maxpacket(dev
, pipe
);
463 /* We found a USB Keyboard, install it. */
464 usb_set_protocol(dev
, iface
->desc
.bInterfaceNumber
, 0);
466 USB_KBD_PRINTF("USB KBD: found set idle...\n");
467 usb_set_idle(dev
, iface
->desc
.bInterfaceNumber
, REPEAT_RATE
, 0);
469 USB_KBD_PRINTF("USB KBD: enable interrupt pipe...\n");
470 usb_submit_int_msg(dev
, pipe
, data
->new, maxp
> 8 ? 8 : maxp
,
477 /* Search for keyboard and register it if found. */
478 int drv_usb_kbd_init(void)
480 struct stdio_dev usb_kbd_dev
, *old_dev
;
481 struct usb_device
*dev
;
482 char *stdinname
= getenv("stdin");
485 /* Scan all USB Devices */
486 for (i
= 0; i
< USB_MAX_DEVICE
; i
++) {
487 /* Get USB device. */
488 dev
= usb_get_dev_index(i
);
492 if (dev
->devnum
== -1)
495 /* Try probing the keyboard */
496 if (usb_kbd_probe(dev
, 0) != 1)
499 /* We found a keyboard, check if it is already registered. */
500 USB_KBD_PRINTF("USB KBD: found set up device.\n");
501 old_dev
= stdio_get_by_name(DEVNAME
);
503 /* Already registered, just return ok. */
504 USB_KBD_PRINTF("USB KBD: is already registered.\n");
508 /* Register the keyboard */
509 USB_KBD_PRINTF("USB KBD: register.\n");
510 memset(&usb_kbd_dev
, 0, sizeof(struct stdio_dev
));
511 strcpy(usb_kbd_dev
.name
, DEVNAME
);
512 usb_kbd_dev
.flags
= DEV_FLAGS_INPUT
| DEV_FLAGS_SYSTEM
;
513 usb_kbd_dev
.putc
= NULL
;
514 usb_kbd_dev
.puts
= NULL
;
515 usb_kbd_dev
.getc
= usb_kbd_getc
;
516 usb_kbd_dev
.tstc
= usb_kbd_testc
;
517 usb_kbd_dev
.priv
= (void *)dev
;
518 error
= stdio_register(&usb_kbd_dev
);
522 #ifdef CONFIG_CONSOLE_MUX
523 error
= iomux_doenv(stdin
, stdinname
);
527 /* Check if this is the standard input device. */
528 if (strcmp(stdinname
, DEVNAME
))
531 /* Reassign the console */
532 if (overwrite_console())
535 error
= console_assign(stdin
, DEVNAME
);
543 /* No USB Keyboard found */
547 /* Deregister the keyboard. */
548 int usb_kbd_deregister(void)
550 #ifdef CONFIG_SYS_STDIO_DEREGISTER
551 return stdio_deregister(DEVNAME
);