]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
affae2bf WD |
2 | /* |
3 | * (C) Copyright 2001 | |
4 | * Denis Peter, MPL AG Switzerland | |
5 | * | |
6 | * Part of this source has been derived from the Linux USB | |
7 | * project. | |
affae2bf | 8 | */ |
24b852a7 | 9 | #include <console.h> |
697033cb | 10 | #include <dm.h> |
7b51b576 | 11 | #include <env.h> |
0ea09dfe | 12 | #include <errno.h> |
f7ae49fc | 13 | #include <log.h> |
9a8c72a6 | 14 | #include <malloc.h> |
cf92e05c | 15 | #include <memalign.h> |
52cb4d4f | 16 | #include <stdio_dev.h> |
03de305e | 17 | #include <time.h> |
f8f3e0e5 | 18 | #include <watchdog.h> |
c918261c | 19 | #include <asm/byteorder.h> |
96991e65 TW |
20 | #ifdef CONFIG_SANDBOX |
21 | #include <asm/state.h> | |
22 | #endif | |
affae2bf | 23 | |
affae2bf WD |
24 | #include <usb.h> |
25 | ||
575c6827 JG |
26 | /* |
27 | * USB vendor and product IDs used for quirks. | |
28 | */ | |
29 | #define USB_VENDOR_ID_APPLE 0x05ac | |
30 | #define USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2021 0x029c | |
31 | #define USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_FINGERPRINT_2021 0x029a | |
32 | #define USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2021 0x029f | |
33 | ||
63f6a449 JG |
34 | #define USB_VENDOR_ID_KEYCHRON 0x3434 |
35 | ||
36 | #define USB_HID_QUIRK_POLL_NO_REPORT_IDLE BIT(0) | |
37 | ||
affae2bf | 38 | /* |
00b7d6ec | 39 | * If overwrite_console returns 1, the stdin, stderr and stdout |
affae2bf WD |
40 | * are switched to the serial port, else the settings in the |
41 | * environment are used | |
42 | */ | |
6d0f6bcf | 43 | #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE |
00b7d6ec | 44 | extern int overwrite_console(void); |
affae2bf | 45 | #else |
00b7d6ec | 46 | int overwrite_console(void) |
affae2bf | 47 | { |
00b7d6ec | 48 | return 0; |
affae2bf WD |
49 | } |
50 | #endif | |
51 | ||
9a8c72a6 | 52 | /* Keyboard sampling rate */ |
8454c84a | 53 | #define REPEAT_RATE 40 /* 40msec -> 25cps */ |
9a8c72a6 | 54 | #define REPEAT_DELAY 10 /* 10 x REPEAT_RATE = 400msec */ |
affae2bf WD |
55 | |
56 | #define NUM_LOCK 0x53 | |
00b7d6ec MV |
57 | #define CAPS_LOCK 0x39 |
58 | #define SCROLL_LOCK 0x47 | |
affae2bf | 59 | |
affae2bf | 60 | /* Modifier bits */ |
9a8c72a6 MV |
61 | #define LEFT_CNTR (1 << 0) |
62 | #define LEFT_SHIFT (1 << 1) | |
63 | #define LEFT_ALT (1 << 2) | |
64 | #define LEFT_GUI (1 << 3) | |
65 | #define RIGHT_CNTR (1 << 4) | |
66 | #define RIGHT_SHIFT (1 << 5) | |
67 | #define RIGHT_ALT (1 << 6) | |
68 | #define RIGHT_GUI (1 << 7) | |
69 | ||
70 | /* Size of the keyboard buffer */ | |
71 | #define USB_KBD_BUFFER_LEN 0x20 | |
72 | ||
73 | /* Device name */ | |
00b7d6ec | 74 | #define DEVNAME "usbkbd" |
affae2bf | 75 | |
9a8c72a6 MV |
76 | /* Keyboard maps */ |
77 | static const unsigned char usb_kbd_numkey[] = { | |
00b7d6ec MV |
78 | '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', |
79 | '\r', 0x1b, '\b', '\t', ' ', '-', '=', '[', ']', | |
80 | '\\', '#', ';', '\'', '`', ',', '.', '/' | |
affae2bf | 81 | }; |
9a8c72a6 | 82 | static const unsigned char usb_kbd_numkey_shifted[] = { |
00b7d6ec MV |
83 | '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', |
84 | '\r', 0x1b, '\b', '\t', ' ', '_', '+', '{', '}', | |
85 | '|', '~', ':', '"', '~', '<', '>', '?' | |
affae2bf WD |
86 | }; |
87 | ||
d53da847 VP |
88 | static const unsigned char usb_kbd_num_keypad[] = { |
89 | '/', '*', '-', '+', '\r', | |
90 | '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', | |
91 | '.', 0, 0, 0, '=' | |
92 | }; | |
93 | ||
3352c211 | 94 | static const u8 usb_special_keys[] = { |
87e91bcc HS |
95 | #ifdef CONFIG_USB_KEYBOARD_FN_KEYS |
96 | '2', 'H', '5', '3', 'F', '6', 'C', 'D', 'B', 'A' | |
97 | #else | |
3352c211 | 98 | 'C', 'D', 'B', 'A' |
87e91bcc | 99 | #endif |
4151a400 AM |
100 | }; |
101 | ||
9a8c72a6 MV |
102 | /* |
103 | * NOTE: It's important for the NUM, CAPS, SCROLL-lock bits to be in this | |
104 | * order. See usb_kbd_setled() function! | |
105 | */ | |
106 | #define USB_KBD_NUMLOCK (1 << 0) | |
107 | #define USB_KBD_CAPSLOCK (1 << 1) | |
108 | #define USB_KBD_SCROLLLOCK (1 << 2) | |
109 | #define USB_KBD_CTRL (1 << 3) | |
48c8073e | 110 | |
9a8c72a6 MV |
111 | #define USB_KBD_LEDMASK \ |
112 | (USB_KBD_NUMLOCK | USB_KBD_CAPSLOCK | USB_KBD_SCROLLLOCK) | |
48c8073e | 113 | |
9a8c72a6 | 114 | struct usb_kbd_pdata { |
8f8d7d24 HG |
115 | unsigned long intpipe; |
116 | int intpktsize; | |
117 | int intinterval; | |
8454c84a | 118 | unsigned long last_report; |
8e553119 | 119 | struct int_queue *intq; |
8f8d7d24 | 120 | |
575c6827 JG |
121 | uint32_t ifnum; |
122 | ||
9a8c72a6 | 123 | uint32_t repeat_delay; |
affae2bf | 124 | |
9a8c72a6 MV |
125 | uint32_t usb_in_pointer; |
126 | uint32_t usb_out_pointer; | |
127 | uint8_t usb_kbd_buffer[USB_KBD_BUFFER_LEN]; | |
48c8073e | 128 | |
d7475386 | 129 | uint8_t *new; |
08a98b89 | 130 | uint8_t old[USB_KBD_BOOT_REPORT_SIZE]; |
48c8073e | 131 | |
9a8c72a6 MV |
132 | uint8_t flags; |
133 | }; | |
48c8073e | 134 | |
07551f23 JL |
135 | extern int __maybe_unused net_busy_flag; |
136 | ||
137 | /* The period of time between two calls of usb_kbd_testc(). */ | |
96991e65 | 138 | static unsigned long kbd_testc_tms; |
07551f23 | 139 | |
bc624321 SG |
140 | int usb_kbd_remove_for_test(void) |
141 | { | |
142 | return console_remove_by_name(DEVNAME); | |
143 | } | |
144 | ||
9a8c72a6 | 145 | /* Puts character in the queue and sets up the in and out pointer. */ |
28dfa7d8 | 146 | static void usb_kbd_put_queue(struct usb_kbd_pdata *data, u8 c) |
affae2bf | 147 | { |
9a8c72a6 MV |
148 | if (data->usb_in_pointer == USB_KBD_BUFFER_LEN - 1) { |
149 | /* Check for buffer full. */ | |
150 | if (data->usb_out_pointer == 0) | |
151 | return; | |
affae2bf | 152 | |
9a8c72a6 MV |
153 | data->usb_in_pointer = 0; |
154 | } else { | |
155 | /* Check for buffer full. */ | |
156 | if (data->usb_in_pointer == data->usb_out_pointer - 1) | |
157 | return; | |
affae2bf | 158 | |
9a8c72a6 MV |
159 | data->usb_in_pointer++; |
160 | } | |
affae2bf | 161 | |
9a8c72a6 | 162 | data->usb_kbd_buffer[data->usb_in_pointer] = c; |
affae2bf WD |
163 | } |
164 | ||
9a8c72a6 MV |
165 | /* |
166 | * Set the LEDs. Since this is used in the irq routine, the control job is | |
167 | * issued with a timeout of 0. This means, that the job is queued without | |
168 | * waiting for job completion. | |
affae2bf | 169 | */ |
affae2bf WD |
170 | static void usb_kbd_setled(struct usb_device *dev) |
171 | { | |
9a8c72a6 | 172 | struct usb_kbd_pdata *data = dev->privptr; |
575c6827 | 173 | struct usb_interface *iface = &dev->config.if_desc[data->ifnum]; |
9b239381 | 174 | ALLOC_ALIGN_BUFFER(uint32_t, leds, 1, USB_DMA_MINALIGN); |
9a8c72a6 | 175 | |
9b239381 | 176 | *leds = data->flags & USB_KBD_LEDMASK; |
affae2bf WD |
177 | usb_control_msg(dev, usb_sndctrlpipe(dev, 0), |
178 | USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
9b239381 | 179 | 0x200, iface->desc.bInterfaceNumber, leds, 1, 0); |
affae2bf WD |
180 | } |
181 | ||
9a8c72a6 | 182 | #define CAPITAL_MASK 0x20 |
affae2bf | 183 | /* Translate the scancode in ASCII */ |
9a8c72a6 MV |
184 | static int usb_kbd_translate(struct usb_kbd_pdata *data, unsigned char scancode, |
185 | unsigned char modifier, int pressed) | |
affae2bf | 186 | { |
9a8c72a6 | 187 | uint8_t keycode = 0; |
affae2bf | 188 | |
9a8c72a6 | 189 | /* Key released */ |
00b7d6ec | 190 | if (pressed == 0) { |
9a8c72a6 | 191 | data->repeat_delay = 0; |
affae2bf WD |
192 | return 0; |
193 | } | |
9a8c72a6 | 194 | |
00b7d6ec | 195 | if (pressed == 2) { |
9a8c72a6 MV |
196 | data->repeat_delay++; |
197 | if (data->repeat_delay < REPEAT_DELAY) | |
affae2bf | 198 | return 0; |
9a8c72a6 MV |
199 | |
200 | data->repeat_delay = REPEAT_DELAY; | |
affae2bf | 201 | } |
9a8c72a6 MV |
202 | |
203 | /* Alphanumeric values */ | |
204 | if ((scancode > 3) && (scancode <= 0x1d)) { | |
205 | keycode = scancode - 4 + 'a'; | |
206 | ||
207 | if (data->flags & USB_KBD_CAPSLOCK) | |
00b7d6ec | 208 | keycode &= ~CAPITAL_MASK; |
9a8c72a6 MV |
209 | |
210 | if (modifier & (LEFT_SHIFT | RIGHT_SHIFT)) { | |
211 | /* Handle CAPSLock + Shift pressed simultaneously */ | |
00b7d6ec | 212 | if (keycode & CAPITAL_MASK) |
00b7d6ec | 213 | keycode &= ~CAPITAL_MASK; |
affae2bf | 214 | else |
00b7d6ec | 215 | keycode |= CAPITAL_MASK; |
affae2bf WD |
216 | } |
217 | } | |
9a8c72a6 | 218 | |
bdbcbe75 | 219 | if ((scancode > 0x1d) && (scancode < 0x39)) { |
9a8c72a6 MV |
220 | /* Shift pressed */ |
221 | if (modifier & (LEFT_SHIFT | RIGHT_SHIFT)) | |
222 | keycode = usb_kbd_numkey_shifted[scancode - 0x1e]; | |
223 | else | |
224 | keycode = usb_kbd_numkey[scancode - 0x1e]; | |
affae2bf | 225 | } |
4785a694 | 226 | |
d53da847 VP |
227 | /* Numeric keypad */ |
228 | if ((scancode >= 0x54) && (scancode <= 0x67)) | |
229 | keycode = usb_kbd_num_keypad[scancode - 0x54]; | |
230 | ||
9a8c72a6 | 231 | if (data->flags & USB_KBD_CTRL) |
4785a694 ZW |
232 | keycode = scancode - 0x3; |
233 | ||
00b7d6ec MV |
234 | if (pressed == 1) { |
235 | if (scancode == NUM_LOCK) { | |
9a8c72a6 | 236 | data->flags ^= USB_KBD_NUMLOCK; |
affae2bf WD |
237 | return 1; |
238 | } | |
9a8c72a6 | 239 | |
00b7d6ec | 240 | if (scancode == CAPS_LOCK) { |
9a8c72a6 | 241 | data->flags ^= USB_KBD_CAPSLOCK; |
affae2bf WD |
242 | return 1; |
243 | } | |
00b7d6ec | 244 | if (scancode == SCROLL_LOCK) { |
9a8c72a6 | 245 | data->flags ^= USB_KBD_SCROLLLOCK; |
affae2bf WD |
246 | return 1; |
247 | } | |
248 | } | |
9a8c72a6 MV |
249 | |
250 | /* Report keycode if any */ | |
3352c211 | 251 | if (keycode) { |
ceb4972a | 252 | debug("%c", keycode); |
9a8c72a6 | 253 | usb_kbd_put_queue(data, keycode); |
3352c211 | 254 | return 0; |
affae2bf | 255 | } |
9a8c72a6 | 256 | |
87e91bcc HS |
257 | #ifdef CONFIG_USB_KEYBOARD_FN_KEYS |
258 | if (scancode < 0x3a || scancode > 0x52 || | |
259 | scancode == 0x46 || scancode == 0x47) | |
260 | return 1; | |
261 | ||
262 | usb_kbd_put_queue(data, 0x1b); | |
263 | if (scancode < 0x3e) { | |
264 | /* F1 - F4 */ | |
265 | usb_kbd_put_queue(data, 0x4f); | |
266 | usb_kbd_put_queue(data, scancode - 0x3a + 'P'); | |
267 | return 0; | |
268 | } | |
269 | usb_kbd_put_queue(data, '['); | |
270 | if (scancode < 0x42) { | |
271 | /* F5 - F8 */ | |
272 | usb_kbd_put_queue(data, '1'); | |
273 | if (scancode == 0x3e) | |
274 | --scancode; | |
275 | keycode = scancode - 0x3f + '7'; | |
276 | } else if (scancode < 0x49) { | |
277 | /* F9 - F12 */ | |
278 | usb_kbd_put_queue(data, '2'); | |
279 | if (scancode > 0x43) | |
280 | ++scancode; | |
281 | keycode = scancode - 0x42 + '0'; | |
282 | } else { | |
283 | /* | |
284 | * INSERT, HOME, PAGE UP, DELETE, END, PAGE DOWN, | |
285 | * RIGHT, LEFT, DOWN, UP | |
286 | */ | |
287 | keycode = usb_special_keys[scancode - 0x49]; | |
288 | } | |
289 | usb_kbd_put_queue(data, keycode); | |
290 | if (scancode < 0x4f && scancode != 0x4a && scancode != 0x4d) | |
291 | usb_kbd_put_queue(data, '~'); | |
292 | return 0; | |
293 | #else | |
3352c211 HS |
294 | /* Left, Right, Up, Down */ |
295 | if (scancode > 0x4e && scancode < 0x53) { | |
296 | usb_kbd_put_queue(data, 0x1b); | |
297 | usb_kbd_put_queue(data, '['); | |
298 | usb_kbd_put_queue(data, usb_special_keys[scancode - 0x4f]); | |
299 | return 0; | |
300 | } | |
301 | return 1; | |
87e91bcc | 302 | #endif /* CONFIG_USB_KEYBOARD_FN_KEYS */ |
affae2bf WD |
303 | } |
304 | ||
9a8c72a6 MV |
305 | static uint32_t usb_kbd_service_key(struct usb_device *dev, int i, int up) |
306 | { | |
307 | uint32_t res = 0; | |
308 | struct usb_kbd_pdata *data = dev->privptr; | |
309 | uint8_t *new; | |
310 | uint8_t *old; | |
311 | ||
312 | if (up) { | |
313 | new = data->old; | |
314 | old = data->new; | |
315 | } else { | |
316 | new = data->new; | |
317 | old = data->old; | |
318 | } | |
319 | ||
08a98b89 AC |
320 | if ((old[i] > 3) && |
321 | (memscan(new + 2, old[i], USB_KBD_BOOT_REPORT_SIZE - 2) == | |
322 | new + USB_KBD_BOOT_REPORT_SIZE)) { | |
9a8c72a6 | 323 | res |= usb_kbd_translate(data, old[i], data->new[0], up); |
08a98b89 | 324 | } |
9a8c72a6 MV |
325 | |
326 | return res; | |
327 | } | |
328 | ||
affae2bf | 329 | /* Interrupt service routine */ |
48c8073e | 330 | static int usb_kbd_irq_worker(struct usb_device *dev) |
affae2bf | 331 | { |
9a8c72a6 MV |
332 | struct usb_kbd_pdata *data = dev->privptr; |
333 | int i, res = 0; | |
4785a694 | 334 | |
9a8c72a6 MV |
335 | /* No combo key pressed */ |
336 | if (data->new[0] == 0x00) | |
337 | data->flags &= ~USB_KBD_CTRL; | |
338 | /* Left or Right Ctrl pressed */ | |
339 | else if ((data->new[0] == LEFT_CNTR) || (data->new[0] == RIGHT_CNTR)) | |
340 | data->flags |= USB_KBD_CTRL; | |
00b7d6ec | 341 | |
08a98b89 | 342 | for (i = 2; i < USB_KBD_BOOT_REPORT_SIZE; i++) { |
9a8c72a6 MV |
343 | res |= usb_kbd_service_key(dev, i, 0); |
344 | res |= usb_kbd_service_key(dev, i, 1); | |
affae2bf | 345 | } |
00b7d6ec | 346 | |
9a8c72a6 MV |
347 | /* Key is still pressed */ |
348 | if ((data->new[2] > 3) && (data->old[2] == data->new[2])) | |
349 | res |= usb_kbd_translate(data, data->new[2], data->new[0], 2); | |
350 | ||
00b7d6ec | 351 | if (res == 1) |
affae2bf | 352 | usb_kbd_setled(dev); |
00b7d6ec | 353 | |
08a98b89 | 354 | memcpy(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE); |
00b7d6ec | 355 | |
9a8c72a6 | 356 | return 1; |
affae2bf WD |
357 | } |
358 | ||
9a8c72a6 | 359 | /* Keyboard interrupt handler */ |
48c8073e MV |
360 | static int usb_kbd_irq(struct usb_device *dev) |
361 | { | |
08a98b89 AC |
362 | if ((dev->irq_status != 0) || |
363 | (dev->irq_act_len != USB_KBD_BOOT_REPORT_SIZE)) { | |
ceb4972a VG |
364 | debug("USB KBD: Error %lX, len %d\n", |
365 | dev->irq_status, dev->irq_act_len); | |
48c8073e MV |
366 | return 1; |
367 | } | |
368 | ||
369 | return usb_kbd_irq_worker(dev); | |
370 | } | |
371 | ||
9a8c72a6 MV |
372 | /* Interrupt polling */ |
373 | static inline void usb_kbd_poll_for_event(struct usb_device *dev) | |
374 | { | |
8454c84a | 375 | #if defined(CONFIG_SYS_USB_EVENT_POLL) |
8f8d7d24 | 376 | struct usb_kbd_pdata *data = dev->privptr; |
f9636e8d | 377 | |
216db3af | 378 | /* Submit an interrupt transfer request */ |
fdd135bf | 379 | if (usb_int_msg(dev, data->intpipe, &data->new[0], |
3437121c | 380 | data->intpktsize, data->intinterval, true) >= 0) |
3e816a24 | 381 | usb_kbd_irq_worker(dev); |
8454c84a HG |
382 | #elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) || \ |
383 | defined(CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE) | |
384 | #if defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) | |
9a8c72a6 MV |
385 | struct usb_interface *iface; |
386 | struct usb_kbd_pdata *data = dev->privptr; | |
575c6827 | 387 | iface = &dev->config.if_desc[data->ifnum]; |
9a8c72a6 | 388 | usb_get_report(dev, iface->desc.bInterfaceNumber, |
08a98b89 | 389 | 1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE); |
8454c84a | 390 | if (memcmp(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE)) { |
9a8c72a6 | 391 | usb_kbd_irq_worker(dev); |
8454c84a | 392 | #else |
8e553119 HG |
393 | struct usb_kbd_pdata *data = dev->privptr; |
394 | if (poll_int_queue(dev, data->intq)) { | |
395 | usb_kbd_irq_worker(dev); | |
396 | /* We've consumed all queued int packets, create new */ | |
397 | destroy_int_queue(dev, data->intq); | |
398 | data->intq = create_int_queue(dev, data->intpipe, 1, | |
8bb6c1d1 HG |
399 | USB_KBD_BOOT_REPORT_SIZE, data->new, |
400 | data->intinterval); | |
8454c84a HG |
401 | #endif |
402 | data->last_report = get_timer(0); | |
403 | /* Repeat last usb hid report every REPEAT_RATE ms for keyrepeat */ | |
404 | } else if (data->last_report != -1 && | |
405 | get_timer(data->last_report) > REPEAT_RATE) { | |
406 | usb_kbd_irq_worker(dev); | |
407 | data->last_report = get_timer(0); | |
8e553119 | 408 | } |
9a8c72a6 MV |
409 | #endif |
410 | } | |
411 | ||
412 | /* test if a character is in the queue */ | |
709ea543 | 413 | static int usb_kbd_testc(struct stdio_dev *sdev) |
9a8c72a6 MV |
414 | { |
415 | struct stdio_dev *dev; | |
416 | struct usb_device *usb_kbd_dev; | |
417 | struct usb_kbd_pdata *data; | |
418 | ||
96991e65 TW |
419 | /* |
420 | * Polling the keyboard for an event can take dozens of milliseconds. | |
421 | * Add a delay between polls to avoid blocking activity which polls | |
422 | * rapidly, like the UEFI console timer. | |
423 | */ | |
424 | unsigned long poll_delay = CONFIG_SYS_HZ / 50; | |
425 | ||
98ad145d | 426 | #if defined(CONFIG_CMD_NET) && !defined(CONFIG_NET_LWIP) |
c95e2b9e JL |
427 | /* |
428 | * If net_busy_flag is 1, NET transfer is running, | |
429 | * then we check key-pressed every second (first check may be | |
430 | * less than 1 second) to improve TFTP booting performance. | |
431 | */ | |
96991e65 TW |
432 | if (net_busy_flag) |
433 | poll_delay = CONFIG_SYS_HZ; | |
c95e2b9e | 434 | #endif |
96991e65 TW |
435 | |
436 | #ifdef CONFIG_SANDBOX | |
437 | /* | |
438 | * Skip delaying polls if a test requests it. | |
439 | */ | |
440 | if (state_get_skip_delays()) | |
441 | poll_delay = 0; | |
442 | #endif | |
443 | ||
4fb67f47 | 444 | dev = stdio_get_by_name(sdev->name); |
9a8c72a6 MV |
445 | usb_kbd_dev = (struct usb_device *)dev->priv; |
446 | data = usb_kbd_dev->privptr; | |
447 | ||
96991e65 TW |
448 | if (get_timer(kbd_testc_tms) >= poll_delay) { |
449 | usb_kbd_poll_for_event(usb_kbd_dev); | |
450 | kbd_testc_tms = get_timer(0); | |
451 | } | |
9a8c72a6 MV |
452 | |
453 | return !(data->usb_in_pointer == data->usb_out_pointer); | |
454 | } | |
455 | ||
456 | /* gets the character from the queue */ | |
709ea543 | 457 | static int usb_kbd_getc(struct stdio_dev *sdev) |
9a8c72a6 MV |
458 | { |
459 | struct stdio_dev *dev; | |
460 | struct usb_device *usb_kbd_dev; | |
461 | struct usb_kbd_pdata *data; | |
462 | ||
4fb67f47 | 463 | dev = stdio_get_by_name(sdev->name); |
9a8c72a6 MV |
464 | usb_kbd_dev = (struct usb_device *)dev->priv; |
465 | data = usb_kbd_dev->privptr; | |
466 | ||
f8f3e0e5 | 467 | while (data->usb_in_pointer == data->usb_out_pointer) { |
29caf930 | 468 | schedule(); |
9a8c72a6 | 469 | usb_kbd_poll_for_event(usb_kbd_dev); |
f8f3e0e5 | 470 | } |
9a8c72a6 MV |
471 | |
472 | if (data->usb_out_pointer == USB_KBD_BUFFER_LEN - 1) | |
473 | data->usb_out_pointer = 0; | |
474 | else | |
475 | data->usb_out_pointer++; | |
476 | ||
477 | return data->usb_kbd_buffer[data->usb_out_pointer]; | |
478 | } | |
479 | ||
480 | /* probes the USB device dev for keyboard type. */ | |
34ab37ee | 481 | static int usb_kbd_probe_dev(struct usb_device *dev, unsigned int ifnum) |
affae2bf | 482 | { |
8f8bd565 | 483 | struct usb_interface *iface; |
affae2bf | 484 | struct usb_endpoint_descriptor *ep; |
9a8c72a6 | 485 | struct usb_kbd_pdata *data; |
63f6a449 | 486 | unsigned int quirks = 0; |
ba0b984b | 487 | int epNum; |
affae2bf | 488 | |
00b7d6ec MV |
489 | if (dev->descriptor.bNumConfigurations != 1) |
490 | return 0; | |
9a8c72a6 | 491 | |
affae2bf WD |
492 | iface = &dev->config.if_desc[ifnum]; |
493 | ||
2cdb58eb | 494 | if (iface->desc.bInterfaceClass != USB_CLASS_HID) |
8f8bd565 | 495 | return 0; |
9a8c72a6 | 496 | |
2cdb58eb | 497 | if (iface->desc.bInterfaceSubClass != USB_SUB_HID_BOOT) |
8f8bd565 | 498 | return 0; |
9a8c72a6 | 499 | |
2cdb58eb | 500 | if (iface->desc.bInterfaceProtocol != USB_PROT_HID_KEYBOARD) |
8f8bd565 | 501 | return 0; |
9a8c72a6 | 502 | |
ba0b984b SB |
503 | for (epNum = 0; epNum < iface->desc.bNumEndpoints; epNum++) { |
504 | ep = &iface->ep_desc[epNum]; | |
affae2bf | 505 | |
ba0b984b SB |
506 | /* Check if endpoint is interrupt IN endpoint */ |
507 | if ((ep->bmAttributes & 3) != 3) | |
508 | continue; | |
affae2bf | 509 | |
ba0b984b SB |
510 | if (ep->bEndpointAddress & 0x80) |
511 | break; | |
512 | } | |
9a8c72a6 | 513 | |
ba0b984b | 514 | if (epNum == iface->desc.bNumEndpoints) |
00b7d6ec | 515 | return 0; |
9a8c72a6 | 516 | |
ba0b984b | 517 | debug("USB KBD: found interrupt EP: 0x%x\n", ep->bEndpointAddress); |
9a8c72a6 | 518 | |
63f6a449 JG |
519 | switch (dev->descriptor.idVendor) { |
520 | case USB_VENDOR_ID_APPLE: | |
521 | case USB_VENDOR_ID_KEYCHRON: | |
522 | quirks |= USB_HID_QUIRK_POLL_NO_REPORT_IDLE; | |
523 | break; | |
524 | default: | |
525 | break; | |
526 | } | |
527 | ||
9a8c72a6 MV |
528 | data = malloc(sizeof(struct usb_kbd_pdata)); |
529 | if (!data) { | |
530 | printf("USB KBD: Error allocating private data\n"); | |
531 | return 0; | |
532 | } | |
533 | ||
534 | /* Clear private data */ | |
535 | memset(data, 0, sizeof(struct usb_kbd_pdata)); | |
536 | ||
d7475386 | 537 | /* allocate input buffer aligned and sized to USB DMA alignment */ |
08a98b89 AC |
538 | data->new = memalign(USB_DMA_MINALIGN, |
539 | roundup(USB_KBD_BOOT_REPORT_SIZE, USB_DMA_MINALIGN)); | |
d7475386 | 540 | |
575c6827 JG |
541 | data->ifnum = ifnum; |
542 | ||
9a8c72a6 MV |
543 | /* Insert private data into USB device structure */ |
544 | dev->privptr = data; | |
545 | ||
546 | /* Set IRQ handler */ | |
547 | dev->irq_handle = usb_kbd_irq; | |
548 | ||
8f8d7d24 HG |
549 | data->intpipe = usb_rcvintpipe(dev, ep->bEndpointAddress); |
550 | data->intpktsize = min(usb_maxpacket(dev, data->intpipe), | |
551 | USB_KBD_BOOT_REPORT_SIZE); | |
552 | data->intinterval = ep->bInterval; | |
8454c84a | 553 | data->last_report = -1; |
9a8c72a6 MV |
554 | |
555 | /* We found a USB Keyboard, install it. */ | |
ba0b984b | 556 | debug("USB KBD: set boot protocol\n"); |
9a8c72a6 MV |
557 | usb_set_protocol(dev, iface->desc.bInterfaceNumber, 0); |
558 | ||
8454c84a HG |
559 | #if !defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) && \ |
560 | !defined(CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE) | |
ba0b984b | 561 | debug("USB KBD: set idle interval...\n"); |
8454c84a | 562 | usb_set_idle(dev, iface->desc.bInterfaceNumber, REPEAT_RATE / 4, 0); |
de451493 | 563 | #else |
ba0b984b | 564 | debug("USB KBD: set idle interval=0...\n"); |
de451493 | 565 | usb_set_idle(dev, iface->desc.bInterfaceNumber, 0, 0); |
8454c84a | 566 | #endif |
9a8c72a6 | 567 | |
63f6a449 JG |
568 | /* |
569 | * Apple and Keychron keyboards do not report the device state. Reports | |
570 | * are only returned during key presses. | |
571 | */ | |
572 | if (quirks & USB_HID_QUIRK_POLL_NO_REPORT_IDLE) { | |
573 | debug("USB KBD: quirk: skip testing device state\n"); | |
574 | return 1; | |
575 | } | |
ceb4972a | 576 | debug("USB KBD: enable interrupt pipe...\n"); |
8e553119 HG |
577 | #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE |
578 | data->intq = create_int_queue(dev, data->intpipe, 1, | |
8bb6c1d1 HG |
579 | USB_KBD_BOOT_REPORT_SIZE, data->new, |
580 | data->intinterval); | |
8e553119 | 581 | if (!data->intq) { |
e4b70d80 SW |
582 | #elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) |
583 | if (usb_get_report(dev, iface->desc.bInterfaceNumber, | |
584 | 1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE) < 0) { | |
8e553119 | 585 | #else |
fdd135bf | 586 | if (usb_int_msg(dev, data->intpipe, data->new, data->intpktsize, |
3437121c | 587 | data->intinterval, false) < 0) { |
8e553119 | 588 | #endif |
5da2dc97 VP |
589 | printf("Failed to get keyboard state from device %04x:%04x\n", |
590 | dev->descriptor.idVendor, dev->descriptor.idProduct); | |
591 | /* Abort, we don't want to use that non-functional keyboard. */ | |
592 | return 0; | |
593 | } | |
9a8c72a6 MV |
594 | |
595 | /* Success. */ | |
affae2bf WD |
596 | return 1; |
597 | } | |
598 | ||
603afaf0 SG |
599 | static int probe_usb_keyboard(struct usb_device *dev) |
600 | { | |
601 | char *stdinname; | |
602 | struct stdio_dev usb_kbd_dev; | |
575c6827 JG |
603 | unsigned int ifnum; |
604 | unsigned int max_ifnum = min((unsigned int)USB_MAX_ACTIVE_INTERFACES, | |
605 | (unsigned int)dev->config.no_of_if); | |
603afaf0 SG |
606 | int error; |
607 | ||
608 | /* Try probing the keyboard */ | |
575c6827 JG |
609 | for (ifnum = 0; ifnum < max_ifnum; ifnum++) { |
610 | if (usb_kbd_probe_dev(dev, ifnum) == 1) | |
611 | break; | |
612 | } | |
613 | if (ifnum >= max_ifnum) | |
603afaf0 SG |
614 | return -ENOENT; |
615 | ||
616 | /* Register the keyboard */ | |
617 | debug("USB KBD: register.\n"); | |
618 | memset(&usb_kbd_dev, 0, sizeof(struct stdio_dev)); | |
619 | strcpy(usb_kbd_dev.name, DEVNAME); | |
010c4492 | 620 | usb_kbd_dev.flags = DEV_FLAGS_INPUT | DEV_FLAGS_DM; |
603afaf0 SG |
621 | usb_kbd_dev.getc = usb_kbd_getc; |
622 | usb_kbd_dev.tstc = usb_kbd_testc; | |
623 | usb_kbd_dev.priv = (void *)dev; | |
624 | error = stdio_register(&usb_kbd_dev); | |
625 | if (error) | |
626 | return error; | |
627 | ||
00caae6d | 628 | stdinname = env_get("stdin"); |
b0265429 | 629 | #if CONFIG_IS_ENABLED(CONSOLE_MUX) |
98ac7857 KM |
630 | if (strstr(stdinname, DEVNAME) != NULL) { |
631 | error = iomux_doenv(stdin, stdinname); | |
632 | if (error) | |
633 | return error; | |
634 | } | |
603afaf0 SG |
635 | #else |
636 | /* Check if this is the standard input device. */ | |
98ac7857 KM |
637 | if (!strcmp(stdinname, DEVNAME)) { |
638 | /* Reassign the console */ | |
639 | if (overwrite_console()) | |
640 | return 1; | |
603afaf0 | 641 | |
98ac7857 KM |
642 | error = console_assign(stdin, DEVNAME); |
643 | if (error) | |
644 | return error; | |
645 | } | |
603afaf0 SG |
646 | #endif |
647 | ||
648 | return 0; | |
649 | } | |
650 | ||
34ab37ee SG |
651 | static int usb_kbd_probe(struct udevice *dev) |
652 | { | |
653 | struct usb_device *udev = dev_get_parent_priv(dev); | |
34ab37ee | 654 | |
8319aeb1 | 655 | return probe_usb_keyboard(udev); |
34ab37ee SG |
656 | } |
657 | ||
8a834870 SG |
658 | static int usb_kbd_remove(struct udevice *dev) |
659 | { | |
660 | struct usb_device *udev = dev_get_parent_priv(dev); | |
661 | struct usb_kbd_pdata *data; | |
662 | struct stdio_dev *sdev; | |
663 | int ret; | |
664 | ||
665 | sdev = stdio_get_by_name(DEVNAME); | |
666 | if (!sdev) { | |
667 | ret = -ENXIO; | |
668 | goto err; | |
669 | } | |
670 | data = udev->privptr; | |
b0265429 | 671 | #if CONFIG_IS_ENABLED(CONSOLE_MUX) |
eb5fd9e4 | 672 | if (iomux_replace_device(stdin, DEVNAME, "nulldev")) { |
8a834870 SG |
673 | ret = -ENOLINK; |
674 | goto err; | |
675 | } | |
676 | #endif | |
eb5fd9e4 AS |
677 | if (stdio_deregister_dev(sdev, true)) { |
678 | ret = -EPERM; | |
679 | goto err; | |
680 | } | |
8a834870 SG |
681 | #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE |
682 | destroy_int_queue(udev, data->intq); | |
683 | #endif | |
684 | free(data->new); | |
685 | free(data); | |
686 | ||
687 | return 0; | |
688 | err: | |
689 | printf("%s: warning, ret=%d", __func__, ret); | |
690 | return ret; | |
691 | } | |
692 | ||
34ab37ee SG |
693 | static const struct udevice_id usb_kbd_ids[] = { |
694 | { .compatible = "usb-keyboard" }, | |
695 | { } | |
696 | }; | |
697 | ||
698 | U_BOOT_DRIVER(usb_kbd) = { | |
699 | .name = "usb_kbd", | |
700 | .id = UCLASS_KEYBOARD, | |
701 | .of_match = usb_kbd_ids, | |
702 | .probe = usb_kbd_probe, | |
8a834870 | 703 | .remove = usb_kbd_remove, |
34ab37ee SG |
704 | }; |
705 | ||
34ab37ee SG |
706 | static const struct usb_device_id kbd_id_table[] = { |
707 | { | |
708 | .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | | |
709 | USB_DEVICE_ID_MATCH_INT_SUBCLASS | | |
710 | USB_DEVICE_ID_MATCH_INT_PROTOCOL, | |
711 | .bInterfaceClass = USB_CLASS_HID, | |
2cdb58eb SG |
712 | .bInterfaceSubClass = USB_SUB_HID_BOOT, |
713 | .bInterfaceProtocol = USB_PROT_HID_KEYBOARD, | |
34ab37ee | 714 | }, |
575c6827 JG |
715 | { |
716 | USB_DEVICE(USB_VENDOR_ID_APPLE, | |
717 | USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2021), | |
718 | }, | |
719 | { | |
720 | USB_DEVICE(USB_VENDOR_ID_APPLE, | |
721 | USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_FINGERPRINT_2021), | |
722 | }, | |
723 | { | |
724 | USB_DEVICE(USB_VENDOR_ID_APPLE, | |
725 | USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2021), | |
726 | }, | |
34ab37ee SG |
727 | { } /* Terminating entry */ |
728 | }; | |
729 | ||
730 | U_BOOT_USB_DEVICE(usb_kbd, kbd_id_table); |