xref: /openbmc/u-boot/common/usb_kbd.c (revision c0883265)
1  /*
2   * (C) Copyright 2001
3   * Denis Peter, MPL AG Switzerland
4   *
5   * Part of this source has been derived from the Linux USB
6   * project.
7   *
8   * SPDX-License-Identifier:	GPL-2.0+
9   */
10  #include <common.h>
11  #include <console.h>
12  #include <dm.h>
13  #include <errno.h>
14  #include <malloc.h>
15  #include <memalign.h>
16  #include <stdio_dev.h>
17  #include <asm/byteorder.h>
18  
19  #include <usb.h>
20  
21  /*
22   * If overwrite_console returns 1, the stdin, stderr and stdout
23   * are switched to the serial port, else the settings in the
24   * environment are used
25   */
26  #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
27  extern int overwrite_console(void);
28  #else
29  int overwrite_console(void)
30  {
31  	return 0;
32  }
33  #endif
34  
35  /* Keyboard sampling rate */
36  #define REPEAT_RATE	40		/* 40msec -> 25cps */
37  #define REPEAT_DELAY	10		/* 10 x REPEAT_RATE = 400msec */
38  
39  #define NUM_LOCK	0x53
40  #define CAPS_LOCK	0x39
41  #define SCROLL_LOCK	0x47
42  
43  /* Modifier bits */
44  #define LEFT_CNTR	(1 << 0)
45  #define LEFT_SHIFT	(1 << 1)
46  #define LEFT_ALT	(1 << 2)
47  #define LEFT_GUI	(1 << 3)
48  #define RIGHT_CNTR	(1 << 4)
49  #define RIGHT_SHIFT	(1 << 5)
50  #define RIGHT_ALT	(1 << 6)
51  #define RIGHT_GUI	(1 << 7)
52  
53  /* Size of the keyboard buffer */
54  #define USB_KBD_BUFFER_LEN	0x20
55  
56  /* Device name */
57  #define DEVNAME			"usbkbd"
58  
59  /* Keyboard maps */
60  static const unsigned char usb_kbd_numkey[] = {
61  	'1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
62  	'\r', 0x1b, '\b', '\t', ' ', '-', '=', '[', ']',
63  	'\\', '#', ';', '\'', '`', ',', '.', '/'
64  };
65  static const unsigned char usb_kbd_numkey_shifted[] = {
66  	'!', '@', '#', '$', '%', '^', '&', '*', '(', ')',
67  	'\r', 0x1b, '\b', '\t', ' ', '_', '+', '{', '}',
68  	'|', '~', ':', '"', '~', '<', '>', '?'
69  };
70  
71  static const unsigned char usb_kbd_num_keypad[] = {
72  	'/', '*', '-', '+', '\r',
73  	'1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
74  	'.', 0, 0, 0, '='
75  };
76  
77  /*
78   * map arrow keys to ^F/^B ^N/^P, can't really use the proper
79   * ANSI sequence for arrow keys because the queuing code breaks
80   * when a single keypress expands to 3 queue elements
81   */
82  static const unsigned char usb_kbd_arrow[] = {
83  	0x6, 0x2, 0xe, 0x10
84  };
85  
86  /*
87   * NOTE: It's important for the NUM, CAPS, SCROLL-lock bits to be in this
88   *       order. See usb_kbd_setled() function!
89   */
90  #define USB_KBD_NUMLOCK		(1 << 0)
91  #define USB_KBD_CAPSLOCK	(1 << 1)
92  #define USB_KBD_SCROLLLOCK	(1 << 2)
93  #define USB_KBD_CTRL		(1 << 3)
94  
95  #define USB_KBD_LEDMASK		\
96  	(USB_KBD_NUMLOCK | USB_KBD_CAPSLOCK | USB_KBD_SCROLLLOCK)
97  
98  /*
99   * USB Keyboard reports are 8 bytes in boot protocol.
100   * Appendix B of HID Device Class Definition 1.11
101   */
102  #define USB_KBD_BOOT_REPORT_SIZE 8
103  
104  struct usb_kbd_pdata {
105  	unsigned long	intpipe;
106  	int		intpktsize;
107  	int		intinterval;
108  	unsigned long	last_report;
109  	struct int_queue *intq;
110  
111  	uint32_t	repeat_delay;
112  
113  	uint32_t	usb_in_pointer;
114  	uint32_t	usb_out_pointer;
115  	uint8_t		usb_kbd_buffer[USB_KBD_BUFFER_LEN];
116  
117  	uint8_t		*new;
118  	uint8_t		old[USB_KBD_BOOT_REPORT_SIZE];
119  
120  	uint8_t		flags;
121  };
122  
123  extern int __maybe_unused net_busy_flag;
124  
125  /* The period of time between two calls of usb_kbd_testc(). */
126  static unsigned long __maybe_unused kbd_testc_tms;
127  
128  /* Puts character in the queue and sets up the in and out pointer. */
129  static void usb_kbd_put_queue(struct usb_kbd_pdata *data, char c)
130  {
131  	if (data->usb_in_pointer == USB_KBD_BUFFER_LEN - 1) {
132  		/* Check for buffer full. */
133  		if (data->usb_out_pointer == 0)
134  			return;
135  
136  		data->usb_in_pointer = 0;
137  	} else {
138  		/* Check for buffer full. */
139  		if (data->usb_in_pointer == data->usb_out_pointer - 1)
140  			return;
141  
142  		data->usb_in_pointer++;
143  	}
144  
145  	data->usb_kbd_buffer[data->usb_in_pointer] = c;
146  }
147  
148  /*
149   * Set the LEDs. Since this is used in the irq routine, the control job is
150   * issued with a timeout of 0. This means, that the job is queued without
151   * waiting for job completion.
152   */
153  static void usb_kbd_setled(struct usb_device *dev)
154  {
155  	struct usb_interface *iface = &dev->config.if_desc[0];
156  	struct usb_kbd_pdata *data = dev->privptr;
157  	ALLOC_ALIGN_BUFFER(uint32_t, leds, 1, USB_DMA_MINALIGN);
158  
159  	*leds = data->flags & USB_KBD_LEDMASK;
160  	usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
161  		USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
162  		0x200, iface->desc.bInterfaceNumber, leds, 1, 0);
163  }
164  
165  #define CAPITAL_MASK	0x20
166  /* Translate the scancode in ASCII */
167  static int usb_kbd_translate(struct usb_kbd_pdata *data, unsigned char scancode,
168  				unsigned char modifier, int pressed)
169  {
170  	uint8_t keycode = 0;
171  
172  	/* Key released */
173  	if (pressed == 0) {
174  		data->repeat_delay = 0;
175  		return 0;
176  	}
177  
178  	if (pressed == 2) {
179  		data->repeat_delay++;
180  		if (data->repeat_delay < REPEAT_DELAY)
181  			return 0;
182  
183  		data->repeat_delay = REPEAT_DELAY;
184  	}
185  
186  	/* Alphanumeric values */
187  	if ((scancode > 3) && (scancode <= 0x1d)) {
188  		keycode = scancode - 4 + 'a';
189  
190  		if (data->flags & USB_KBD_CAPSLOCK)
191  			keycode &= ~CAPITAL_MASK;
192  
193  		if (modifier & (LEFT_SHIFT | RIGHT_SHIFT)) {
194  			/* Handle CAPSLock + Shift pressed simultaneously */
195  			if (keycode & CAPITAL_MASK)
196  				keycode &= ~CAPITAL_MASK;
197  			else
198  				keycode |= CAPITAL_MASK;
199  		}
200  	}
201  
202  	if ((scancode > 0x1d) && (scancode < 0x3a)) {
203  		/* Shift pressed */
204  		if (modifier & (LEFT_SHIFT | RIGHT_SHIFT))
205  			keycode = usb_kbd_numkey_shifted[scancode - 0x1e];
206  		else
207  			keycode = usb_kbd_numkey[scancode - 0x1e];
208  	}
209  
210  	/* Arrow keys */
211  	if ((scancode >= 0x4f) && (scancode <= 0x52))
212  		keycode = usb_kbd_arrow[scancode - 0x4f];
213  
214  	/* Numeric keypad */
215  	if ((scancode >= 0x54) && (scancode <= 0x67))
216  		keycode = usb_kbd_num_keypad[scancode - 0x54];
217  
218  	if (data->flags & USB_KBD_CTRL)
219  		keycode = scancode - 0x3;
220  
221  	if (pressed == 1) {
222  		if (scancode == NUM_LOCK) {
223  			data->flags ^= USB_KBD_NUMLOCK;
224  			return 1;
225  		}
226  
227  		if (scancode == CAPS_LOCK) {
228  			data->flags ^= USB_KBD_CAPSLOCK;
229  			return 1;
230  		}
231  		if (scancode == SCROLL_LOCK) {
232  			data->flags ^= USB_KBD_SCROLLLOCK;
233  			return 1;
234  		}
235  	}
236  
237  	/* Report keycode if any */
238  	if (keycode) {
239  		debug("%c", keycode);
240  		usb_kbd_put_queue(data, keycode);
241  	}
242  
243  	return 0;
244  }
245  
246  static uint32_t usb_kbd_service_key(struct usb_device *dev, int i, int up)
247  {
248  	uint32_t res = 0;
249  	struct usb_kbd_pdata *data = dev->privptr;
250  	uint8_t *new;
251  	uint8_t *old;
252  
253  	if (up) {
254  		new = data->old;
255  		old = data->new;
256  	} else {
257  		new = data->new;
258  		old = data->old;
259  	}
260  
261  	if ((old[i] > 3) &&
262  	    (memscan(new + 2, old[i], USB_KBD_BOOT_REPORT_SIZE - 2) ==
263  			new + USB_KBD_BOOT_REPORT_SIZE)) {
264  		res |= usb_kbd_translate(data, old[i], data->new[0], up);
265  	}
266  
267  	return res;
268  }
269  
270  /* Interrupt service routine */
271  static int usb_kbd_irq_worker(struct usb_device *dev)
272  {
273  	struct usb_kbd_pdata *data = dev->privptr;
274  	int i, res = 0;
275  
276  	/* No combo key pressed */
277  	if (data->new[0] == 0x00)
278  		data->flags &= ~USB_KBD_CTRL;
279  	/* Left or Right Ctrl pressed */
280  	else if ((data->new[0] == LEFT_CNTR) || (data->new[0] == RIGHT_CNTR))
281  		data->flags |= USB_KBD_CTRL;
282  
283  	for (i = 2; i < USB_KBD_BOOT_REPORT_SIZE; i++) {
284  		res |= usb_kbd_service_key(dev, i, 0);
285  		res |= usb_kbd_service_key(dev, i, 1);
286  	}
287  
288  	/* Key is still pressed */
289  	if ((data->new[2] > 3) && (data->old[2] == data->new[2]))
290  		res |= usb_kbd_translate(data, data->new[2], data->new[0], 2);
291  
292  	if (res == 1)
293  		usb_kbd_setled(dev);
294  
295  	memcpy(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE);
296  
297  	return 1;
298  }
299  
300  /* Keyboard interrupt handler */
301  static int usb_kbd_irq(struct usb_device *dev)
302  {
303  	if ((dev->irq_status != 0) ||
304  	    (dev->irq_act_len != USB_KBD_BOOT_REPORT_SIZE)) {
305  		debug("USB KBD: Error %lX, len %d\n",
306  		      dev->irq_status, dev->irq_act_len);
307  		return 1;
308  	}
309  
310  	return usb_kbd_irq_worker(dev);
311  }
312  
313  /* Interrupt polling */
314  static inline void usb_kbd_poll_for_event(struct usb_device *dev)
315  {
316  #if defined(CONFIG_SYS_USB_EVENT_POLL)
317  	struct usb_kbd_pdata *data = dev->privptr;
318  
319  	/* Submit a interrupt transfer request */
320  	usb_submit_int_msg(dev, data->intpipe, &data->new[0], data->intpktsize,
321  			   data->intinterval);
322  
323  	usb_kbd_irq_worker(dev);
324  #elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) || \
325        defined(CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE)
326  #if defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
327  	struct usb_interface *iface;
328  	struct usb_kbd_pdata *data = dev->privptr;
329  	iface = &dev->config.if_desc[0];
330  	usb_get_report(dev, iface->desc.bInterfaceNumber,
331  		       1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE);
332  	if (memcmp(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE)) {
333  		usb_kbd_irq_worker(dev);
334  #else
335  	struct usb_kbd_pdata *data = dev->privptr;
336  	if (poll_int_queue(dev, data->intq)) {
337  		usb_kbd_irq_worker(dev);
338  		/* We've consumed all queued int packets, create new */
339  		destroy_int_queue(dev, data->intq);
340  		data->intq = create_int_queue(dev, data->intpipe, 1,
341  				      USB_KBD_BOOT_REPORT_SIZE, data->new,
342  				      data->intinterval);
343  #endif
344  		data->last_report = get_timer(0);
345  	/* Repeat last usb hid report every REPEAT_RATE ms for keyrepeat */
346  	} else if (data->last_report != -1 &&
347  		   get_timer(data->last_report) > REPEAT_RATE) {
348  		usb_kbd_irq_worker(dev);
349  		data->last_report = get_timer(0);
350  	}
351  #endif
352  }
353  
354  /* test if a character is in the queue */
355  static int usb_kbd_testc(struct stdio_dev *sdev)
356  {
357  	struct stdio_dev *dev;
358  	struct usb_device *usb_kbd_dev;
359  	struct usb_kbd_pdata *data;
360  
361  #ifdef CONFIG_CMD_NET
362  	/*
363  	 * If net_busy_flag is 1, NET transfer is running,
364  	 * then we check key-pressed every second (first check may be
365  	 * less than 1 second) to improve TFTP booting performance.
366  	 */
367  	if (net_busy_flag && (get_timer(kbd_testc_tms) < CONFIG_SYS_HZ))
368  		return 0;
369  	kbd_testc_tms = get_timer(0);
370  #endif
371  	dev = stdio_get_by_name(DEVNAME);
372  	usb_kbd_dev = (struct usb_device *)dev->priv;
373  	data = usb_kbd_dev->privptr;
374  
375  	usb_kbd_poll_for_event(usb_kbd_dev);
376  
377  	return !(data->usb_in_pointer == data->usb_out_pointer);
378  }
379  
380  /* gets the character from the queue */
381  static int usb_kbd_getc(struct stdio_dev *sdev)
382  {
383  	struct stdio_dev *dev;
384  	struct usb_device *usb_kbd_dev;
385  	struct usb_kbd_pdata *data;
386  
387  	dev = stdio_get_by_name(DEVNAME);
388  	usb_kbd_dev = (struct usb_device *)dev->priv;
389  	data = usb_kbd_dev->privptr;
390  
391  	while (data->usb_in_pointer == data->usb_out_pointer)
392  		usb_kbd_poll_for_event(usb_kbd_dev);
393  
394  	if (data->usb_out_pointer == USB_KBD_BUFFER_LEN - 1)
395  		data->usb_out_pointer = 0;
396  	else
397  		data->usb_out_pointer++;
398  
399  	return data->usb_kbd_buffer[data->usb_out_pointer];
400  }
401  
402  /* probes the USB device dev for keyboard type. */
403  static int usb_kbd_probe_dev(struct usb_device *dev, unsigned int ifnum)
404  {
405  	struct usb_interface *iface;
406  	struct usb_endpoint_descriptor *ep;
407  	struct usb_kbd_pdata *data;
408  
409  	if (dev->descriptor.bNumConfigurations != 1)
410  		return 0;
411  
412  	iface = &dev->config.if_desc[ifnum];
413  
414  	if (iface->desc.bInterfaceClass != USB_CLASS_HID)
415  		return 0;
416  
417  	if (iface->desc.bInterfaceSubClass != USB_SUB_HID_BOOT)
418  		return 0;
419  
420  	if (iface->desc.bInterfaceProtocol != USB_PROT_HID_KEYBOARD)
421  		return 0;
422  
423  	if (iface->desc.bNumEndpoints != 1)
424  		return 0;
425  
426  	ep = &iface->ep_desc[0];
427  
428  	/* Check if endpoint 1 is interrupt endpoint */
429  	if (!(ep->bEndpointAddress & 0x80))
430  		return 0;
431  
432  	if ((ep->bmAttributes & 3) != 3)
433  		return 0;
434  
435  	debug("USB KBD: found set protocol...\n");
436  
437  	data = malloc(sizeof(struct usb_kbd_pdata));
438  	if (!data) {
439  		printf("USB KBD: Error allocating private data\n");
440  		return 0;
441  	}
442  
443  	/* Clear private data */
444  	memset(data, 0, sizeof(struct usb_kbd_pdata));
445  
446  	/* allocate input buffer aligned and sized to USB DMA alignment */
447  	data->new = memalign(USB_DMA_MINALIGN,
448  		roundup(USB_KBD_BOOT_REPORT_SIZE, USB_DMA_MINALIGN));
449  
450  	/* Insert private data into USB device structure */
451  	dev->privptr = data;
452  
453  	/* Set IRQ handler */
454  	dev->irq_handle = usb_kbd_irq;
455  
456  	data->intpipe = usb_rcvintpipe(dev, ep->bEndpointAddress);
457  	data->intpktsize = min(usb_maxpacket(dev, data->intpipe),
458  			       USB_KBD_BOOT_REPORT_SIZE);
459  	data->intinterval = ep->bInterval;
460  	data->last_report = -1;
461  
462  	/* We found a USB Keyboard, install it. */
463  	usb_set_protocol(dev, iface->desc.bInterfaceNumber, 0);
464  
465  	debug("USB KBD: found set idle...\n");
466  #if !defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP) && \
467      !defined(CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE)
468  	usb_set_idle(dev, iface->desc.bInterfaceNumber, REPEAT_RATE / 4, 0);
469  #else
470  	usb_set_idle(dev, iface->desc.bInterfaceNumber, 0, 0);
471  #endif
472  
473  	debug("USB KBD: enable interrupt pipe...\n");
474  #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
475  	data->intq = create_int_queue(dev, data->intpipe, 1,
476  				      USB_KBD_BOOT_REPORT_SIZE, data->new,
477  				      data->intinterval);
478  	if (!data->intq) {
479  #elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
480  	if (usb_get_report(dev, iface->desc.bInterfaceNumber,
481  			   1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE) < 0) {
482  #else
483  	if (usb_submit_int_msg(dev, data->intpipe, data->new, data->intpktsize,
484  			       data->intinterval) < 0) {
485  #endif
486  		printf("Failed to get keyboard state from device %04x:%04x\n",
487  		       dev->descriptor.idVendor, dev->descriptor.idProduct);
488  		/* Abort, we don't want to use that non-functional keyboard. */
489  		return 0;
490  	}
491  
492  	/* Success. */
493  	return 1;
494  }
495  
496  static int probe_usb_keyboard(struct usb_device *dev)
497  {
498  	char *stdinname;
499  	struct stdio_dev usb_kbd_dev;
500  	int error;
501  
502  	/* Try probing the keyboard */
503  	if (usb_kbd_probe_dev(dev, 0) != 1)
504  		return -ENOENT;
505  
506  	/* Register the keyboard */
507  	debug("USB KBD: register.\n");
508  	memset(&usb_kbd_dev, 0, sizeof(struct stdio_dev));
509  	strcpy(usb_kbd_dev.name, DEVNAME);
510  	usb_kbd_dev.flags =  DEV_FLAGS_INPUT;
511  	usb_kbd_dev.getc = usb_kbd_getc;
512  	usb_kbd_dev.tstc = usb_kbd_testc;
513  	usb_kbd_dev.priv = (void *)dev;
514  	error = stdio_register(&usb_kbd_dev);
515  	if (error)
516  		return error;
517  
518  	stdinname = getenv("stdin");
519  #ifdef CONFIG_CONSOLE_MUX
520  	error = iomux_doenv(stdin, stdinname);
521  	if (error)
522  		return error;
523  #else
524  	/* Check if this is the standard input device. */
525  	if (strcmp(stdinname, DEVNAME))
526  		return 1;
527  
528  	/* Reassign the console */
529  	if (overwrite_console())
530  		return 1;
531  
532  	error = console_assign(stdin, DEVNAME);
533  	if (error)
534  		return error;
535  #endif
536  
537  	return 0;
538  }
539  
540  #ifndef CONFIG_DM_USB
541  /* Search for keyboard and register it if found. */
542  int drv_usb_kbd_init(void)
543  {
544  	int error, i;
545  
546  	debug("%s: Probing for keyboard\n", __func__);
547  	/* Scan all USB Devices */
548  	for (i = 0; i < USB_MAX_DEVICE; i++) {
549  		struct usb_device *dev;
550  
551  		/* Get USB device. */
552  		dev = usb_get_dev_index(i);
553  		if (!dev)
554  			break;
555  
556  		if (dev->devnum == -1)
557  			continue;
558  
559  		error = probe_usb_keyboard(dev);
560  		if (!error)
561  			return 1;
562  		if (error && error != -ENOENT)
563  			return error;
564  	}
565  
566  	/* No USB Keyboard found */
567  	return -1;
568  }
569  #endif
570  
571  /* Deregister the keyboard. */
572  int usb_kbd_deregister(int force)
573  {
574  #ifdef CONFIG_SYS_STDIO_DEREGISTER
575  	struct stdio_dev *dev;
576  	struct usb_device *usb_kbd_dev;
577  	struct usb_kbd_pdata *data;
578  
579  	dev = stdio_get_by_name(DEVNAME);
580  	if (dev) {
581  		usb_kbd_dev = (struct usb_device *)dev->priv;
582  		data = usb_kbd_dev->privptr;
583  		if (stdio_deregister_dev(dev, force) != 0)
584  			return 1;
585  #ifdef CONFIG_CONSOLE_MUX
586  		if (iomux_doenv(stdin, getenv("stdin")) != 0)
587  			return 1;
588  #endif
589  #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
590  		destroy_int_queue(usb_kbd_dev, data->intq);
591  #endif
592  		free(data->new);
593  		free(data);
594  	}
595  
596  	return 0;
597  #else
598  	return 1;
599  #endif
600  }
601  
602  #ifdef CONFIG_DM_USB
603  
604  static int usb_kbd_probe(struct udevice *dev)
605  {
606  	struct usb_device *udev = dev_get_parent_priv(dev);
607  	int ret;
608  
609  	ret = probe_usb_keyboard(udev);
610  
611  	return ret;
612  }
613  
614  static int usb_kbd_remove(struct udevice *dev)
615  {
616  	struct usb_device *udev = dev_get_parent_priv(dev);
617  	struct usb_kbd_pdata *data;
618  	struct stdio_dev *sdev;
619  	int ret;
620  
621  	sdev = stdio_get_by_name(DEVNAME);
622  	if (!sdev) {
623  		ret = -ENXIO;
624  		goto err;
625  	}
626  	data = udev->privptr;
627  	if (stdio_deregister_dev(sdev, true)) {
628  		ret = -EPERM;
629  		goto err;
630  	}
631  #ifdef CONFIG_CONSOLE_MUX
632  	if (iomux_doenv(stdin, getenv("stdin"))) {
633  		ret = -ENOLINK;
634  		goto err;
635  	}
636  #endif
637  #ifdef CONFIG_SYS_USB_EVENT_POLL_VIA_INT_QUEUE
638  	destroy_int_queue(udev, data->intq);
639  #endif
640  	free(data->new);
641  	free(data);
642  
643  	return 0;
644  err:
645  	printf("%s: warning, ret=%d", __func__, ret);
646  	return ret;
647  }
648  
649  static const struct udevice_id usb_kbd_ids[] = {
650  	{ .compatible = "usb-keyboard" },
651  	{ }
652  };
653  
654  U_BOOT_DRIVER(usb_kbd) = {
655  	.name	= "usb_kbd",
656  	.id	= UCLASS_KEYBOARD,
657  	.of_match = usb_kbd_ids,
658  	.probe = usb_kbd_probe,
659  	.remove = usb_kbd_remove,
660  };
661  
662  static const struct usb_device_id kbd_id_table[] = {
663  	{
664  		.match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
665  			USB_DEVICE_ID_MATCH_INT_SUBCLASS |
666  			USB_DEVICE_ID_MATCH_INT_PROTOCOL,
667  		.bInterfaceClass = USB_CLASS_HID,
668  		.bInterfaceSubClass = USB_SUB_HID_BOOT,
669  		.bInterfaceProtocol = USB_PROT_HID_KEYBOARD,
670  	},
671  	{ }		/* Terminating entry */
672  };
673  
674  U_BOOT_USB_DEVICE(usb_kbd, kbd_id_table);
675  
676  #endif
677