blob: c7b642c40af969885d0d782bcf010740e613f16f [file] [log] [blame]
wdenke887afc2002-08-27 09:44:07 +00001/*
2 * (C) Copyright 2001
3 * Denis Peter, MPL AG Switzerland
4 *
Simon Glass6a1b2062015-03-25 12:22:02 -06005 * Adapted for U-Boot driver model
6 * (C) Copyright 2015 Google, Inc
7 *
wdenke887afc2002-08-27 09:44:07 +00008 * Most of this source has been derived from the Linux USB
9 * project.
10 *
Wolfgang Denk1a459662013-07-08 09:37:19 +020011 * SPDX-License-Identifier: GPL-2.0+
wdenke887afc2002-08-27 09:44:07 +000012 */
13
14#include <common.h>
15#include <command.h>
Simon Glass24b852a2015-11-08 23:47:45 -070016#include <console.h>
Simon Glass6a1b2062015-03-25 12:22:02 -060017#include <dm.h>
Simon Glasscf92e052015-09-02 17:24:58 -060018#include <memalign.h>
wdenk414eec32005-04-02 22:37:54 +000019#include <asm/byteorder.h>
Tom Rinib2fb47f2011-12-15 08:40:51 -070020#include <asm/unaligned.h>
Grant Likely735dd972007-02-20 09:04:34 +010021#include <part.h>
wdenke887afc2002-08-27 09:44:07 +000022#include <usb.h>
wdenke887afc2002-08-27 09:44:07 +000023
wdenk1968e612005-02-24 23:23:29 +000024#ifdef CONFIG_USB_STORAGE
Wolfgang Denkd0ff51b2008-07-14 15:19:07 +020025static int usb_stor_curr_dev = -1; /* current device */
wdenk1968e612005-02-24 23:23:29 +000026#endif
Simon Glassc8c27972015-07-06 16:47:50 -060027#if defined(CONFIG_USB_HOST_ETHER) && !defined(CONFIG_DM_ETH)
Simon Glass69559092015-07-06 16:47:48 -060028static int __maybe_unused usb_ether_curr_dev = -1; /* current ethernet device */
Simon Glass89d48362011-02-16 11:14:33 -080029#endif
wdenke887afc2002-08-27 09:44:07 +000030
wdenka2663ea2003-12-07 18:32:37 +000031/* some display routines (info command) */
Kim Phillips088f1b12012-10-29 13:34:31 +000032static char *usb_get_class_desc(unsigned char dclass)
wdenke887afc2002-08-27 09:44:07 +000033{
Michael Trimarchide39f8c2008-11-26 17:41:34 +010034 switch (dclass) {
35 case USB_CLASS_PER_INTERFACE:
36 return "See Interface";
37 case USB_CLASS_AUDIO:
38 return "Audio";
39 case USB_CLASS_COMM:
40 return "Communication";
41 case USB_CLASS_HID:
42 return "Human Interface";
43 case USB_CLASS_PRINTER:
44 return "Printer";
45 case USB_CLASS_MASS_STORAGE:
46 return "Mass Storage";
47 case USB_CLASS_HUB:
48 return "Hub";
49 case USB_CLASS_DATA:
50 return "CDC Data";
51 case USB_CLASS_VENDOR_SPEC:
52 return "Vendor specific";
53 default:
54 return "";
wdenke887afc2002-08-27 09:44:07 +000055 }
56}
57
Kim Phillips088f1b12012-10-29 13:34:31 +000058static void usb_display_class_sub(unsigned char dclass, unsigned char subclass,
59 unsigned char proto)
wdenke887afc2002-08-27 09:44:07 +000060{
Michael Trimarchide39f8c2008-11-26 17:41:34 +010061 switch (dclass) {
62 case USB_CLASS_PER_INTERFACE:
63 printf("See Interface");
64 break;
65 case USB_CLASS_HID:
66 printf("Human Interface, Subclass: ");
67 switch (subclass) {
68 case USB_SUB_HID_NONE:
69 printf("None");
wdenke887afc2002-08-27 09:44:07 +000070 break;
Michael Trimarchide39f8c2008-11-26 17:41:34 +010071 case USB_SUB_HID_BOOT:
72 printf("Boot ");
73 switch (proto) {
74 case USB_PROT_HID_NONE:
75 printf("None");
76 break;
77 case USB_PROT_HID_KEYBOARD:
78 printf("Keyboard");
79 break;
80 case USB_PROT_HID_MOUSE:
81 printf("Mouse");
82 break;
83 default:
84 printf("reserved");
85 break;
wdenke887afc2002-08-27 09:44:07 +000086 }
87 break;
88 default:
Michael Trimarchide39f8c2008-11-26 17:41:34 +010089 printf("reserved");
90 break;
91 }
92 break;
93 case USB_CLASS_MASS_STORAGE:
94 printf("Mass Storage, ");
95 switch (subclass) {
96 case US_SC_RBC:
97 printf("RBC ");
98 break;
99 case US_SC_8020:
100 printf("SFF-8020i (ATAPI)");
101 break;
102 case US_SC_QIC:
103 printf("QIC-157 (Tape)");
104 break;
105 case US_SC_UFI:
106 printf("UFI");
107 break;
108 case US_SC_8070:
109 printf("SFF-8070");
110 break;
111 case US_SC_SCSI:
112 printf("Transp. SCSI");
113 break;
114 default:
115 printf("reserved");
116 break;
117 }
118 printf(", ");
119 switch (proto) {
120 case US_PR_CB:
121 printf("Command/Bulk");
122 break;
123 case US_PR_CBI:
124 printf("Command/Bulk/Int");
125 break;
126 case US_PR_BULK:
127 printf("Bulk only");
128 break;
129 default:
130 printf("reserved");
131 break;
132 }
133 break;
134 default:
135 printf("%s", usb_get_class_desc(dclass));
136 break;
wdenke887afc2002-08-27 09:44:07 +0000137 }
138}
139
Kim Phillips088f1b12012-10-29 13:34:31 +0000140static void usb_display_string(struct usb_device *dev, int index)
wdenke887afc2002-08-27 09:44:07 +0000141{
Puneet Saxenaf5766132012-04-03 14:56:06 +0530142 ALLOC_CACHE_ALIGN_BUFFER(char, buffer, 256);
143
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100144 if (index != 0) {
145 if (usb_string(dev, index, &buffer[0], 256) > 0)
146 printf("String: \"%s\"", buffer);
wdenke887afc2002-08-27 09:44:07 +0000147 }
148}
149
Kim Phillips088f1b12012-10-29 13:34:31 +0000150static void usb_display_desc(struct usb_device *dev)
wdenke887afc2002-08-27 09:44:07 +0000151{
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100152 if (dev->descriptor.bDescriptorType == USB_DT_DEVICE) {
153 printf("%d: %s, USB Revision %x.%x\n", dev->devnum,
Tom Rix8f8bd562009-10-31 12:37:38 -0500154 usb_get_class_desc(dev->config.if_desc[0].desc.bInterfaceClass),
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100155 (dev->descriptor.bcdUSB>>8) & 0xff,
156 dev->descriptor.bcdUSB & 0xff);
157
158 if (strlen(dev->mf) || strlen(dev->prod) ||
159 strlen(dev->serial))
160 printf(" - %s %s %s\n", dev->mf, dev->prod,
161 dev->serial);
wdenke887afc2002-08-27 09:44:07 +0000162 if (dev->descriptor.bDeviceClass) {
163 printf(" - Class: ");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100164 usb_display_class_sub(dev->descriptor.bDeviceClass,
165 dev->descriptor.bDeviceSubClass,
166 dev->descriptor.bDeviceProtocol);
wdenke887afc2002-08-27 09:44:07 +0000167 printf("\n");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100168 } else {
169 printf(" - Class: (from Interface) %s\n",
170 usb_get_class_desc(
Tom Rix8f8bd562009-10-31 12:37:38 -0500171 dev->config.if_desc[0].desc.bInterfaceClass));
wdenke887afc2002-08-27 09:44:07 +0000172 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100173 printf(" - PacketSize: %d Configurations: %d\n",
174 dev->descriptor.bMaxPacketSize0,
175 dev->descriptor.bNumConfigurations);
176 printf(" - Vendor: 0x%04x Product 0x%04x Version %d.%d\n",
177 dev->descriptor.idVendor, dev->descriptor.idProduct,
178 (dev->descriptor.bcdDevice>>8) & 0xff,
179 dev->descriptor.bcdDevice & 0xff);
wdenke887afc2002-08-27 09:44:07 +0000180 }
181
182}
183
Ilya Yanokc60795f2012-11-06 13:48:20 +0000184static void usb_display_conf_desc(struct usb_config_descriptor *config,
Kim Phillips088f1b12012-10-29 13:34:31 +0000185 struct usb_device *dev)
wdenke887afc2002-08-27 09:44:07 +0000186{
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100187 printf(" Configuration: %d\n", config->bConfigurationValue);
188 printf(" - Interfaces: %d %s%s%dmA\n", config->bNumInterfaces,
189 (config->bmAttributes & 0x40) ? "Self Powered " : "Bus Powered ",
190 (config->bmAttributes & 0x20) ? "Remote Wakeup " : "",
Tom Rix8f8bd562009-10-31 12:37:38 -0500191 config->bMaxPower*2);
wdenke887afc2002-08-27 09:44:07 +0000192 if (config->iConfiguration) {
193 printf(" - ");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100194 usb_display_string(dev, config->iConfiguration);
wdenke887afc2002-08-27 09:44:07 +0000195 printf("\n");
196 }
197}
198
Kim Phillips088f1b12012-10-29 13:34:31 +0000199static void usb_display_if_desc(struct usb_interface_descriptor *ifdesc,
200 struct usb_device *dev)
wdenke887afc2002-08-27 09:44:07 +0000201{
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100202 printf(" Interface: %d\n", ifdesc->bInterfaceNumber);
203 printf(" - Alternate Setting %d, Endpoints: %d\n",
204 ifdesc->bAlternateSetting, ifdesc->bNumEndpoints);
wdenke887afc2002-08-27 09:44:07 +0000205 printf(" - Class ");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100206 usb_display_class_sub(ifdesc->bInterfaceClass,
207 ifdesc->bInterfaceSubClass, ifdesc->bInterfaceProtocol);
wdenke887afc2002-08-27 09:44:07 +0000208 printf("\n");
209 if (ifdesc->iInterface) {
210 printf(" - ");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100211 usb_display_string(dev, ifdesc->iInterface);
wdenke887afc2002-08-27 09:44:07 +0000212 printf("\n");
213 }
214}
215
Kim Phillips088f1b12012-10-29 13:34:31 +0000216static void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc)
wdenke887afc2002-08-27 09:44:07 +0000217{
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100218 printf(" - Endpoint %d %s ", epdesc->bEndpointAddress & 0xf,
219 (epdesc->bEndpointAddress & 0x80) ? "In" : "Out");
220 switch ((epdesc->bmAttributes & 0x03)) {
221 case 0:
222 printf("Control");
223 break;
224 case 1:
225 printf("Isochronous");
226 break;
227 case 2:
228 printf("Bulk");
229 break;
230 case 3:
231 printf("Interrupt");
232 break;
wdenke887afc2002-08-27 09:44:07 +0000233 }
Tom Rinib2fb47f2011-12-15 08:40:51 -0700234 printf(" MaxPacket %d", get_unaligned(&epdesc->wMaxPacketSize));
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100235 if ((epdesc->bmAttributes & 0x03) == 0x3)
236 printf(" Interval %dms", epdesc->bInterval);
wdenke887afc2002-08-27 09:44:07 +0000237 printf("\n");
238}
239
240/* main routine to diasplay the configs, interfaces and endpoints */
Kim Phillips088f1b12012-10-29 13:34:31 +0000241static void usb_display_config(struct usb_device *dev)
wdenke887afc2002-08-27 09:44:07 +0000242{
Tom Rix8f8bd562009-10-31 12:37:38 -0500243 struct usb_config *config;
244 struct usb_interface *ifdesc;
wdenke887afc2002-08-27 09:44:07 +0000245 struct usb_endpoint_descriptor *epdesc;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100246 int i, ii;
wdenke887afc2002-08-27 09:44:07 +0000247
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100248 config = &dev->config;
Tom Rix8f8bd562009-10-31 12:37:38 -0500249 usb_display_conf_desc(&config->desc, dev);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100250 for (i = 0; i < config->no_of_if; i++) {
251 ifdesc = &config->if_desc[i];
Tom Rix8f8bd562009-10-31 12:37:38 -0500252 usb_display_if_desc(&ifdesc->desc, dev);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100253 for (ii = 0; ii < ifdesc->no_of_ep; ii++) {
254 epdesc = &ifdesc->ep_desc[ii];
wdenke887afc2002-08-27 09:44:07 +0000255 usb_display_ep_desc(epdesc);
256 }
257 }
258 printf("\n");
259}
260
Simon Glass6a1b2062015-03-25 12:22:02 -0600261/*
262 * With driver model this isn't right since we can have multiple controllers
263 * and the device numbering starts at 1 on each bus.
264 * TODO(sjg@chromium.org): Add a way to specify the controller/bus.
265 */
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000266static struct usb_device *usb_find_device(int devnum)
267{
Simon Glass6a1b2062015-03-25 12:22:02 -0600268#ifdef CONFIG_DM_USB
269 struct usb_device *udev;
270 struct udevice *hub;
271 struct uclass *uc;
272 int ret;
273
274 /* Device addresses start at 1 */
275 devnum++;
276 ret = uclass_get(UCLASS_USB_HUB, &uc);
277 if (ret)
278 return NULL;
279
280 uclass_foreach_dev(hub, uc) {
281 struct udevice *dev;
282
283 if (!device_active(hub))
284 continue;
Simon Glassbcbe3d12015-09-28 23:32:01 -0600285 udev = dev_get_parent_priv(hub);
Simon Glass6a1b2062015-03-25 12:22:02 -0600286 if (udev->devnum == devnum)
287 return udev;
288
289 for (device_find_first_child(hub, &dev);
290 dev;
291 device_find_next_child(&dev)) {
292 if (!device_active(hub))
293 continue;
294
Simon Glassbcbe3d12015-09-28 23:32:01 -0600295 udev = dev_get_parent_priv(dev);
Simon Glass6a1b2062015-03-25 12:22:02 -0600296 if (udev->devnum == devnum)
297 return udev;
298 }
299 }
300#else
Simon Glasscad42912015-03-25 12:22:00 -0600301 struct usb_device *udev;
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000302 int d;
303
304 for (d = 0; d < USB_MAX_DEVICE; d++) {
Simon Glasscad42912015-03-25 12:22:00 -0600305 udev = usb_get_dev_index(d);
306 if (udev == NULL)
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000307 return NULL;
Simon Glasscad42912015-03-25 12:22:00 -0600308 if (udev->devnum == devnum)
309 return udev;
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000310 }
Simon Glass6a1b2062015-03-25 12:22:02 -0600311#endif
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000312
313 return NULL;
314}
315
Stefan Roesef1c1f542009-01-22 10:11:21 +0100316static inline char *portspeed(int speed)
317{
Vivek Gautam6497c662013-04-12 16:34:38 +0530318 char *speed_str;
319
320 switch (speed) {
321 case USB_SPEED_SUPER:
322 speed_str = "5 Gb/s";
323 break;
324 case USB_SPEED_HIGH:
325 speed_str = "480 Mb/s";
326 break;
327 case USB_SPEED_LOW:
328 speed_str = "1.5 Mb/s";
329 break;
330 default:
331 speed_str = "12 Mb/s";
332 break;
333 }
334
335 return speed_str;
Stefan Roesef1c1f542009-01-22 10:11:21 +0100336}
337
wdenke887afc2002-08-27 09:44:07 +0000338/* shows the device tree recursively */
Kim Phillips088f1b12012-10-29 13:34:31 +0000339static void usb_show_tree_graph(struct usb_device *dev, char *pre)
wdenke887afc2002-08-27 09:44:07 +0000340{
Simon Glass6a1b2062015-03-25 12:22:02 -0600341 int index;
Wolfgang Denk10f4dd72011-10-05 23:01:59 +0200342 int has_child, last_child;
wdenke887afc2002-08-27 09:44:07 +0000343
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100344 index = strlen(pre);
345 printf(" %s", pre);
Simon Glass6a1b2062015-03-25 12:22:02 -0600346#ifdef CONFIG_DM_USB
347 has_child = device_has_active_children(dev->dev);
348#else
wdenke887afc2002-08-27 09:44:07 +0000349 /* check if the device has connected children */
Simon Glass6a1b2062015-03-25 12:22:02 -0600350 int i;
351
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100352 has_child = 0;
353 for (i = 0; i < dev->maxchild; i++) {
354 if (dev->children[i] != NULL)
355 has_child = 1;
wdenke887afc2002-08-27 09:44:07 +0000356 }
Simon Glass6a1b2062015-03-25 12:22:02 -0600357#endif
wdenke887afc2002-08-27 09:44:07 +0000358 /* check if we are the last one */
Simon Glass6a1b2062015-03-25 12:22:02 -0600359#ifdef CONFIG_DM_USB
Hans de Goedec27b3292015-06-17 21:33:50 +0200360 /* Not the root of the usb tree? */
361 if (device_get_uclass_id(dev->dev->parent) != UCLASS_USB) {
362 last_child = device_is_last_sibling(dev->dev);
Simon Glass6a1b2062015-03-25 12:22:02 -0600363#else
Hans de Goedec27b3292015-06-17 21:33:50 +0200364 if (dev->parent != NULL) { /* not root? */
365 last_child = 1;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100366 for (i = 0; i < dev->parent->maxchild; i++) {
wdenke887afc2002-08-27 09:44:07 +0000367 /* search for children */
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100368 if (dev->parent->children[i] == dev) {
369 /* found our pointer, see if we have a
370 * little sister
371 */
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100372 while (i++ < dev->parent->maxchild) {
373 if (dev->parent->children[i] != NULL) {
wdenke887afc2002-08-27 09:44:07 +0000374 /* found a sister */
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100375 last_child = 0;
wdenke887afc2002-08-27 09:44:07 +0000376 break;
377 } /* if */
378 } /* while */
379 } /* device found */
380 } /* for all children of the parent */
Simon Glass6a1b2062015-03-25 12:22:02 -0600381#endif
wdenke887afc2002-08-27 09:44:07 +0000382 printf("\b+-");
383 /* correct last child */
Simon Glasscad42912015-03-25 12:22:00 -0600384 if (last_child && index)
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100385 pre[index-1] = ' ';
wdenke887afc2002-08-27 09:44:07 +0000386 } /* if not root hub */
387 else
388 printf(" ");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100389 printf("%d ", dev->devnum);
390 pre[index++] = ' ';
391 pre[index++] = has_child ? '|' : ' ';
392 pre[index] = 0;
393 printf(" %s (%s, %dmA)\n", usb_get_class_desc(
Tom Rix8f8bd562009-10-31 12:37:38 -0500394 dev->config.if_desc[0].desc.bInterfaceClass),
Stefan Roesef1c1f542009-01-22 10:11:21 +0100395 portspeed(dev->speed),
Tom Rix8f8bd562009-10-31 12:37:38 -0500396 dev->config.desc.bMaxPower * 2);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100397 if (strlen(dev->mf) || strlen(dev->prod) || strlen(dev->serial))
398 printf(" %s %s %s %s\n", pre, dev->mf, dev->prod, dev->serial);
399 printf(" %s\n", pre);
Simon Glass6a1b2062015-03-25 12:22:02 -0600400#ifdef CONFIG_DM_USB
401 struct udevice *child;
402
403 for (device_find_first_child(dev->dev, &child);
404 child;
405 device_find_next_child(&child)) {
406 struct usb_device *udev;
407
408 if (!device_active(child))
409 continue;
410
Simon Glassbcbe3d12015-09-28 23:32:01 -0600411 udev = dev_get_parent_priv(child);
Simon Glass6a1b2062015-03-25 12:22:02 -0600412
413 /* Ignore emulators, we only want real devices */
414 if (device_get_uclass_id(child) != UCLASS_USB_EMUL) {
415 usb_show_tree_graph(udev, pre);
416 pre[index] = 0;
417 }
418 }
419#else
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100420 if (dev->maxchild > 0) {
421 for (i = 0; i < dev->maxchild; i++) {
422 if (dev->children[i] != NULL) {
423 usb_show_tree_graph(dev->children[i], pre);
424 pre[index] = 0;
wdenke887afc2002-08-27 09:44:07 +0000425 }
426 }
427 }
Simon Glass6a1b2062015-03-25 12:22:02 -0600428#endif
wdenke887afc2002-08-27 09:44:07 +0000429}
430
431/* main routine for the tree command */
Simon Glass45bfa472015-11-08 23:47:51 -0700432static void usb_show_subtree(struct usb_device *dev)
wdenke887afc2002-08-27 09:44:07 +0000433{
434 char preamble[32];
435
Simon Glasscad42912015-03-25 12:22:00 -0600436 memset(preamble, '\0', sizeof(preamble));
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100437 usb_show_tree_graph(dev, &preamble[0]);
wdenke887afc2002-08-27 09:44:07 +0000438}
439
Simon Glass45bfa472015-11-08 23:47:51 -0700440void usb_show_tree(void)
441{
442#ifdef CONFIG_DM_USB
443 struct udevice *bus;
444
445 for (uclass_first_device(UCLASS_USB, &bus);
446 bus;
447 uclass_next_device(&bus)) {
448 struct usb_device *udev;
449 struct udevice *dev;
450
451 device_find_first_child(bus, &dev);
452 if (dev && device_active(dev)) {
453 udev = dev_get_parent_priv(dev);
454 usb_show_subtree(udev);
455 }
456 }
457#else
458 struct usb_device *udev;
459 int i;
460
461 for (i = 0; i < USB_MAX_DEVICE; i++) {
462 udev = usb_get_dev_index(i);
463 if (udev == NULL)
464 break;
465 if (udev->parent == NULL)
466 usb_show_subtree(udev);
467 }
468#endif
469}
470
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000471static int usb_test(struct usb_device *dev, int port, char* arg)
472{
473 int mode;
474
475 if (port > dev->maxchild) {
476 printf("Device is no hub or does not have %d ports.\n", port);
477 return 1;
478 }
479
480 switch (arg[0]) {
481 case 'J':
482 case 'j':
483 printf("Setting Test_J mode");
484 mode = USB_TEST_MODE_J;
485 break;
486 case 'K':
487 case 'k':
488 printf("Setting Test_K mode");
489 mode = USB_TEST_MODE_K;
490 break;
491 case 'S':
492 case 's':
493 printf("Setting Test_SE0_NAK mode");
494 mode = USB_TEST_MODE_SE0_NAK;
495 break;
496 case 'P':
497 case 'p':
498 printf("Setting Test_Packet mode");
499 mode = USB_TEST_MODE_PACKET;
500 break;
501 case 'F':
502 case 'f':
503 printf("Setting Test_Force_Enable mode");
504 mode = USB_TEST_MODE_FORCE_ENABLE;
505 break;
506 default:
507 printf("Unrecognized test mode: %s\nAvailable modes: "
508 "J, K, S[E0_NAK], P[acket], F[orce_Enable]\n", arg);
509 return 1;
510 }
511
512 if (port)
513 printf(" on downstream facing port %d...\n", port);
514 else
515 printf(" on upstream facing port...\n");
516
517 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_FEATURE,
518 port ? USB_RT_PORT : USB_RECIP_DEVICE,
519 port ? USB_PORT_FEAT_TEST : USB_FEAT_TEST,
520 (mode << 8) | port,
521 NULL, 0, USB_CNTL_TIMEOUT) == -1) {
522 printf("Error during SET_FEATURE.\n");
523 return 1;
524 } else {
525 printf("Test mode successfully set. Use 'usb start' "
526 "to return to normal operation.\n");
527 return 0;
528 }
529}
530
wdenke887afc2002-08-27 09:44:07 +0000531
wdenke887afc2002-08-27 09:44:07 +0000532/******************************************************************************
533 * usb boot command intepreter. Derived from diskboot
534 */
535#ifdef CONFIG_USB_STORAGE
Kim Phillips088f1b12012-10-29 13:34:31 +0000536static int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenke887afc2002-08-27 09:44:07 +0000537{
Rob Herring7405a132012-09-21 04:02:30 +0000538 return common_diskboot(cmdtp, "usb", argc, argv);
wdenke887afc2002-08-27 09:44:07 +0000539}
540#endif /* CONFIG_USB_STORAGE */
541
Hans de Goede8a8a2252014-09-20 16:54:38 +0200542static int do_usb_stop_keyboard(int force)
Hans de Goede6e78c742014-09-20 16:54:35 +0200543{
544#ifdef CONFIG_USB_KEYBOARD
Hans de Goede8a8a2252014-09-20 16:54:38 +0200545 if (usb_kbd_deregister(force) != 0) {
Hans de Goede6e78c742014-09-20 16:54:35 +0200546 printf("USB not stopped: usbkbd still using USB\n");
547 return 1;
548 }
549#endif
550 return 0;
551}
wdenke887afc2002-08-27 09:44:07 +0000552
Hans de Goedeb5072262015-01-06 14:27:41 +0100553static void do_usb_start(void)
554{
555 bootstage_mark_name(BOOTSTAGE_ID_USB_START, "usb_start");
556
557 if (usb_init() < 0)
558 return;
559
Simon Glass6a1b2062015-03-25 12:22:02 -0600560 /* Driver model will probe the devices as they are found */
561#ifndef CONFIG_DM_USB
Simon Glass34ab37e2015-09-08 11:15:11 -0600562# ifdef CONFIG_USB_STORAGE
Hans de Goedeb5072262015-01-06 14:27:41 +0100563 /* try to recognize storage devices immediately */
564 usb_stor_curr_dev = usb_stor_scan(1);
Simon Glass34ab37e2015-09-08 11:15:11 -0600565# endif
566# ifdef CONFIG_USB_KEYBOARD
567 drv_usb_kbd_init();
568# endif
569#endif /* !CONFIG_DM_USB */
Hans de Goedeb5072262015-01-06 14:27:41 +0100570#ifdef CONFIG_USB_HOST_ETHER
Simon Glass69559092015-07-06 16:47:48 -0600571# ifdef CONFIG_DM_ETH
Marcel Ziswiler389f1852015-08-05 16:58:17 +0200572# ifndef CONFIG_DM_USB
573# error "You must use CONFIG_DM_USB if you want to use CONFIG_USB_HOST_ETHER with CONFIG_DM_ETH"
574# endif
575# else
Hans de Goedeb5072262015-01-06 14:27:41 +0100576 /* try to recognize ethernet devices immediately */
577 usb_ether_curr_dev = usb_host_eth_scan(1);
Marcel Ziswiler389f1852015-08-05 16:58:17 +0200578# endif
Simon Glass69559092015-07-06 16:47:48 -0600579#endif
Hans de Goedeb5072262015-01-06 14:27:41 +0100580}
581
Simon Glass6a1b2062015-03-25 12:22:02 -0600582#ifdef CONFIG_DM_USB
583static void show_info(struct udevice *dev)
584{
585 struct udevice *child;
586 struct usb_device *udev;
587
Simon Glassbcbe3d12015-09-28 23:32:01 -0600588 udev = dev_get_parent_priv(dev);
Simon Glass6a1b2062015-03-25 12:22:02 -0600589 usb_display_desc(udev);
590 usb_display_config(udev);
591 for (device_find_first_child(dev, &child);
592 child;
593 device_find_next_child(&child)) {
594 if (device_active(child))
595 show_info(child);
596 }
597}
598
599static int usb_device_info(void)
600{
601 struct udevice *bus;
602
603 for (uclass_first_device(UCLASS_USB, &bus);
604 bus;
605 uclass_next_device(&bus)) {
606 struct udevice *hub;
607
608 device_find_first_child(bus, &hub);
609 if (device_get_uclass_id(hub) == UCLASS_USB_HUB &&
610 device_active(hub)) {
611 show_info(hub);
612 }
613 }
614
615 return 0;
616}
617#endif
618
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100619/******************************************************************************
wdenke887afc2002-08-27 09:44:07 +0000620 * usb command intepreter
621 */
Kim Phillips088f1b12012-10-29 13:34:31 +0000622static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenke887afc2002-08-27 09:44:07 +0000623{
Simon Glasscad42912015-03-25 12:22:00 -0600624 struct usb_device *udev = NULL;
wdenke887afc2002-08-27 09:44:07 +0000625 int i;
Bartlomiej Siekae51aae32006-08-03 23:20:13 +0200626 extern char usb_started;
wdenk1968e612005-02-24 23:23:29 +0000627#ifdef CONFIG_USB_STORAGE
wdenke887afc2002-08-27 09:44:07 +0000628 block_dev_desc_t *stor_dev;
wdenk1968e612005-02-24 23:23:29 +0000629#endif
wdenke887afc2002-08-27 09:44:07 +0000630
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200631 if (argc < 2)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000632 return CMD_RET_USAGE;
Serge Ziryukin65d34252010-04-25 21:32:36 +0300633
Hans de Goedeb5072262015-01-06 14:27:41 +0100634 if (strncmp(argv[1], "start", 5) == 0) {
635 if (usb_started)
636 return 0; /* Already started */
637 printf("starting USB...\n");
638 do_usb_start();
639 return 0;
640 }
641
642 if (strncmp(argv[1], "reset", 5) == 0) {
643 printf("resetting USB...\n");
Hans de Goede8a8a2252014-09-20 16:54:38 +0200644 if (do_usb_stop_keyboard(1) != 0)
Hans de Goede6e78c742014-09-20 16:54:35 +0200645 return 1;
wdenke887afc2002-08-27 09:44:07 +0000646 usb_stop();
Hans de Goedeb5072262015-01-06 14:27:41 +0100647 do_usb_start();
wdenke887afc2002-08-27 09:44:07 +0000648 return 0;
649 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100650 if (strncmp(argv[1], "stop", 4) == 0) {
Hans de Goede6e78c742014-09-20 16:54:35 +0200651 if (argc != 2)
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100652 console_assign(stdin, "serial");
Hans de Goede8a8a2252014-09-20 16:54:38 +0200653 if (do_usb_stop_keyboard(0) != 0)
Hans de Goede6e78c742014-09-20 16:54:35 +0200654 return 1;
wdenke887afc2002-08-27 09:44:07 +0000655 printf("stopping USB..\n");
656 usb_stop();
657 return 0;
658 }
Bartlomiej Siekae51aae32006-08-03 23:20:13 +0200659 if (!usb_started) {
660 printf("USB is stopped. Please issue 'usb start' first.\n");
661 return 1;
662 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100663 if (strncmp(argv[1], "tree", 4) == 0) {
Lucas Stach93c25822012-09-26 00:14:36 +0200664 puts("USB device tree:\n");
Simon Glass45bfa472015-11-08 23:47:51 -0700665 usb_show_tree();
wdenke887afc2002-08-27 09:44:07 +0000666 return 0;
667 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100668 if (strncmp(argv[1], "inf", 3) == 0) {
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100669 if (argc == 2) {
Simon Glass6a1b2062015-03-25 12:22:02 -0600670#ifdef CONFIG_DM_USB
671 usb_device_info();
672#else
673 int d;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100674 for (d = 0; d < USB_MAX_DEVICE; d++) {
Simon Glasscad42912015-03-25 12:22:00 -0600675 udev = usb_get_dev_index(d);
676 if (udev == NULL)
wdenke887afc2002-08-27 09:44:07 +0000677 break;
Simon Glasscad42912015-03-25 12:22:00 -0600678 usb_display_desc(udev);
679 usb_display_config(udev);
wdenke887afc2002-08-27 09:44:07 +0000680 }
Simon Glass6a1b2062015-03-25 12:22:02 -0600681#endif
wdenke887afc2002-08-27 09:44:07 +0000682 return 0;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100683 } else {
Simon Glass6a1b2062015-03-25 12:22:02 -0600684 /*
685 * With driver model this isn't right since we can
686 * have multiple controllers and the device numbering
687 * starts at 1 on each bus.
688 */
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000689 i = simple_strtoul(argv[2], NULL, 10);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100690 printf("config for device %d\n", i);
Simon Glasscad42912015-03-25 12:22:00 -0600691 udev = usb_find_device(i);
692 if (udev == NULL) {
Loïc Minier6052cba2011-02-03 22:04:26 +0100693 printf("*** No device available ***\n");
wdenke887afc2002-08-27 09:44:07 +0000694 return 0;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100695 } else {
Simon Glasscad42912015-03-25 12:22:00 -0600696 usb_display_desc(udev);
697 usb_display_config(udev);
wdenke887afc2002-08-27 09:44:07 +0000698 }
699 }
700 return 0;
701 }
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000702 if (strncmp(argv[1], "test", 4) == 0) {
703 if (argc < 5)
704 return CMD_RET_USAGE;
705 i = simple_strtoul(argv[2], NULL, 10);
Simon Glasscad42912015-03-25 12:22:00 -0600706 udev = usb_find_device(i);
707 if (udev == NULL) {
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000708 printf("Device %d does not exist.\n", i);
709 return 1;
710 }
711 i = simple_strtoul(argv[3], NULL, 10);
Simon Glasscad42912015-03-25 12:22:00 -0600712 return usb_test(udev, i, argv[4]);
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000713 }
wdenke887afc2002-08-27 09:44:07 +0000714#ifdef CONFIG_USB_STORAGE
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100715 if (strncmp(argv[1], "stor", 4) == 0)
Aras Vaichasf6b44e02008-03-25 12:09:07 +1100716 return usb_stor_info();
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200717
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100718 if (strncmp(argv[1], "part", 4) == 0) {
Christian Eggersd4b5f3f2008-06-27 19:46:51 +0200719 int devno, ok = 0;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100720 if (argc == 2) {
Kim B. Heinoaaad1082010-03-12 15:46:56 +0200721 for (devno = 0; ; ++devno) {
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100722 stor_dev = usb_stor_get_dev(devno);
Kim B. Heinoaaad1082010-03-12 15:46:56 +0200723 if (stor_dev == NULL)
724 break;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100725 if (stor_dev->type != DEV_TYPE_UNKNOWN) {
Christian Eggersd4b5f3f2008-06-27 19:46:51 +0200726 ok++;
727 if (devno)
728 printf("\n");
Wolfgang Denk060f2852010-03-25 14:07:23 +0100729 debug("print_part of %x\n", devno);
Christian Eggersd4b5f3f2008-06-27 19:46:51 +0200730 print_part(stor_dev);
731 }
732 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100733 } else {
734 devno = simple_strtoul(argv[2], NULL, 16);
735 stor_dev = usb_stor_get_dev(devno);
Kim B. Heinoaaad1082010-03-12 15:46:56 +0200736 if (stor_dev != NULL &&
737 stor_dev->type != DEV_TYPE_UNKNOWN) {
wdenke887afc2002-08-27 09:44:07 +0000738 ok++;
Wolfgang Denk060f2852010-03-25 14:07:23 +0100739 debug("print_part of %x\n", devno);
wdenke887afc2002-08-27 09:44:07 +0000740 print_part(stor_dev);
741 }
742 }
743 if (!ok) {
744 printf("\nno USB devices available\n");
745 return 1;
746 }
747 return 0;
748 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100749 if (strcmp(argv[1], "read") == 0) {
750 if (usb_stor_curr_dev < 0) {
wdenke887afc2002-08-27 09:44:07 +0000751 printf("no current device selected\n");
752 return 1;
753 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100754 if (argc == 5) {
wdenke887afc2002-08-27 09:44:07 +0000755 unsigned long addr = simple_strtoul(argv[2], NULL, 16);
756 unsigned long blk = simple_strtoul(argv[3], NULL, 16);
757 unsigned long cnt = simple_strtoul(argv[4], NULL, 16);
758 unsigned long n;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100759 printf("\nUSB read: device %d block # %ld, count %ld"
760 " ... ", usb_stor_curr_dev, blk, cnt);
761 stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
Stephen Warren7c4213f2015-12-07 11:38:48 -0700762 n = stor_dev->block_read(stor_dev, blk, cnt,
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100763 (ulong *)addr);
764 printf("%ld blocks read: %s\n", n,
765 (n == cnt) ? "OK" : "ERROR");
766 if (n == cnt)
wdenke887afc2002-08-27 09:44:07 +0000767 return 0;
768 return 1;
769 }
770 }
Mahavir Jain127e1082009-11-03 12:22:10 +0530771 if (strcmp(argv[1], "write") == 0) {
772 if (usb_stor_curr_dev < 0) {
773 printf("no current device selected\n");
774 return 1;
775 }
776 if (argc == 5) {
777 unsigned long addr = simple_strtoul(argv[2], NULL, 16);
778 unsigned long blk = simple_strtoul(argv[3], NULL, 16);
779 unsigned long cnt = simple_strtoul(argv[4], NULL, 16);
780 unsigned long n;
781 printf("\nUSB write: device %d block # %ld, count %ld"
782 " ... ", usb_stor_curr_dev, blk, cnt);
783 stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
Stephen Warren7c4213f2015-12-07 11:38:48 -0700784 n = stor_dev->block_write(stor_dev, blk, cnt,
Mahavir Jain127e1082009-11-03 12:22:10 +0530785 (ulong *)addr);
786 printf("%ld blocks write: %s\n", n,
787 (n == cnt) ? "OK" : "ERROR");
788 if (n == cnt)
789 return 0;
790 return 1;
791 }
792 }
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200793 if (strncmp(argv[1], "dev", 3) == 0) {
794 if (argc == 3) {
wdenke887afc2002-08-27 09:44:07 +0000795 int dev = (int)simple_strtoul(argv[2], NULL, 10);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100796 printf("\nUSB device %d: ", dev);
Kim B. Heinoaaad1082010-03-12 15:46:56 +0200797 stor_dev = usb_stor_get_dev(dev);
798 if (stor_dev == NULL) {
wdenke887afc2002-08-27 09:44:07 +0000799 printf("unknown device\n");
800 return 1;
801 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100802 printf("\n Device %d: ", dev);
wdenke887afc2002-08-27 09:44:07 +0000803 dev_print(stor_dev);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100804 if (stor_dev->type == DEV_TYPE_UNKNOWN)
wdenke887afc2002-08-27 09:44:07 +0000805 return 1;
wdenke887afc2002-08-27 09:44:07 +0000806 usb_stor_curr_dev = dev;
807 printf("... is now current device\n");
808 return 0;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100809 } else {
810 printf("\nUSB device %d: ", usb_stor_curr_dev);
811 stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
wdenke887afc2002-08-27 09:44:07 +0000812 dev_print(stor_dev);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100813 if (stor_dev->type == DEV_TYPE_UNKNOWN)
wdenke887afc2002-08-27 09:44:07 +0000814 return 1;
wdenke887afc2002-08-27 09:44:07 +0000815 return 0;
816 }
817 return 0;
818 }
819#endif /* CONFIG_USB_STORAGE */
Simon Glass4c12eeb2011-12-10 08:44:01 +0000820 return CMD_RET_USAGE;
wdenke887afc2002-08-27 09:44:07 +0000821}
822
wdenk0d498392003-07-01 21:06:45 +0000823U_BOOT_CMD(
824 usb, 5, 1, do_usb,
Peter Tyser2fb26042009-01-27 18:03:12 -0600825 "USB sub-system",
Veli-Pekka Peltola1af9f962011-11-02 16:59:56 +0200826 "start - start (scan) USB controller\n"
827 "usb reset - reset (rescan) USB controller\n"
Veli-Pekka Peltolab3813a22011-11-02 16:59:55 +0200828 "usb stop [f] - stop USB [f]=force stop\n"
829 "usb tree - show USB device tree\n"
wdenk5cf91d62004-04-23 20:32:05 +0000830 "usb info [dev] - show available USB devices\n"
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000831 "usb test [dev] [port] [mode] - set USB 2.0 test mode\n"
832 " (specify port 0 to indicate the device's upstream port)\n"
833 " Available modes: J, K, S[E0_NAK], P[acket], F[orce_Enable]\n"
834#ifdef CONFIG_USB_STORAGE
Veli-Pekka Peltolab3813a22011-11-02 16:59:55 +0200835 "usb storage - show details of USB storage devices\n"
wdenk342717f2005-06-27 13:30:03 +0000836 "usb dev [dev] - show or set current USB storage device\n"
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100837 "usb part [dev] - print partition table of one or all USB storage"
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000838 " devices\n"
wdenk5cf91d62004-04-23 20:32:05 +0000839 "usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n"
Sergei Poselenov842404e2010-08-09 16:01:42 +0400840 " to memory address `addr'\n"
Mahavir Jain127e1082009-11-03 12:22:10 +0530841 "usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'\n"
842 " from memory address `addr'"
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000843#endif /* CONFIG_USB_STORAGE */
wdenk8bde7f72003-06-27 21:31:46 +0000844);
845
846
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000847#ifdef CONFIG_USB_STORAGE
wdenk0d498392003-07-01 21:06:45 +0000848U_BOOT_CMD(
849 usbboot, 3, 1, do_usbboot,
Peter Tyser2fb26042009-01-27 18:03:12 -0600850 "boot from USB device",
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200851 "loadAddr dev:part"
wdenk8bde7f72003-06-27 21:31:46 +0000852);
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000853#endif /* CONFIG_USB_STORAGE */