blob: 60c6027e048d5864aafecd40e5a0594cf5cc0e32 [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
wdenkaffae2b2002-08-17 09:36:01 +00002/*
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.
wdenkaffae2b2002-08-17 09:36:01 +00008 */
9#include <common.h>
Simon Glassa73bda42015-11-08 23:47:45 -070010#include <console.h>
Simon Glass5f1296b2015-03-25 12:22:34 -060011#include <dm.h>
Simon Glass0af6e2d2019-08-01 09:46:52 -060012#include <env.h>
Hans de Goedef5656232014-09-20 16:54:34 +020013#include <errno.h>
Simon Glass0f2af882020-05-10 11:40:05 -060014#include <log.h>
Marek Vasut7534a3e2011-10-10 16:34:26 +010015#include <malloc.h>
Simon Glass2dd337a2015-09-02 17:24:58 -060016#include <memalign.h>
Jean-Christophe PLAGNIOL-VILLARD2a7a0312009-05-16 12:14:54 +020017#include <stdio_dev.h>
Michal Simek07b3cc92018-06-27 14:16:54 +020018#include <watchdog.h>
Christian Eggers4e0e8d02008-05-21 22:12:00 +020019#include <asm/byteorder.h>
wdenkaffae2b2002-08-17 09:36:01 +000020
wdenkaffae2b2002-08-17 09:36:01 +000021#include <usb.h>
22
wdenkaffae2b2002-08-17 09:36:01 +000023/*
Marek Vasutb9300982011-10-10 05:34:25 +000024 * If overwrite_console returns 1, the stdin, stderr and stdout
wdenkaffae2b2002-08-17 09:36:01 +000025 * are switched to the serial port, else the settings in the
26 * environment are used
27 */
Jean-Christophe PLAGNIOL-VILLARD03836942008-10-16 15:01:15 +020028#ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
Marek Vasutb9300982011-10-10 05:34:25 +000029extern int overwrite_console(void);
wdenkaffae2b2002-08-17 09:36:01 +000030#else
Marek Vasutb9300982011-10-10 05:34:25 +000031int overwrite_console(void)
wdenkaffae2b2002-08-17 09:36:01 +000032{
Marek Vasutb9300982011-10-10 05:34:25 +000033 return 0;
wdenkaffae2b2002-08-17 09:36:01 +000034}
35#endif
36
Marek Vasut7534a3e2011-10-10 16:34:26 +010037/* Keyboard sampling rate */
Hans de Goede650d7202015-05-19 22:51:03 +020038#define REPEAT_RATE 40 /* 40msec -> 25cps */
Marek Vasut7534a3e2011-10-10 16:34:26 +010039#define REPEAT_DELAY 10 /* 10 x REPEAT_RATE = 400msec */
wdenkaffae2b2002-08-17 09:36:01 +000040
41#define NUM_LOCK 0x53
Marek Vasutb9300982011-10-10 05:34:25 +000042#define CAPS_LOCK 0x39
43#define SCROLL_LOCK 0x47
wdenkaffae2b2002-08-17 09:36:01 +000044
wdenkaffae2b2002-08-17 09:36:01 +000045/* Modifier bits */
Marek Vasut7534a3e2011-10-10 16:34:26 +010046#define LEFT_CNTR (1 << 0)
47#define LEFT_SHIFT (1 << 1)
48#define LEFT_ALT (1 << 2)
49#define LEFT_GUI (1 << 3)
50#define RIGHT_CNTR (1 << 4)
51#define RIGHT_SHIFT (1 << 5)
52#define RIGHT_ALT (1 << 6)
53#define RIGHT_GUI (1 << 7)
wdenkaffae2b2002-08-17 09:36:01 +000054
Marek Vasut7534a3e2011-10-10 16:34:26 +010055/* Size of the keyboard buffer */
56#define USB_KBD_BUFFER_LEN 0x20
wdenkaffae2b2002-08-17 09:36:01 +000057
Marek Vasut7534a3e2011-10-10 16:34:26 +010058/* Device name */
Marek Vasutb9300982011-10-10 05:34:25 +000059#define DEVNAME "usbkbd"
wdenkaffae2b2002-08-17 09:36:01 +000060
Marek Vasut7534a3e2011-10-10 16:34:26 +010061/* Keyboard maps */
62static const unsigned char usb_kbd_numkey[] = {
Marek Vasutb9300982011-10-10 05:34:25 +000063 '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
64 '\r', 0x1b, '\b', '\t', ' ', '-', '=', '[', ']',
65 '\\', '#', ';', '\'', '`', ',', '.', '/'
wdenkaffae2b2002-08-17 09:36:01 +000066};
Marek Vasut7534a3e2011-10-10 16:34:26 +010067static const unsigned char usb_kbd_numkey_shifted[] = {
Marek Vasutb9300982011-10-10 05:34:25 +000068 '!', '@', '#', '$', '%', '^', '&', '*', '(', ')',
69 '\r', 0x1b, '\b', '\t', ' ', '_', '+', '{', '}',
70 '|', '~', ':', '"', '~', '<', '>', '?'
wdenkaffae2b2002-08-17 09:36:01 +000071};
72
Vincent Palatin92f6a622012-01-09 12:59:36 +000073static const unsigned char usb_kbd_num_keypad[] = {
74 '/', '*', '-', '+', '\r',
75 '1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
76 '.', 0, 0, 0, '='
77};
78
Heinrich Schuchardtd05aaef2019-11-23 18:15:20 +010079static const u8 usb_special_keys[] = {
Heinrich Schuchardt8e505ee2019-11-23 18:15:21 +010080#ifdef CONFIG_USB_KEYBOARD_FN_KEYS
81 '2', 'H', '5', '3', 'F', '6', 'C', 'D', 'B', 'A'
82#else
Heinrich Schuchardtd05aaef2019-11-23 18:15:20 +010083 'C', 'D', 'B', 'A'
Heinrich Schuchardt8e505ee2019-11-23 18:15:21 +010084#endif
Allen Martin1bfb4cd2012-11-06 13:26:03 -080085};
86
87/*
Marek Vasut7534a3e2011-10-10 16:34:26 +010088 * NOTE: It's important for the NUM, CAPS, SCROLL-lock bits to be in this
89 * order. See usb_kbd_setled() function!
90 */
91#define USB_KBD_NUMLOCK (1 << 0)
92#define USB_KBD_CAPSLOCK (1 << 1)
93#define USB_KBD_SCROLLLOCK (1 << 2)
94#define USB_KBD_CTRL (1 << 3)
Marek Vasut82cf9a42011-09-25 20:00:37 +010095
Marek Vasut7534a3e2011-10-10 16:34:26 +010096#define USB_KBD_LEDMASK \
97 (USB_KBD_NUMLOCK | USB_KBD_CAPSLOCK | USB_KBD_SCROLLLOCK)
Marek Vasut82cf9a42011-09-25 20:00:37 +010098
Marek Vasut7534a3e2011-10-10 16:34:26 +010099struct usb_kbd_pdata {
Hans de Goede3c794702014-09-24 14:06:10 +0200100 unsigned long intpipe;
101 int intpktsize;
102 int intinterval;
Hans de Goede650d7202015-05-19 22:51:03 +0200103 unsigned long last_report;
Hans de Goede2d02ae72014-09-24 14:06:11 +0200104 struct int_queue *intq;
Hans de Goede3c794702014-09-24 14:06:10 +0200105
Marek Vasut7534a3e2011-10-10 16:34:26 +0100106 uint32_t repeat_delay;
wdenkaffae2b2002-08-17 09:36:01 +0000107
Marek Vasut7534a3e2011-10-10 16:34:26 +0100108 uint32_t usb_in_pointer;
109 uint32_t usb_out_pointer;
110 uint8_t usb_kbd_buffer[USB_KBD_BUFFER_LEN];
Marek Vasut82cf9a42011-09-25 20:00:37 +0100111
Allen Martinef769ca2012-10-24 08:32:04 +0000112 uint8_t *new;
Adrian Cox17472dc2014-04-10 14:02:44 +0100113 uint8_t old[USB_KBD_BOOT_REPORT_SIZE];
Marek Vasut82cf9a42011-09-25 20:00:37 +0100114
Marek Vasut7534a3e2011-10-10 16:34:26 +0100115 uint8_t flags;
116};
Marek Vasut82cf9a42011-09-25 20:00:37 +0100117
Jim Linc562f972013-08-13 19:04:22 +0800118extern int __maybe_unused net_busy_flag;
119
120/* The period of time between two calls of usb_kbd_testc(). */
121static unsigned long __maybe_unused kbd_testc_tms;
122
Marek Vasut7534a3e2011-10-10 16:34:26 +0100123/* Puts character in the queue and sets up the in and out pointer. */
Heinrich Schuchardt90d746f2019-11-23 18:15:19 +0100124static void usb_kbd_put_queue(struct usb_kbd_pdata *data, u8 c)
wdenkaffae2b2002-08-17 09:36:01 +0000125{
Marek Vasut7534a3e2011-10-10 16:34:26 +0100126 if (data->usb_in_pointer == USB_KBD_BUFFER_LEN - 1) {
127 /* Check for buffer full. */
128 if (data->usb_out_pointer == 0)
129 return;
wdenkaffae2b2002-08-17 09:36:01 +0000130
Marek Vasut7534a3e2011-10-10 16:34:26 +0100131 data->usb_in_pointer = 0;
132 } else {
133 /* Check for buffer full. */
134 if (data->usb_in_pointer == data->usb_out_pointer - 1)
135 return;
wdenkaffae2b2002-08-17 09:36:01 +0000136
Marek Vasut7534a3e2011-10-10 16:34:26 +0100137 data->usb_in_pointer++;
138 }
wdenkaffae2b2002-08-17 09:36:01 +0000139
Marek Vasut7534a3e2011-10-10 16:34:26 +0100140 data->usb_kbd_buffer[data->usb_in_pointer] = c;
wdenkaffae2b2002-08-17 09:36:01 +0000141}
142
Marek Vasut7534a3e2011-10-10 16:34:26 +0100143/*
144 * Set the LEDs. Since this is used in the irq routine, the control job is
145 * issued with a timeout of 0. This means, that the job is queued without
146 * waiting for job completion.
wdenkaffae2b2002-08-17 09:36:01 +0000147 */
wdenkaffae2b2002-08-17 09:36:01 +0000148static void usb_kbd_setled(struct usb_device *dev)
149{
Marek Vasut7534a3e2011-10-10 16:34:26 +0100150 struct usb_interface *iface = &dev->config.if_desc[0];
151 struct usb_kbd_pdata *data = dev->privptr;
Hans de Goedee402b6c2014-09-20 16:51:26 +0200152 ALLOC_ALIGN_BUFFER(uint32_t, leds, 1, USB_DMA_MINALIGN);
Marek Vasut7534a3e2011-10-10 16:34:26 +0100153
Hans de Goedee402b6c2014-09-20 16:51:26 +0200154 *leds = data->flags & USB_KBD_LEDMASK;
wdenkaffae2b2002-08-17 09:36:01 +0000155 usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
156 USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
Hans de Goedee402b6c2014-09-20 16:51:26 +0200157 0x200, iface->desc.bInterfaceNumber, leds, 1, 0);
wdenkaffae2b2002-08-17 09:36:01 +0000158}
159
Marek Vasut7534a3e2011-10-10 16:34:26 +0100160#define CAPITAL_MASK 0x20
wdenkaffae2b2002-08-17 09:36:01 +0000161/* Translate the scancode in ASCII */
Marek Vasut7534a3e2011-10-10 16:34:26 +0100162static int usb_kbd_translate(struct usb_kbd_pdata *data, unsigned char scancode,
163 unsigned char modifier, int pressed)
wdenkaffae2b2002-08-17 09:36:01 +0000164{
Marek Vasut7534a3e2011-10-10 16:34:26 +0100165 uint8_t keycode = 0;
wdenkaffae2b2002-08-17 09:36:01 +0000166
Marek Vasut7534a3e2011-10-10 16:34:26 +0100167 /* Key released */
Marek Vasutb9300982011-10-10 05:34:25 +0000168 if (pressed == 0) {
Marek Vasut7534a3e2011-10-10 16:34:26 +0100169 data->repeat_delay = 0;
wdenkaffae2b2002-08-17 09:36:01 +0000170 return 0;
171 }
Marek Vasut7534a3e2011-10-10 16:34:26 +0100172
Marek Vasutb9300982011-10-10 05:34:25 +0000173 if (pressed == 2) {
Marek Vasut7534a3e2011-10-10 16:34:26 +0100174 data->repeat_delay++;
175 if (data->repeat_delay < REPEAT_DELAY)
wdenkaffae2b2002-08-17 09:36:01 +0000176 return 0;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100177
178 data->repeat_delay = REPEAT_DELAY;
wdenkaffae2b2002-08-17 09:36:01 +0000179 }
Marek Vasut7534a3e2011-10-10 16:34:26 +0100180
181 /* Alphanumeric values */
182 if ((scancode > 3) && (scancode <= 0x1d)) {
183 keycode = scancode - 4 + 'a';
184
185 if (data->flags & USB_KBD_CAPSLOCK)
Marek Vasutb9300982011-10-10 05:34:25 +0000186 keycode &= ~CAPITAL_MASK;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100187
188 if (modifier & (LEFT_SHIFT | RIGHT_SHIFT)) {
189 /* Handle CAPSLock + Shift pressed simultaneously */
Marek Vasutb9300982011-10-10 05:34:25 +0000190 if (keycode & CAPITAL_MASK)
Marek Vasutb9300982011-10-10 05:34:25 +0000191 keycode &= ~CAPITAL_MASK;
wdenkaffae2b2002-08-17 09:36:01 +0000192 else
Marek Vasutb9300982011-10-10 05:34:25 +0000193 keycode |= CAPITAL_MASK;
wdenkaffae2b2002-08-17 09:36:01 +0000194 }
195 }
Marek Vasut7534a3e2011-10-10 16:34:26 +0100196
Marek Vasut0082cd12016-01-25 22:00:44 +0100197 if ((scancode > 0x1d) && (scancode < 0x39)) {
Marek Vasut7534a3e2011-10-10 16:34:26 +0100198 /* Shift pressed */
199 if (modifier & (LEFT_SHIFT | RIGHT_SHIFT))
200 keycode = usb_kbd_numkey_shifted[scancode - 0x1e];
201 else
202 keycode = usb_kbd_numkey[scancode - 0x1e];
wdenkaffae2b2002-08-17 09:36:01 +0000203 }
Zhang Wei37cc4f02008-01-03 10:51:15 +0800204
Vincent Palatin92f6a622012-01-09 12:59:36 +0000205 /* Numeric keypad */
206 if ((scancode >= 0x54) && (scancode <= 0x67))
207 keycode = usb_kbd_num_keypad[scancode - 0x54];
208
Marek Vasut7534a3e2011-10-10 16:34:26 +0100209 if (data->flags & USB_KBD_CTRL)
Zhang Wei37cc4f02008-01-03 10:51:15 +0800210 keycode = scancode - 0x3;
211
Marek Vasutb9300982011-10-10 05:34:25 +0000212 if (pressed == 1) {
213 if (scancode == NUM_LOCK) {
Marek Vasut7534a3e2011-10-10 16:34:26 +0100214 data->flags ^= USB_KBD_NUMLOCK;
wdenkaffae2b2002-08-17 09:36:01 +0000215 return 1;
216 }
Marek Vasut7534a3e2011-10-10 16:34:26 +0100217
Marek Vasutb9300982011-10-10 05:34:25 +0000218 if (scancode == CAPS_LOCK) {
Marek Vasut7534a3e2011-10-10 16:34:26 +0100219 data->flags ^= USB_KBD_CAPSLOCK;
wdenkaffae2b2002-08-17 09:36:01 +0000220 return 1;
221 }
Marek Vasutb9300982011-10-10 05:34:25 +0000222 if (scancode == SCROLL_LOCK) {
Marek Vasut7534a3e2011-10-10 16:34:26 +0100223 data->flags ^= USB_KBD_SCROLLLOCK;
wdenkaffae2b2002-08-17 09:36:01 +0000224 return 1;
225 }
226 }
Marek Vasut7534a3e2011-10-10 16:34:26 +0100227
228 /* Report keycode if any */
Heinrich Schuchardtd05aaef2019-11-23 18:15:20 +0100229 if (keycode) {
Vivek Gautamf94c95d2013-04-12 16:34:33 +0530230 debug("%c", keycode);
Marek Vasut7534a3e2011-10-10 16:34:26 +0100231 usb_kbd_put_queue(data, keycode);
Heinrich Schuchardtd05aaef2019-11-23 18:15:20 +0100232 return 0;
wdenkaffae2b2002-08-17 09:36:01 +0000233 }
Marek Vasut7534a3e2011-10-10 16:34:26 +0100234
Heinrich Schuchardt8e505ee2019-11-23 18:15:21 +0100235#ifdef CONFIG_USB_KEYBOARD_FN_KEYS
236 if (scancode < 0x3a || scancode > 0x52 ||
237 scancode == 0x46 || scancode == 0x47)
238 return 1;
239
240 usb_kbd_put_queue(data, 0x1b);
241 if (scancode < 0x3e) {
242 /* F1 - F4 */
243 usb_kbd_put_queue(data, 0x4f);
244 usb_kbd_put_queue(data, scancode - 0x3a + 'P');
245 return 0;
246 }
247 usb_kbd_put_queue(data, '[');
248 if (scancode < 0x42) {
249 /* F5 - F8 */
250 usb_kbd_put_queue(data, '1');
251 if (scancode == 0x3e)
252 --scancode;
253 keycode = scancode - 0x3f + '7';
254 } else if (scancode < 0x49) {
255 /* F9 - F12 */
256 usb_kbd_put_queue(data, '2');
257 if (scancode > 0x43)
258 ++scancode;
259 keycode = scancode - 0x42 + '0';
260 } else {
261 /*
262 * INSERT, HOME, PAGE UP, DELETE, END, PAGE DOWN,
263 * RIGHT, LEFT, DOWN, UP
264 */
265 keycode = usb_special_keys[scancode - 0x49];
266 }
267 usb_kbd_put_queue(data, keycode);
268 if (scancode < 0x4f && scancode != 0x4a && scancode != 0x4d)
269 usb_kbd_put_queue(data, '~');
270 return 0;
271#else
Heinrich Schuchardtd05aaef2019-11-23 18:15:20 +0100272 /* Left, Right, Up, Down */
273 if (scancode > 0x4e && scancode < 0x53) {
274 usb_kbd_put_queue(data, 0x1b);
275 usb_kbd_put_queue(data, '[');
276 usb_kbd_put_queue(data, usb_special_keys[scancode - 0x4f]);
277 return 0;
278 }
279 return 1;
Heinrich Schuchardt8e505ee2019-11-23 18:15:21 +0100280#endif /* CONFIG_USB_KEYBOARD_FN_KEYS */
wdenkaffae2b2002-08-17 09:36:01 +0000281}
282
Marek Vasut7534a3e2011-10-10 16:34:26 +0100283static uint32_t usb_kbd_service_key(struct usb_device *dev, int i, int up)
284{
285 uint32_t res = 0;
286 struct usb_kbd_pdata *data = dev->privptr;
287 uint8_t *new;
288 uint8_t *old;
289
290 if (up) {
291 new = data->old;
292 old = data->new;
293 } else {
294 new = data->new;
295 old = data->old;
296 }
297
Adrian Cox17472dc2014-04-10 14:02:44 +0100298 if ((old[i] > 3) &&
299 (memscan(new + 2, old[i], USB_KBD_BOOT_REPORT_SIZE - 2) ==
300 new + USB_KBD_BOOT_REPORT_SIZE)) {
Marek Vasut7534a3e2011-10-10 16:34:26 +0100301 res |= usb_kbd_translate(data, old[i], data->new[0], up);
Adrian Cox17472dc2014-04-10 14:02:44 +0100302 }
Marek Vasut7534a3e2011-10-10 16:34:26 +0100303
304 return res;
305}
306
wdenkaffae2b2002-08-17 09:36:01 +0000307/* Interrupt service routine */
Marek Vasut82cf9a42011-09-25 20:00:37 +0100308static int usb_kbd_irq_worker(struct usb_device *dev)
wdenkaffae2b2002-08-17 09:36:01 +0000309{
Marek Vasut7534a3e2011-10-10 16:34:26 +0100310 struct usb_kbd_pdata *data = dev->privptr;
311 int i, res = 0;
wdenkaffae2b2002-08-17 09:36:01 +0000312
Marek Vasut7534a3e2011-10-10 16:34:26 +0100313 /* No combo key pressed */
314 if (data->new[0] == 0x00)
315 data->flags &= ~USB_KBD_CTRL;
316 /* Left or Right Ctrl pressed */
317 else if ((data->new[0] == LEFT_CNTR) || (data->new[0] == RIGHT_CNTR))
318 data->flags |= USB_KBD_CTRL;
Zhang Wei37cc4f02008-01-03 10:51:15 +0800319
Adrian Cox17472dc2014-04-10 14:02:44 +0100320 for (i = 2; i < USB_KBD_BOOT_REPORT_SIZE; i++) {
Marek Vasut7534a3e2011-10-10 16:34:26 +0100321 res |= usb_kbd_service_key(dev, i, 0);
322 res |= usb_kbd_service_key(dev, i, 1);
wdenkaffae2b2002-08-17 09:36:01 +0000323 }
Marek Vasutb9300982011-10-10 05:34:25 +0000324
Marek Vasut7534a3e2011-10-10 16:34:26 +0100325 /* Key is still pressed */
326 if ((data->new[2] > 3) && (data->old[2] == data->new[2]))
327 res |= usb_kbd_translate(data, data->new[2], data->new[0], 2);
328
Marek Vasutb9300982011-10-10 05:34:25 +0000329 if (res == 1)
wdenkaffae2b2002-08-17 09:36:01 +0000330 usb_kbd_setled(dev);
Marek Vasutb9300982011-10-10 05:34:25 +0000331
Adrian Cox17472dc2014-04-10 14:02:44 +0100332 memcpy(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE);
Marek Vasutb9300982011-10-10 05:34:25 +0000333
Marek Vasut7534a3e2011-10-10 16:34:26 +0100334 return 1;
wdenkaffae2b2002-08-17 09:36:01 +0000335}
336
Marek Vasut7534a3e2011-10-10 16:34:26 +0100337/* Keyboard interrupt handler */
Marek Vasut82cf9a42011-09-25 20:00:37 +0100338static int usb_kbd_irq(struct usb_device *dev)
339{
Adrian Cox17472dc2014-04-10 14:02:44 +0100340 if ((dev->irq_status != 0) ||
341 (dev->irq_act_len != USB_KBD_BOOT_REPORT_SIZE)) {
Vivek Gautamf94c95d2013-04-12 16:34:33 +0530342 debug("USB KBD: Error %lX, len %d\n",
343 dev->irq_status, dev->irq_act_len);
Marek Vasut82cf9a42011-09-25 20:00:37 +0100344 return 1;
345 }
346
347 return usb_kbd_irq_worker(dev);
348}
349
Marek Vasut7534a3e2011-10-10 16:34:26 +0100350/* Interrupt polling */
351static inline void usb_kbd_poll_for_event(struct usb_device *dev)
352{
Hans de Goede650d7202015-05-19 22:51:03 +0200353#if defined(CONFIG_SYS_USB_EVENT_POLL)
Hans de Goede3c794702014-09-24 14:06:10 +0200354 struct usb_kbd_pdata *data = dev->privptr;
amartin@nvidia.com185da952011-12-20 14:56:16 +0000355
Heinrich Schuchardt38ed7fe2019-11-23 18:15:18 +0100356 /* Submit an interrupt transfer request */
Michal Suchanekf5d5af42019-08-18 10:55:25 +0200357 if (usb_int_msg(dev, data->intpipe, &data->new[0],
Michal Suchanek1c95b9f2019-08-18 10:55:27 +0200358 data->intpktsize, data->intinterval, true) >= 0)
Michal Suchanek46c83f32019-08-18 10:55:24 +0200359 usb_kbd_irq_worker(dev);
Hans de Goede650d7202015-05-19 22:51:03 +0200360#elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) || \
361 defined(CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE)
362#if defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
Marek Vasut7534a3e2011-10-10 16:34:26 +0100363 struct usb_interface *iface;
364 struct usb_kbd_pdata *data = dev->privptr;
365 iface = &dev->config.if_desc[0];
366 usb_get_report(dev, iface->desc.bInterfaceNumber,
Adrian Cox17472dc2014-04-10 14:02:44 +0100367 1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE);
Hans de Goede650d7202015-05-19 22:51:03 +0200368 if (memcmp(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE)) {
Marek Vasut7534a3e2011-10-10 16:34:26 +0100369 usb_kbd_irq_worker(dev);
Hans de Goede650d7202015-05-19 22:51:03 +0200370#else
Hans de Goede2d02ae72014-09-24 14:06:11 +0200371 struct usb_kbd_pdata *data = dev->privptr;
372 if (poll_int_queue(dev, data->intq)) {
373 usb_kbd_irq_worker(dev);
374 /* We've consumed all queued int packets, create new */
375 destroy_int_queue(dev, data->intq);
376 data->intq = create_int_queue(dev, data->intpipe, 1,
Hans de Goedebbd2d2a2015-01-11 20:38:28 +0100377 USB_KBD_BOOT_REPORT_SIZE, data->new,
378 data->intinterval);
Hans de Goede650d7202015-05-19 22:51:03 +0200379#endif
380 data->last_report = get_timer(0);
381 /* Repeat last usb hid report every REPEAT_RATE ms for keyrepeat */
382 } else if (data->last_report != -1 &&
383 get_timer(data->last_report) > REPEAT_RATE) {
384 usb_kbd_irq_worker(dev);
385 data->last_report = get_timer(0);
Hans de Goede2d02ae72014-09-24 14:06:11 +0200386 }
Marek Vasut7534a3e2011-10-10 16:34:26 +0100387#endif
388}
389
390/* test if a character is in the queue */
Simon Glass0d1e1f72014-07-23 06:54:59 -0600391static int usb_kbd_testc(struct stdio_dev *sdev)
Marek Vasut7534a3e2011-10-10 16:34:26 +0100392{
393 struct stdio_dev *dev;
394 struct usb_device *usb_kbd_dev;
395 struct usb_kbd_pdata *data;
396
Jim Line2ebec82013-08-26 20:21:09 +0800397#ifdef CONFIG_CMD_NET
398 /*
399 * If net_busy_flag is 1, NET transfer is running,
400 * then we check key-pressed every second (first check may be
401 * less than 1 second) to improve TFTP booting performance.
402 */
403 if (net_busy_flag && (get_timer(kbd_testc_tms) < CONFIG_SYS_HZ))
404 return 0;
405 kbd_testc_tms = get_timer(0);
406#endif
Michal Simek2b0634d2018-06-27 14:35:07 +0200407 dev = stdio_get_by_name(sdev->name);
Marek Vasut7534a3e2011-10-10 16:34:26 +0100408 usb_kbd_dev = (struct usb_device *)dev->priv;
409 data = usb_kbd_dev->privptr;
410
411 usb_kbd_poll_for_event(usb_kbd_dev);
412
413 return !(data->usb_in_pointer == data->usb_out_pointer);
414}
415
416/* gets the character from the queue */
Simon Glass0d1e1f72014-07-23 06:54:59 -0600417static int usb_kbd_getc(struct stdio_dev *sdev)
Marek Vasut7534a3e2011-10-10 16:34:26 +0100418{
419 struct stdio_dev *dev;
420 struct usb_device *usb_kbd_dev;
421 struct usb_kbd_pdata *data;
422
Michal Simek2b0634d2018-06-27 14:35:07 +0200423 dev = stdio_get_by_name(sdev->name);
Marek Vasut7534a3e2011-10-10 16:34:26 +0100424 usb_kbd_dev = (struct usb_device *)dev->priv;
425 data = usb_kbd_dev->privptr;
426
Michal Simek07b3cc92018-06-27 14:16:54 +0200427 while (data->usb_in_pointer == data->usb_out_pointer) {
428 WATCHDOG_RESET();
Marek Vasut7534a3e2011-10-10 16:34:26 +0100429 usb_kbd_poll_for_event(usb_kbd_dev);
Michal Simek07b3cc92018-06-27 14:16:54 +0200430 }
Marek Vasut7534a3e2011-10-10 16:34:26 +0100431
432 if (data->usb_out_pointer == USB_KBD_BUFFER_LEN - 1)
433 data->usb_out_pointer = 0;
434 else
435 data->usb_out_pointer++;
436
437 return data->usb_kbd_buffer[data->usb_out_pointer];
438}
439
440/* probes the USB device dev for keyboard type. */
Simon Glass02f0c282015-09-08 11:15:11 -0600441static int usb_kbd_probe_dev(struct usb_device *dev, unsigned int ifnum)
wdenkaffae2b2002-08-17 09:36:01 +0000442{
Tom Rix83b9e1d2009-10-31 12:37:38 -0500443 struct usb_interface *iface;
wdenkaffae2b2002-08-17 09:36:01 +0000444 struct usb_endpoint_descriptor *ep;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100445 struct usb_kbd_pdata *data;
wdenkaffae2b2002-08-17 09:36:01 +0000446
Marek Vasutb9300982011-10-10 05:34:25 +0000447 if (dev->descriptor.bNumConfigurations != 1)
448 return 0;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100449
wdenkaffae2b2002-08-17 09:36:01 +0000450 iface = &dev->config.if_desc[ifnum];
451
Simon Glassab88fdb2015-11-08 23:48:04 -0700452 if (iface->desc.bInterfaceClass != USB_CLASS_HID)
Tom Rix83b9e1d2009-10-31 12:37:38 -0500453 return 0;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100454
Simon Glassab88fdb2015-11-08 23:48:04 -0700455 if (iface->desc.bInterfaceSubClass != USB_SUB_HID_BOOT)
Tom Rix83b9e1d2009-10-31 12:37:38 -0500456 return 0;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100457
Simon Glassab88fdb2015-11-08 23:48:04 -0700458 if (iface->desc.bInterfaceProtocol != USB_PROT_HID_KEYBOARD)
Tom Rix83b9e1d2009-10-31 12:37:38 -0500459 return 0;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100460
Tom Rix83b9e1d2009-10-31 12:37:38 -0500461 if (iface->desc.bNumEndpoints != 1)
462 return 0;
wdenkaffae2b2002-08-17 09:36:01 +0000463
464 ep = &iface->ep_desc[0];
465
Marek Vasut7534a3e2011-10-10 16:34:26 +0100466 /* Check if endpoint 1 is interrupt endpoint */
Marek Vasutb9300982011-10-10 05:34:25 +0000467 if (!(ep->bEndpointAddress & 0x80))
468 return 0;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100469
Marek Vasutb9300982011-10-10 05:34:25 +0000470 if ((ep->bmAttributes & 3) != 3)
471 return 0;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100472
Vivek Gautamf94c95d2013-04-12 16:34:33 +0530473 debug("USB KBD: found set protocol...\n");
Marek Vasut7534a3e2011-10-10 16:34:26 +0100474
475 data = malloc(sizeof(struct usb_kbd_pdata));
476 if (!data) {
477 printf("USB KBD: Error allocating private data\n");
478 return 0;
479 }
480
481 /* Clear private data */
482 memset(data, 0, sizeof(struct usb_kbd_pdata));
483
Allen Martinef769ca2012-10-24 08:32:04 +0000484 /* allocate input buffer aligned and sized to USB DMA alignment */
Adrian Cox17472dc2014-04-10 14:02:44 +0100485 data->new = memalign(USB_DMA_MINALIGN,
486 roundup(USB_KBD_BOOT_REPORT_SIZE, USB_DMA_MINALIGN));
Allen Martinef769ca2012-10-24 08:32:04 +0000487
Marek Vasut7534a3e2011-10-10 16:34:26 +0100488 /* Insert private data into USB device structure */
489 dev->privptr = data;
490
491 /* Set IRQ handler */
492 dev->irq_handle = usb_kbd_irq;
493
Hans de Goede3c794702014-09-24 14:06:10 +0200494 data->intpipe = usb_rcvintpipe(dev, ep->bEndpointAddress);
495 data->intpktsize = min(usb_maxpacket(dev, data->intpipe),
496 USB_KBD_BOOT_REPORT_SIZE);
497 data->intinterval = ep->bInterval;
Hans de Goede650d7202015-05-19 22:51:03 +0200498 data->last_report = -1;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100499
500 /* We found a USB Keyboard, install it. */
501 usb_set_protocol(dev, iface->desc.bInterfaceNumber, 0);
502
Hans de Goeded4e99a62015-06-18 22:34:34 +0200503 debug("USB KBD: found set idle...\n");
Hans de Goede650d7202015-05-19 22:51:03 +0200504#if !defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) && \
505 !defined(CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE)
Hans de Goede650d7202015-05-19 22:51:03 +0200506 usb_set_idle(dev, iface->desc.bInterfaceNumber, REPEAT_RATE / 4, 0);
Hans de Goeded4e99a62015-06-18 22:34:34 +0200507#else
508 usb_set_idle(dev, iface->desc.bInterfaceNumber, 0, 0);
Hans de Goede650d7202015-05-19 22:51:03 +0200509#endif
Marek Vasut7534a3e2011-10-10 16:34:26 +0100510
Vivek Gautamf94c95d2013-04-12 16:34:33 +0530511 debug("USB KBD: enable interrupt pipe...\n");
Hans de Goede2d02ae72014-09-24 14:06:11 +0200512#ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
513 data->intq = create_int_queue(dev, data->intpipe, 1,
Hans de Goedebbd2d2a2015-01-11 20:38:28 +0100514 USB_KBD_BOOT_REPORT_SIZE, data->new,
515 data->intinterval);
Hans de Goede2d02ae72014-09-24 14:06:11 +0200516 if (!data->intq) {
Stephen Warren1fd879e2015-11-13 13:34:09 -0700517#elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
518 if (usb_get_report(dev, iface->desc.bInterfaceNumber,
519 1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE) < 0) {
Hans de Goede2d02ae72014-09-24 14:06:11 +0200520#else
Michal Suchanekf5d5af42019-08-18 10:55:25 +0200521 if (usb_int_msg(dev, data->intpipe, data->new, data->intpktsize,
Michal Suchanek1c95b9f2019-08-18 10:55:27 +0200522 data->intinterval, false) < 0) {
Hans de Goede2d02ae72014-09-24 14:06:11 +0200523#endif
Vincent Palatin0eab9982013-05-10 19:48:59 -0700524 printf("Failed to get keyboard state from device %04x:%04x\n",
525 dev->descriptor.idVendor, dev->descriptor.idProduct);
526 /* Abort, we don't want to use that non-functional keyboard. */
527 return 0;
528 }
Marek Vasut7534a3e2011-10-10 16:34:26 +0100529
530 /* Success. */
wdenkaffae2b2002-08-17 09:36:01 +0000531 return 1;
532}
533
Simon Glassfcdc0c32015-03-25 12:22:33 -0600534static int probe_usb_keyboard(struct usb_device *dev)
535{
536 char *stdinname;
537 struct stdio_dev usb_kbd_dev;
538 int error;
539
540 /* Try probing the keyboard */
Simon Glass02f0c282015-09-08 11:15:11 -0600541 if (usb_kbd_probe_dev(dev, 0) != 1)
Simon Glassfcdc0c32015-03-25 12:22:33 -0600542 return -ENOENT;
543
544 /* Register the keyboard */
545 debug("USB KBD: register.\n");
546 memset(&usb_kbd_dev, 0, sizeof(struct stdio_dev));
547 strcpy(usb_kbd_dev.name, DEVNAME);
Bin Meng6abe4b62015-11-03 23:23:37 -0800548 usb_kbd_dev.flags = DEV_FLAGS_INPUT;
Simon Glassfcdc0c32015-03-25 12:22:33 -0600549 usb_kbd_dev.getc = usb_kbd_getc;
550 usb_kbd_dev.tstc = usb_kbd_testc;
551 usb_kbd_dev.priv = (void *)dev;
552 error = stdio_register(&usb_kbd_dev);
553 if (error)
554 return error;
555
Simon Glass64b723f2017-08-03 12:22:12 -0600556 stdinname = env_get("stdin");
Simon Glassdfc25352017-01-16 07:03:26 -0700557#if CONFIG_IS_ENABLED(CONSOLE_MUX)
Simon Glassfcdc0c32015-03-25 12:22:33 -0600558 error = iomux_doenv(stdin, stdinname);
559 if (error)
560 return error;
561#else
562 /* Check if this is the standard input device. */
563 if (strcmp(stdinname, DEVNAME))
564 return 1;
565
566 /* Reassign the console */
567 if (overwrite_console())
568 return 1;
569
570 error = console_assign(stdin, DEVNAME);
571 if (error)
572 return error;
573#endif
574
575 return 0;
576}
577
Sven Schwermer8a3cb9f12018-11-21 08:43:56 +0100578#if !CONFIG_IS_ENABLED(DM_USB)
Marek Vasut7534a3e2011-10-10 16:34:26 +0100579/* Search for keyboard and register it if found. */
580int drv_usb_kbd_init(void)
581{
Marek Vasut7534a3e2011-10-10 16:34:26 +0100582 int error, i;
583
Simon Glass5f1296b2015-03-25 12:22:34 -0600584 debug("%s: Probing for keyboard\n", __func__);
Simon Glass5f1296b2015-03-25 12:22:34 -0600585 /* Scan all USB Devices */
Marek Vasut7534a3e2011-10-10 16:34:26 +0100586 for (i = 0; i < USB_MAX_DEVICE; i++) {
Simon Glassfcdc0c32015-03-25 12:22:33 -0600587 struct usb_device *dev;
588
Marek Vasut7534a3e2011-10-10 16:34:26 +0100589 /* Get USB device. */
590 dev = usb_get_dev_index(i);
591 if (!dev)
Simon Glassfcdc0c32015-03-25 12:22:33 -0600592 break;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100593
594 if (dev->devnum == -1)
595 continue;
596
Simon Glassfcdc0c32015-03-25 12:22:33 -0600597 error = probe_usb_keyboard(dev);
598 if (!error)
Marek Vasut7534a3e2011-10-10 16:34:26 +0100599 return 1;
Simon Glassfcdc0c32015-03-25 12:22:33 -0600600 if (error && error != -ENOENT)
Marek Vasut7534a3e2011-10-10 16:34:26 +0100601 return error;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100602 }
603
604 /* No USB Keyboard found */
605 return -1;
606}
607
608/* Deregister the keyboard. */
Hans de Goede3e51df02014-09-20 16:54:38 +0200609int usb_kbd_deregister(int force)
Marek Vasut7534a3e2011-10-10 16:34:26 +0100610{
Simon Glass3110ece2016-10-17 20:13:02 -0600611#if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER)
Hans de Goede55a54512014-09-24 14:06:08 +0200612 struct stdio_dev *dev;
613 struct usb_device *usb_kbd_dev;
614 struct usb_kbd_pdata *data;
615
616 dev = stdio_get_by_name(DEVNAME);
617 if (dev) {
618 usb_kbd_dev = (struct usb_device *)dev->priv;
619 data = usb_kbd_dev->privptr;
Simon Glassdfc25352017-01-16 07:03:26 -0700620#if CONFIG_IS_ENABLED(CONSOLE_MUX)
Andy Shevchenko05a17e82021-02-11 17:09:44 +0200621 if (iomux_replace_device(stdin, DEVNAME, force ? "nulldev" : ""))
Hans de Goedee8790a22015-01-11 20:34:44 +0100622 return 1;
623#endif
Andy Shevchenko05a17e82021-02-11 17:09:44 +0200624 if (stdio_deregister_dev(dev, force) != 0)
625 return 1;
Hans de Goede2d02ae72014-09-24 14:06:11 +0200626#ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
627 destroy_int_queue(usb_kbd_dev, data->intq);
628#endif
Hans de Goede55a54512014-09-24 14:06:08 +0200629 free(data->new);
630 free(data);
631 }
Hans de Goedef5656232014-09-20 16:54:34 +0200632
633 return 0;
Marek Vasut7534a3e2011-10-10 16:34:26 +0100634#else
635 return 1;
636#endif
637}
Simon Glass02f0c282015-09-08 11:15:11 -0600638
Hans de Goedea88d4372016-04-03 09:18:53 +0200639#endif
640
Sven Schwermer8a3cb9f12018-11-21 08:43:56 +0100641#if CONFIG_IS_ENABLED(DM_USB)
Simon Glass02f0c282015-09-08 11:15:11 -0600642
643static int usb_kbd_probe(struct udevice *dev)
644{
645 struct usb_device *udev = dev_get_parent_priv(dev);
Simon Glass02f0c282015-09-08 11:15:11 -0600646
Masahiro Yamada9b70df52016-09-06 22:17:35 +0900647 return probe_usb_keyboard(udev);
Simon Glass02f0c282015-09-08 11:15:11 -0600648}
649
Simon Glass3c3ba902016-01-03 13:50:31 -0700650static int usb_kbd_remove(struct udevice *dev)
651{
652 struct usb_device *udev = dev_get_parent_priv(dev);
653 struct usb_kbd_pdata *data;
654 struct stdio_dev *sdev;
655 int ret;
656
657 sdev = stdio_get_by_name(DEVNAME);
658 if (!sdev) {
659 ret = -ENXIO;
660 goto err;
661 }
662 data = udev->privptr;
Simon Glassdfc25352017-01-16 07:03:26 -0700663#if CONFIG_IS_ENABLED(CONSOLE_MUX)
Andy Shevchenko05a17e82021-02-11 17:09:44 +0200664 if (iomux_replace_device(stdin, DEVNAME, "nulldev")) {
Simon Glass3c3ba902016-01-03 13:50:31 -0700665 ret = -ENOLINK;
666 goto err;
667 }
668#endif
Andy Shevchenko05a17e82021-02-11 17:09:44 +0200669 if (stdio_deregister_dev(sdev, true)) {
670 ret = -EPERM;
671 goto err;
672 }
Simon Glass3c3ba902016-01-03 13:50:31 -0700673#ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
674 destroy_int_queue(udev, data->intq);
675#endif
676 free(data->new);
677 free(data);
678
679 return 0;
680err:
681 printf("%s: warning, ret=%d", __func__, ret);
682 return ret;
683}
684
Simon Glass02f0c282015-09-08 11:15:11 -0600685static const struct udevice_id usb_kbd_ids[] = {
686 { .compatible = "usb-keyboard" },
687 { }
688};
689
690U_BOOT_DRIVER(usb_kbd) = {
691 .name = "usb_kbd",
692 .id = UCLASS_KEYBOARD,
693 .of_match = usb_kbd_ids,
694 .probe = usb_kbd_probe,
Simon Glass3c3ba902016-01-03 13:50:31 -0700695 .remove = usb_kbd_remove,
Simon Glass02f0c282015-09-08 11:15:11 -0600696};
697
Simon Glass02f0c282015-09-08 11:15:11 -0600698static const struct usb_device_id kbd_id_table[] = {
699 {
700 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
701 USB_DEVICE_ID_MATCH_INT_SUBCLASS |
702 USB_DEVICE_ID_MATCH_INT_PROTOCOL,
703 .bInterfaceClass = USB_CLASS_HID,
Simon Glassab88fdb2015-11-08 23:48:04 -0700704 .bInterfaceSubClass = USB_SUB_HID_BOOT,
705 .bInterfaceProtocol = USB_PROT_HID_KEYBOARD,
Simon Glass02f0c282015-09-08 11:15:11 -0600706 },
707 { } /* Terminating entry */
708};
709
710U_BOOT_USB_DEVICE(usb_kbd, kbd_id_table);
711
712#endif