blob: 58d9db29d73ab151e85c37915bedabea59f10fba [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>
Hans de Goede192eab92016-04-03 00:04:39 +020018#include <dm/uclass-internal.h>
Simon Glasscf92e052015-09-02 17:24:58 -060019#include <memalign.h>
wdenk414eec32005-04-02 22:37:54 +000020#include <asm/byteorder.h>
Tom Rinib2fb47f2011-12-15 08:40:51 -070021#include <asm/unaligned.h>
Grant Likely735dd972007-02-20 09:04:34 +010022#include <part.h>
wdenke887afc2002-08-27 09:44:07 +000023#include <usb.h>
wdenke887afc2002-08-27 09:44:07 +000024
wdenk1968e612005-02-24 23:23:29 +000025#ifdef CONFIG_USB_STORAGE
Wolfgang Denkd0ff51b2008-07-14 15:19:07 +020026static int usb_stor_curr_dev = -1; /* current device */
wdenk1968e612005-02-24 23:23:29 +000027#endif
Simon Glassc8c27972015-07-06 16:47:50 -060028#if defined(CONFIG_USB_HOST_ETHER) && !defined(CONFIG_DM_ETH)
Simon Glass69559092015-07-06 16:47:48 -060029static int __maybe_unused usb_ether_curr_dev = -1; /* current ethernet device */
Simon Glass89d48362011-02-16 11:14:33 -080030#endif
wdenke887afc2002-08-27 09:44:07 +000031
wdenka2663ea2003-12-07 18:32:37 +000032/* some display routines (info command) */
Kim Phillips088f1b12012-10-29 13:34:31 +000033static char *usb_get_class_desc(unsigned char dclass)
wdenke887afc2002-08-27 09:44:07 +000034{
Michael Trimarchide39f8c2008-11-26 17:41:34 +010035 switch (dclass) {
36 case USB_CLASS_PER_INTERFACE:
37 return "See Interface";
38 case USB_CLASS_AUDIO:
39 return "Audio";
40 case USB_CLASS_COMM:
41 return "Communication";
42 case USB_CLASS_HID:
43 return "Human Interface";
44 case USB_CLASS_PRINTER:
45 return "Printer";
46 case USB_CLASS_MASS_STORAGE:
47 return "Mass Storage";
48 case USB_CLASS_HUB:
49 return "Hub";
50 case USB_CLASS_DATA:
51 return "CDC Data";
52 case USB_CLASS_VENDOR_SPEC:
53 return "Vendor specific";
54 default:
55 return "";
wdenke887afc2002-08-27 09:44:07 +000056 }
57}
58
Kim Phillips088f1b12012-10-29 13:34:31 +000059static void usb_display_class_sub(unsigned char dclass, unsigned char subclass,
60 unsigned char proto)
wdenke887afc2002-08-27 09:44:07 +000061{
Michael Trimarchide39f8c2008-11-26 17:41:34 +010062 switch (dclass) {
63 case USB_CLASS_PER_INTERFACE:
64 printf("See Interface");
65 break;
66 case USB_CLASS_HID:
67 printf("Human Interface, Subclass: ");
68 switch (subclass) {
69 case USB_SUB_HID_NONE:
70 printf("None");
wdenke887afc2002-08-27 09:44:07 +000071 break;
Michael Trimarchide39f8c2008-11-26 17:41:34 +010072 case USB_SUB_HID_BOOT:
73 printf("Boot ");
74 switch (proto) {
75 case USB_PROT_HID_NONE:
76 printf("None");
77 break;
78 case USB_PROT_HID_KEYBOARD:
79 printf("Keyboard");
80 break;
81 case USB_PROT_HID_MOUSE:
82 printf("Mouse");
83 break;
84 default:
85 printf("reserved");
86 break;
wdenke887afc2002-08-27 09:44:07 +000087 }
88 break;
89 default:
Michael Trimarchide39f8c2008-11-26 17:41:34 +010090 printf("reserved");
91 break;
92 }
93 break;
94 case USB_CLASS_MASS_STORAGE:
95 printf("Mass Storage, ");
96 switch (subclass) {
97 case US_SC_RBC:
98 printf("RBC ");
99 break;
100 case US_SC_8020:
101 printf("SFF-8020i (ATAPI)");
102 break;
103 case US_SC_QIC:
104 printf("QIC-157 (Tape)");
105 break;
106 case US_SC_UFI:
107 printf("UFI");
108 break;
109 case US_SC_8070:
110 printf("SFF-8070");
111 break;
112 case US_SC_SCSI:
113 printf("Transp. SCSI");
114 break;
115 default:
116 printf("reserved");
117 break;
118 }
119 printf(", ");
120 switch (proto) {
121 case US_PR_CB:
122 printf("Command/Bulk");
123 break;
124 case US_PR_CBI:
125 printf("Command/Bulk/Int");
126 break;
127 case US_PR_BULK:
128 printf("Bulk only");
129 break;
130 default:
131 printf("reserved");
132 break;
133 }
134 break;
135 default:
136 printf("%s", usb_get_class_desc(dclass));
137 break;
wdenke887afc2002-08-27 09:44:07 +0000138 }
139}
140
Kim Phillips088f1b12012-10-29 13:34:31 +0000141static void usb_display_string(struct usb_device *dev, int index)
wdenke887afc2002-08-27 09:44:07 +0000142{
Puneet Saxenaf5766132012-04-03 14:56:06 +0530143 ALLOC_CACHE_ALIGN_BUFFER(char, buffer, 256);
144
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100145 if (index != 0) {
146 if (usb_string(dev, index, &buffer[0], 256) > 0)
147 printf("String: \"%s\"", buffer);
wdenke887afc2002-08-27 09:44:07 +0000148 }
149}
150
Kim Phillips088f1b12012-10-29 13:34:31 +0000151static void usb_display_desc(struct usb_device *dev)
wdenke887afc2002-08-27 09:44:07 +0000152{
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100153 if (dev->descriptor.bDescriptorType == USB_DT_DEVICE) {
154 printf("%d: %s, USB Revision %x.%x\n", dev->devnum,
Tom Rix8f8bd562009-10-31 12:37:38 -0500155 usb_get_class_desc(dev->config.if_desc[0].desc.bInterfaceClass),
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100156 (dev->descriptor.bcdUSB>>8) & 0xff,
157 dev->descriptor.bcdUSB & 0xff);
158
159 if (strlen(dev->mf) || strlen(dev->prod) ||
160 strlen(dev->serial))
161 printf(" - %s %s %s\n", dev->mf, dev->prod,
162 dev->serial);
wdenke887afc2002-08-27 09:44:07 +0000163 if (dev->descriptor.bDeviceClass) {
164 printf(" - Class: ");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100165 usb_display_class_sub(dev->descriptor.bDeviceClass,
166 dev->descriptor.bDeviceSubClass,
167 dev->descriptor.bDeviceProtocol);
wdenke887afc2002-08-27 09:44:07 +0000168 printf("\n");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100169 } else {
170 printf(" - Class: (from Interface) %s\n",
171 usb_get_class_desc(
Tom Rix8f8bd562009-10-31 12:37:38 -0500172 dev->config.if_desc[0].desc.bInterfaceClass));
wdenke887afc2002-08-27 09:44:07 +0000173 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100174 printf(" - PacketSize: %d Configurations: %d\n",
175 dev->descriptor.bMaxPacketSize0,
176 dev->descriptor.bNumConfigurations);
177 printf(" - Vendor: 0x%04x Product 0x%04x Version %d.%d\n",
178 dev->descriptor.idVendor, dev->descriptor.idProduct,
179 (dev->descriptor.bcdDevice>>8) & 0xff,
180 dev->descriptor.bcdDevice & 0xff);
wdenke887afc2002-08-27 09:44:07 +0000181 }
182
183}
184
Ilya Yanokc60795f2012-11-06 13:48:20 +0000185static void usb_display_conf_desc(struct usb_config_descriptor *config,
Kim Phillips088f1b12012-10-29 13:34:31 +0000186 struct usb_device *dev)
wdenke887afc2002-08-27 09:44:07 +0000187{
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100188 printf(" Configuration: %d\n", config->bConfigurationValue);
189 printf(" - Interfaces: %d %s%s%dmA\n", config->bNumInterfaces,
190 (config->bmAttributes & 0x40) ? "Self Powered " : "Bus Powered ",
191 (config->bmAttributes & 0x20) ? "Remote Wakeup " : "",
Tom Rix8f8bd562009-10-31 12:37:38 -0500192 config->bMaxPower*2);
wdenke887afc2002-08-27 09:44:07 +0000193 if (config->iConfiguration) {
194 printf(" - ");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100195 usb_display_string(dev, config->iConfiguration);
wdenke887afc2002-08-27 09:44:07 +0000196 printf("\n");
197 }
198}
199
Kim Phillips088f1b12012-10-29 13:34:31 +0000200static void usb_display_if_desc(struct usb_interface_descriptor *ifdesc,
201 struct usb_device *dev)
wdenke887afc2002-08-27 09:44:07 +0000202{
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100203 printf(" Interface: %d\n", ifdesc->bInterfaceNumber);
204 printf(" - Alternate Setting %d, Endpoints: %d\n",
205 ifdesc->bAlternateSetting, ifdesc->bNumEndpoints);
wdenke887afc2002-08-27 09:44:07 +0000206 printf(" - Class ");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100207 usb_display_class_sub(ifdesc->bInterfaceClass,
208 ifdesc->bInterfaceSubClass, ifdesc->bInterfaceProtocol);
wdenke887afc2002-08-27 09:44:07 +0000209 printf("\n");
210 if (ifdesc->iInterface) {
211 printf(" - ");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100212 usb_display_string(dev, ifdesc->iInterface);
wdenke887afc2002-08-27 09:44:07 +0000213 printf("\n");
214 }
215}
216
Kim Phillips088f1b12012-10-29 13:34:31 +0000217static void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc)
wdenke887afc2002-08-27 09:44:07 +0000218{
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100219 printf(" - Endpoint %d %s ", epdesc->bEndpointAddress & 0xf,
220 (epdesc->bEndpointAddress & 0x80) ? "In" : "Out");
221 switch ((epdesc->bmAttributes & 0x03)) {
222 case 0:
223 printf("Control");
224 break;
225 case 1:
226 printf("Isochronous");
227 break;
228 case 2:
229 printf("Bulk");
230 break;
231 case 3:
232 printf("Interrupt");
233 break;
wdenke887afc2002-08-27 09:44:07 +0000234 }
Tom Rinib2fb47f2011-12-15 08:40:51 -0700235 printf(" MaxPacket %d", get_unaligned(&epdesc->wMaxPacketSize));
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100236 if ((epdesc->bmAttributes & 0x03) == 0x3)
237 printf(" Interval %dms", epdesc->bInterval);
wdenke887afc2002-08-27 09:44:07 +0000238 printf("\n");
239}
240
241/* main routine to diasplay the configs, interfaces and endpoints */
Kim Phillips088f1b12012-10-29 13:34:31 +0000242static void usb_display_config(struct usb_device *dev)
wdenke887afc2002-08-27 09:44:07 +0000243{
Tom Rix8f8bd562009-10-31 12:37:38 -0500244 struct usb_config *config;
245 struct usb_interface *ifdesc;
wdenke887afc2002-08-27 09:44:07 +0000246 struct usb_endpoint_descriptor *epdesc;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100247 int i, ii;
wdenke887afc2002-08-27 09:44:07 +0000248
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100249 config = &dev->config;
Tom Rix8f8bd562009-10-31 12:37:38 -0500250 usb_display_conf_desc(&config->desc, dev);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100251 for (i = 0; i < config->no_of_if; i++) {
252 ifdesc = &config->if_desc[i];
Tom Rix8f8bd562009-10-31 12:37:38 -0500253 usb_display_if_desc(&ifdesc->desc, dev);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100254 for (ii = 0; ii < ifdesc->no_of_ep; ii++) {
255 epdesc = &ifdesc->ep_desc[ii];
wdenke887afc2002-08-27 09:44:07 +0000256 usb_display_ep_desc(epdesc);
257 }
258 }
259 printf("\n");
260}
261
Simon Glass6a1b2062015-03-25 12:22:02 -0600262/*
263 * With driver model this isn't right since we can have multiple controllers
264 * and the device numbering starts at 1 on each bus.
265 * TODO(sjg@chromium.org): Add a way to specify the controller/bus.
266 */
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000267static struct usb_device *usb_find_device(int devnum)
268{
Simon Glass6a1b2062015-03-25 12:22:02 -0600269#ifdef CONFIG_DM_USB
270 struct usb_device *udev;
271 struct udevice *hub;
272 struct uclass *uc;
273 int ret;
274
275 /* Device addresses start at 1 */
276 devnum++;
277 ret = uclass_get(UCLASS_USB_HUB, &uc);
278 if (ret)
279 return NULL;
280
281 uclass_foreach_dev(hub, uc) {
282 struct udevice *dev;
283
284 if (!device_active(hub))
285 continue;
Simon Glassbcbe3d12015-09-28 23:32:01 -0600286 udev = dev_get_parent_priv(hub);
Simon Glass6a1b2062015-03-25 12:22:02 -0600287 if (udev->devnum == devnum)
288 return udev;
289
290 for (device_find_first_child(hub, &dev);
291 dev;
292 device_find_next_child(&dev)) {
293 if (!device_active(hub))
294 continue;
295
Simon Glassbcbe3d12015-09-28 23:32:01 -0600296 udev = dev_get_parent_priv(dev);
Simon Glass6a1b2062015-03-25 12:22:02 -0600297 if (udev->devnum == devnum)
298 return udev;
299 }
300 }
301#else
Simon Glasscad42912015-03-25 12:22:00 -0600302 struct usb_device *udev;
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000303 int d;
304
305 for (d = 0; d < USB_MAX_DEVICE; d++) {
Simon Glasscad42912015-03-25 12:22:00 -0600306 udev = usb_get_dev_index(d);
307 if (udev == NULL)
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000308 return NULL;
Simon Glasscad42912015-03-25 12:22:00 -0600309 if (udev->devnum == devnum)
310 return udev;
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000311 }
Simon Glass6a1b2062015-03-25 12:22:02 -0600312#endif
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000313
314 return NULL;
315}
316
Stefan Roesef1c1f542009-01-22 10:11:21 +0100317static inline char *portspeed(int speed)
318{
Vivek Gautam6497c662013-04-12 16:34:38 +0530319 char *speed_str;
320
321 switch (speed) {
322 case USB_SPEED_SUPER:
323 speed_str = "5 Gb/s";
324 break;
325 case USB_SPEED_HIGH:
326 speed_str = "480 Mb/s";
327 break;
328 case USB_SPEED_LOW:
329 speed_str = "1.5 Mb/s";
330 break;
331 default:
332 speed_str = "12 Mb/s";
333 break;
334 }
335
336 return speed_str;
Stefan Roesef1c1f542009-01-22 10:11:21 +0100337}
338
wdenke887afc2002-08-27 09:44:07 +0000339/* shows the device tree recursively */
Kim Phillips088f1b12012-10-29 13:34:31 +0000340static void usb_show_tree_graph(struct usb_device *dev, char *pre)
wdenke887afc2002-08-27 09:44:07 +0000341{
Simon Glass6a1b2062015-03-25 12:22:02 -0600342 int index;
Wolfgang Denk10f4dd72011-10-05 23:01:59 +0200343 int has_child, last_child;
wdenke887afc2002-08-27 09:44:07 +0000344
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100345 index = strlen(pre);
346 printf(" %s", pre);
Simon Glass6a1b2062015-03-25 12:22:02 -0600347#ifdef CONFIG_DM_USB
348 has_child = device_has_active_children(dev->dev);
349#else
wdenke887afc2002-08-27 09:44:07 +0000350 /* check if the device has connected children */
Simon Glass6a1b2062015-03-25 12:22:02 -0600351 int i;
352
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100353 has_child = 0;
354 for (i = 0; i < dev->maxchild; i++) {
355 if (dev->children[i] != NULL)
356 has_child = 1;
wdenke887afc2002-08-27 09:44:07 +0000357 }
Simon Glass6a1b2062015-03-25 12:22:02 -0600358#endif
wdenke887afc2002-08-27 09:44:07 +0000359 /* check if we are the last one */
Simon Glass6a1b2062015-03-25 12:22:02 -0600360#ifdef CONFIG_DM_USB
Hans de Goedec27b3292015-06-17 21:33:50 +0200361 /* Not the root of the usb tree? */
362 if (device_get_uclass_id(dev->dev->parent) != UCLASS_USB) {
363 last_child = device_is_last_sibling(dev->dev);
Simon Glass6a1b2062015-03-25 12:22:02 -0600364#else
Hans de Goedec27b3292015-06-17 21:33:50 +0200365 if (dev->parent != NULL) { /* not root? */
366 last_child = 1;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100367 for (i = 0; i < dev->parent->maxchild; i++) {
wdenke887afc2002-08-27 09:44:07 +0000368 /* search for children */
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100369 if (dev->parent->children[i] == dev) {
370 /* found our pointer, see if we have a
371 * little sister
372 */
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100373 while (i++ < dev->parent->maxchild) {
374 if (dev->parent->children[i] != NULL) {
wdenke887afc2002-08-27 09:44:07 +0000375 /* found a sister */
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100376 last_child = 0;
wdenke887afc2002-08-27 09:44:07 +0000377 break;
378 } /* if */
379 } /* while */
380 } /* device found */
381 } /* for all children of the parent */
Simon Glass6a1b2062015-03-25 12:22:02 -0600382#endif
wdenke887afc2002-08-27 09:44:07 +0000383 printf("\b+-");
384 /* correct last child */
Simon Glasscad42912015-03-25 12:22:00 -0600385 if (last_child && index)
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100386 pre[index-1] = ' ';
wdenke887afc2002-08-27 09:44:07 +0000387 } /* if not root hub */
388 else
389 printf(" ");
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100390 printf("%d ", dev->devnum);
391 pre[index++] = ' ';
392 pre[index++] = has_child ? '|' : ' ';
393 pre[index] = 0;
394 printf(" %s (%s, %dmA)\n", usb_get_class_desc(
Tom Rix8f8bd562009-10-31 12:37:38 -0500395 dev->config.if_desc[0].desc.bInterfaceClass),
Stefan Roesef1c1f542009-01-22 10:11:21 +0100396 portspeed(dev->speed),
Tom Rix8f8bd562009-10-31 12:37:38 -0500397 dev->config.desc.bMaxPower * 2);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100398 if (strlen(dev->mf) || strlen(dev->prod) || strlen(dev->serial))
399 printf(" %s %s %s %s\n", pre, dev->mf, dev->prod, dev->serial);
400 printf(" %s\n", pre);
Simon Glass6a1b2062015-03-25 12:22:02 -0600401#ifdef CONFIG_DM_USB
402 struct udevice *child;
403
404 for (device_find_first_child(dev->dev, &child);
405 child;
406 device_find_next_child(&child)) {
407 struct usb_device *udev;
408
409 if (!device_active(child))
410 continue;
411
Simon Glassbcbe3d12015-09-28 23:32:01 -0600412 udev = dev_get_parent_priv(child);
Simon Glass6a1b2062015-03-25 12:22:02 -0600413
414 /* Ignore emulators, we only want real devices */
415 if (device_get_uclass_id(child) != UCLASS_USB_EMUL) {
416 usb_show_tree_graph(udev, pre);
417 pre[index] = 0;
418 }
419 }
420#else
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100421 if (dev->maxchild > 0) {
422 for (i = 0; i < dev->maxchild; i++) {
423 if (dev->children[i] != NULL) {
424 usb_show_tree_graph(dev->children[i], pre);
425 pre[index] = 0;
wdenke887afc2002-08-27 09:44:07 +0000426 }
427 }
428 }
Simon Glass6a1b2062015-03-25 12:22:02 -0600429#endif
wdenke887afc2002-08-27 09:44:07 +0000430}
431
432/* main routine for the tree command */
Simon Glass45bfa472015-11-08 23:47:51 -0700433static void usb_show_subtree(struct usb_device *dev)
wdenke887afc2002-08-27 09:44:07 +0000434{
435 char preamble[32];
436
Simon Glasscad42912015-03-25 12:22:00 -0600437 memset(preamble, '\0', sizeof(preamble));
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100438 usb_show_tree_graph(dev, &preamble[0]);
wdenke887afc2002-08-27 09:44:07 +0000439}
440
Simon Glass45bfa472015-11-08 23:47:51 -0700441void usb_show_tree(void)
442{
443#ifdef CONFIG_DM_USB
444 struct udevice *bus;
445
Hans de Goede192eab92016-04-03 00:04:39 +0200446 for (uclass_find_first_device(UCLASS_USB, &bus);
Simon Glass45bfa472015-11-08 23:47:51 -0700447 bus;
Hans de Goede192eab92016-04-03 00:04:39 +0200448 uclass_find_next_device(&bus)) {
Simon Glass45bfa472015-11-08 23:47:51 -0700449 struct usb_device *udev;
450 struct udevice *dev;
451
Hans de Goede192eab92016-04-03 00:04:39 +0200452 if (!device_active(bus))
453 continue;
454
Simon Glass45bfa472015-11-08 23:47:51 -0700455 device_find_first_child(bus, &dev);
456 if (dev && device_active(dev)) {
457 udev = dev_get_parent_priv(dev);
458 usb_show_subtree(udev);
459 }
460 }
461#else
462 struct usb_device *udev;
463 int i;
464
465 for (i = 0; i < USB_MAX_DEVICE; i++) {
466 udev = usb_get_dev_index(i);
467 if (udev == NULL)
468 break;
469 if (udev->parent == NULL)
470 usb_show_subtree(udev);
471 }
472#endif
473}
474
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000475static int usb_test(struct usb_device *dev, int port, char* arg)
476{
477 int mode;
478
479 if (port > dev->maxchild) {
480 printf("Device is no hub or does not have %d ports.\n", port);
481 return 1;
482 }
483
484 switch (arg[0]) {
485 case 'J':
486 case 'j':
487 printf("Setting Test_J mode");
488 mode = USB_TEST_MODE_J;
489 break;
490 case 'K':
491 case 'k':
492 printf("Setting Test_K mode");
493 mode = USB_TEST_MODE_K;
494 break;
495 case 'S':
496 case 's':
497 printf("Setting Test_SE0_NAK mode");
498 mode = USB_TEST_MODE_SE0_NAK;
499 break;
500 case 'P':
501 case 'p':
502 printf("Setting Test_Packet mode");
503 mode = USB_TEST_MODE_PACKET;
504 break;
505 case 'F':
506 case 'f':
507 printf("Setting Test_Force_Enable mode");
508 mode = USB_TEST_MODE_FORCE_ENABLE;
509 break;
510 default:
511 printf("Unrecognized test mode: %s\nAvailable modes: "
512 "J, K, S[E0_NAK], P[acket], F[orce_Enable]\n", arg);
513 return 1;
514 }
515
516 if (port)
517 printf(" on downstream facing port %d...\n", port);
518 else
519 printf(" on upstream facing port...\n");
520
521 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_FEATURE,
522 port ? USB_RT_PORT : USB_RECIP_DEVICE,
523 port ? USB_PORT_FEAT_TEST : USB_FEAT_TEST,
524 (mode << 8) | port,
525 NULL, 0, USB_CNTL_TIMEOUT) == -1) {
526 printf("Error during SET_FEATURE.\n");
527 return 1;
528 } else {
529 printf("Test mode successfully set. Use 'usb start' "
530 "to return to normal operation.\n");
531 return 0;
532 }
533}
534
wdenke887afc2002-08-27 09:44:07 +0000535
wdenke887afc2002-08-27 09:44:07 +0000536/******************************************************************************
537 * usb boot command intepreter. Derived from diskboot
538 */
539#ifdef CONFIG_USB_STORAGE
Kim Phillips088f1b12012-10-29 13:34:31 +0000540static int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenke887afc2002-08-27 09:44:07 +0000541{
Rob Herring7405a132012-09-21 04:02:30 +0000542 return common_diskboot(cmdtp, "usb", argc, argv);
wdenke887afc2002-08-27 09:44:07 +0000543}
544#endif /* CONFIG_USB_STORAGE */
545
Hans de Goede8a8a2252014-09-20 16:54:38 +0200546static int do_usb_stop_keyboard(int force)
Hans de Goede6e78c742014-09-20 16:54:35 +0200547{
Hans de Goede9a80e712016-04-03 09:18:53 +0200548#if !defined CONFIG_DM_USB && defined CONFIG_USB_KEYBOARD
Hans de Goede8a8a2252014-09-20 16:54:38 +0200549 if (usb_kbd_deregister(force) != 0) {
Hans de Goede6e78c742014-09-20 16:54:35 +0200550 printf("USB not stopped: usbkbd still using USB\n");
551 return 1;
552 }
553#endif
554 return 0;
555}
wdenke887afc2002-08-27 09:44:07 +0000556
Hans de Goedeb5072262015-01-06 14:27:41 +0100557static void do_usb_start(void)
558{
559 bootstage_mark_name(BOOTSTAGE_ID_USB_START, "usb_start");
560
561 if (usb_init() < 0)
562 return;
563
Simon Glass6a1b2062015-03-25 12:22:02 -0600564 /* Driver model will probe the devices as they are found */
565#ifndef CONFIG_DM_USB
Simon Glass34ab37e2015-09-08 11:15:11 -0600566# ifdef CONFIG_USB_STORAGE
Hans de Goedeb5072262015-01-06 14:27:41 +0100567 /* try to recognize storage devices immediately */
568 usb_stor_curr_dev = usb_stor_scan(1);
Simon Glass34ab37e2015-09-08 11:15:11 -0600569# endif
570# ifdef CONFIG_USB_KEYBOARD
571 drv_usb_kbd_init();
572# endif
573#endif /* !CONFIG_DM_USB */
Hans de Goedeb5072262015-01-06 14:27:41 +0100574#ifdef CONFIG_USB_HOST_ETHER
Simon Glass69559092015-07-06 16:47:48 -0600575# ifdef CONFIG_DM_ETH
Marcel Ziswiler389f1852015-08-05 16:58:17 +0200576# ifndef CONFIG_DM_USB
577# error "You must use CONFIG_DM_USB if you want to use CONFIG_USB_HOST_ETHER with CONFIG_DM_ETH"
578# endif
579# else
Hans de Goedeb5072262015-01-06 14:27:41 +0100580 /* try to recognize ethernet devices immediately */
581 usb_ether_curr_dev = usb_host_eth_scan(1);
Marcel Ziswiler389f1852015-08-05 16:58:17 +0200582# endif
Simon Glass69559092015-07-06 16:47:48 -0600583#endif
Hans de Goedeb5072262015-01-06 14:27:41 +0100584}
585
Simon Glass6a1b2062015-03-25 12:22:02 -0600586#ifdef CONFIG_DM_USB
587static void show_info(struct udevice *dev)
588{
589 struct udevice *child;
590 struct usb_device *udev;
591
Simon Glassbcbe3d12015-09-28 23:32:01 -0600592 udev = dev_get_parent_priv(dev);
Simon Glass6a1b2062015-03-25 12:22:02 -0600593 usb_display_desc(udev);
594 usb_display_config(udev);
595 for (device_find_first_child(dev, &child);
596 child;
597 device_find_next_child(&child)) {
598 if (device_active(child))
599 show_info(child);
600 }
601}
602
603static int usb_device_info(void)
604{
605 struct udevice *bus;
606
607 for (uclass_first_device(UCLASS_USB, &bus);
608 bus;
609 uclass_next_device(&bus)) {
610 struct udevice *hub;
611
612 device_find_first_child(bus, &hub);
613 if (device_get_uclass_id(hub) == UCLASS_USB_HUB &&
614 device_active(hub)) {
615 show_info(hub);
616 }
617 }
618
619 return 0;
620}
621#endif
622
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100623/******************************************************************************
wdenke887afc2002-08-27 09:44:07 +0000624 * usb command intepreter
625 */
Kim Phillips088f1b12012-10-29 13:34:31 +0000626static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenke887afc2002-08-27 09:44:07 +0000627{
Simon Glasscad42912015-03-25 12:22:00 -0600628 struct usb_device *udev = NULL;
wdenke887afc2002-08-27 09:44:07 +0000629 int i;
Bartlomiej Siekae51aae32006-08-03 23:20:13 +0200630 extern char usb_started;
wdenk1968e612005-02-24 23:23:29 +0000631#ifdef CONFIG_USB_STORAGE
Simon Glass4101f682016-02-29 15:25:34 -0700632 struct blk_desc *stor_dev;
wdenk1968e612005-02-24 23:23:29 +0000633#endif
wdenke887afc2002-08-27 09:44:07 +0000634
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200635 if (argc < 2)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000636 return CMD_RET_USAGE;
Serge Ziryukin65d34252010-04-25 21:32:36 +0300637
Hans de Goedeb5072262015-01-06 14:27:41 +0100638 if (strncmp(argv[1], "start", 5) == 0) {
639 if (usb_started)
640 return 0; /* Already started */
641 printf("starting USB...\n");
642 do_usb_start();
643 return 0;
644 }
645
646 if (strncmp(argv[1], "reset", 5) == 0) {
647 printf("resetting USB...\n");
Hans de Goede8a8a2252014-09-20 16:54:38 +0200648 if (do_usb_stop_keyboard(1) != 0)
Hans de Goede6e78c742014-09-20 16:54:35 +0200649 return 1;
wdenke887afc2002-08-27 09:44:07 +0000650 usb_stop();
Hans de Goedeb5072262015-01-06 14:27:41 +0100651 do_usb_start();
wdenke887afc2002-08-27 09:44:07 +0000652 return 0;
653 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100654 if (strncmp(argv[1], "stop", 4) == 0) {
Hans de Goede6e78c742014-09-20 16:54:35 +0200655 if (argc != 2)
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100656 console_assign(stdin, "serial");
Hans de Goede8a8a2252014-09-20 16:54:38 +0200657 if (do_usb_stop_keyboard(0) != 0)
Hans de Goede6e78c742014-09-20 16:54:35 +0200658 return 1;
wdenke887afc2002-08-27 09:44:07 +0000659 printf("stopping USB..\n");
660 usb_stop();
661 return 0;
662 }
Bartlomiej Siekae51aae32006-08-03 23:20:13 +0200663 if (!usb_started) {
664 printf("USB is stopped. Please issue 'usb start' first.\n");
665 return 1;
666 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100667 if (strncmp(argv[1], "tree", 4) == 0) {
Lucas Stach93c25822012-09-26 00:14:36 +0200668 puts("USB device tree:\n");
Simon Glass45bfa472015-11-08 23:47:51 -0700669 usb_show_tree();
wdenke887afc2002-08-27 09:44:07 +0000670 return 0;
671 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100672 if (strncmp(argv[1], "inf", 3) == 0) {
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100673 if (argc == 2) {
Simon Glass6a1b2062015-03-25 12:22:02 -0600674#ifdef CONFIG_DM_USB
675 usb_device_info();
676#else
677 int d;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100678 for (d = 0; d < USB_MAX_DEVICE; d++) {
Simon Glasscad42912015-03-25 12:22:00 -0600679 udev = usb_get_dev_index(d);
680 if (udev == NULL)
wdenke887afc2002-08-27 09:44:07 +0000681 break;
Simon Glasscad42912015-03-25 12:22:00 -0600682 usb_display_desc(udev);
683 usb_display_config(udev);
wdenke887afc2002-08-27 09:44:07 +0000684 }
Simon Glass6a1b2062015-03-25 12:22:02 -0600685#endif
wdenke887afc2002-08-27 09:44:07 +0000686 return 0;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100687 } else {
Simon Glass6a1b2062015-03-25 12:22:02 -0600688 /*
689 * With driver model this isn't right since we can
690 * have multiple controllers and the device numbering
691 * starts at 1 on each bus.
692 */
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000693 i = simple_strtoul(argv[2], NULL, 10);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100694 printf("config for device %d\n", i);
Simon Glasscad42912015-03-25 12:22:00 -0600695 udev = usb_find_device(i);
696 if (udev == NULL) {
Loïc Minier6052cba2011-02-03 22:04:26 +0100697 printf("*** No device available ***\n");
wdenke887afc2002-08-27 09:44:07 +0000698 return 0;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100699 } else {
Simon Glasscad42912015-03-25 12:22:00 -0600700 usb_display_desc(udev);
701 usb_display_config(udev);
wdenke887afc2002-08-27 09:44:07 +0000702 }
703 }
704 return 0;
705 }
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000706 if (strncmp(argv[1], "test", 4) == 0) {
707 if (argc < 5)
708 return CMD_RET_USAGE;
709 i = simple_strtoul(argv[2], NULL, 10);
Simon Glasscad42912015-03-25 12:22:00 -0600710 udev = usb_find_device(i);
711 if (udev == NULL) {
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000712 printf("Device %d does not exist.\n", i);
713 return 1;
714 }
715 i = simple_strtoul(argv[3], NULL, 10);
Simon Glasscad42912015-03-25 12:22:00 -0600716 return usb_test(udev, i, argv[4]);
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000717 }
wdenke887afc2002-08-27 09:44:07 +0000718#ifdef CONFIG_USB_STORAGE
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100719 if (strncmp(argv[1], "stor", 4) == 0)
Aras Vaichasf6b44e02008-03-25 12:09:07 +1100720 return usb_stor_info();
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200721
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100722 if (strncmp(argv[1], "part", 4) == 0) {
Christian Eggersd4b5f3f2008-06-27 19:46:51 +0200723 int devno, ok = 0;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100724 if (argc == 2) {
Kim B. Heinoaaad1082010-03-12 15:46:56 +0200725 for (devno = 0; ; ++devno) {
Simon Glass57ebf672016-05-01 11:36:13 -0600726 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB,
727 devno);
Kim B. Heinoaaad1082010-03-12 15:46:56 +0200728 if (stor_dev == NULL)
729 break;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100730 if (stor_dev->type != DEV_TYPE_UNKNOWN) {
Christian Eggersd4b5f3f2008-06-27 19:46:51 +0200731 ok++;
732 if (devno)
733 printf("\n");
Wolfgang Denk060f2852010-03-25 14:07:23 +0100734 debug("print_part of %x\n", devno);
Simon Glass3e8bd462016-02-29 15:25:48 -0700735 part_print(stor_dev);
Christian Eggersd4b5f3f2008-06-27 19:46:51 +0200736 }
737 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100738 } else {
739 devno = simple_strtoul(argv[2], NULL, 16);
Simon Glass57ebf672016-05-01 11:36:13 -0600740 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, devno);
Kim B. Heinoaaad1082010-03-12 15:46:56 +0200741 if (stor_dev != NULL &&
742 stor_dev->type != DEV_TYPE_UNKNOWN) {
wdenke887afc2002-08-27 09:44:07 +0000743 ok++;
Wolfgang Denk060f2852010-03-25 14:07:23 +0100744 debug("print_part of %x\n", devno);
Simon Glass3e8bd462016-02-29 15:25:48 -0700745 part_print(stor_dev);
wdenke887afc2002-08-27 09:44:07 +0000746 }
747 }
748 if (!ok) {
749 printf("\nno USB devices available\n");
750 return 1;
751 }
752 return 0;
753 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100754 if (strcmp(argv[1], "read") == 0) {
755 if (usb_stor_curr_dev < 0) {
wdenke887afc2002-08-27 09:44:07 +0000756 printf("no current device selected\n");
757 return 1;
758 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100759 if (argc == 5) {
wdenke887afc2002-08-27 09:44:07 +0000760 unsigned long addr = simple_strtoul(argv[2], NULL, 16);
761 unsigned long blk = simple_strtoul(argv[3], NULL, 16);
762 unsigned long cnt = simple_strtoul(argv[4], NULL, 16);
763 unsigned long n;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100764 printf("\nUSB read: device %d block # %ld, count %ld"
765 " ... ", usb_stor_curr_dev, blk, cnt);
Simon Glass57ebf672016-05-01 11:36:13 -0600766 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB,
767 usb_stor_curr_dev);
Simon Glass2a981dc2016-02-29 15:25:52 -0700768 n = blk_dread(stor_dev, blk, cnt, (ulong *)addr);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100769 printf("%ld blocks read: %s\n", n,
770 (n == cnt) ? "OK" : "ERROR");
771 if (n == cnt)
wdenke887afc2002-08-27 09:44:07 +0000772 return 0;
773 return 1;
774 }
775 }
Mahavir Jain127e1082009-11-03 12:22:10 +0530776 if (strcmp(argv[1], "write") == 0) {
777 if (usb_stor_curr_dev < 0) {
778 printf("no current device selected\n");
779 return 1;
780 }
781 if (argc == 5) {
782 unsigned long addr = simple_strtoul(argv[2], NULL, 16);
783 unsigned long blk = simple_strtoul(argv[3], NULL, 16);
784 unsigned long cnt = simple_strtoul(argv[4], NULL, 16);
785 unsigned long n;
786 printf("\nUSB write: device %d block # %ld, count %ld"
787 " ... ", usb_stor_curr_dev, blk, cnt);
Simon Glass57ebf672016-05-01 11:36:13 -0600788 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB,
789 usb_stor_curr_dev);
Simon Glass2a981dc2016-02-29 15:25:52 -0700790 n = blk_dwrite(stor_dev, blk, cnt, (ulong *)addr);
Mahavir Jain127e1082009-11-03 12:22:10 +0530791 printf("%ld blocks write: %s\n", n,
792 (n == cnt) ? "OK" : "ERROR");
793 if (n == cnt)
794 return 0;
795 return 1;
796 }
797 }
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200798 if (strncmp(argv[1], "dev", 3) == 0) {
799 if (argc == 3) {
wdenke887afc2002-08-27 09:44:07 +0000800 int dev = (int)simple_strtoul(argv[2], NULL, 10);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100801 printf("\nUSB device %d: ", dev);
Simon Glass57ebf672016-05-01 11:36:13 -0600802 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, dev);
Peng Fan7839f5f2016-06-17 14:18:11 +0800803 if ((stor_dev == NULL) ||
804 (stor_dev->if_type == IF_TYPE_UNKNOWN)) {
wdenke887afc2002-08-27 09:44:07 +0000805 printf("unknown device\n");
806 return 1;
807 }
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100808 printf("\n Device %d: ", dev);
wdenke887afc2002-08-27 09:44:07 +0000809 dev_print(stor_dev);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100810 if (stor_dev->type == DEV_TYPE_UNKNOWN)
wdenke887afc2002-08-27 09:44:07 +0000811 return 1;
wdenke887afc2002-08-27 09:44:07 +0000812 usb_stor_curr_dev = dev;
813 printf("... is now current device\n");
814 return 0;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100815 } else {
816 printf("\nUSB device %d: ", usb_stor_curr_dev);
Simon Glass57ebf672016-05-01 11:36:13 -0600817 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB,
818 usb_stor_curr_dev);
wdenke887afc2002-08-27 09:44:07 +0000819 dev_print(stor_dev);
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100820 if (stor_dev->type == DEV_TYPE_UNKNOWN)
wdenke887afc2002-08-27 09:44:07 +0000821 return 1;
wdenke887afc2002-08-27 09:44:07 +0000822 return 0;
823 }
824 return 0;
825 }
826#endif /* CONFIG_USB_STORAGE */
Simon Glass4c12eeb2011-12-10 08:44:01 +0000827 return CMD_RET_USAGE;
wdenke887afc2002-08-27 09:44:07 +0000828}
829
wdenk0d498392003-07-01 21:06:45 +0000830U_BOOT_CMD(
831 usb, 5, 1, do_usb,
Peter Tyser2fb26042009-01-27 18:03:12 -0600832 "USB sub-system",
Veli-Pekka Peltola1af9f962011-11-02 16:59:56 +0200833 "start - start (scan) USB controller\n"
834 "usb reset - reset (rescan) USB controller\n"
Veli-Pekka Peltolab3813a22011-11-02 16:59:55 +0200835 "usb stop [f] - stop USB [f]=force stop\n"
836 "usb tree - show USB device tree\n"
wdenk5cf91d62004-04-23 20:32:05 +0000837 "usb info [dev] - show available USB devices\n"
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000838 "usb test [dev] [port] [mode] - set USB 2.0 test mode\n"
839 " (specify port 0 to indicate the device's upstream port)\n"
840 " Available modes: J, K, S[E0_NAK], P[acket], F[orce_Enable]\n"
841#ifdef CONFIG_USB_STORAGE
Veli-Pekka Peltolab3813a22011-11-02 16:59:55 +0200842 "usb storage - show details of USB storage devices\n"
wdenk342717f2005-06-27 13:30:03 +0000843 "usb dev [dev] - show or set current USB storage device\n"
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100844 "usb part [dev] - print partition table of one or all USB storage"
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000845 " devices\n"
wdenk5cf91d62004-04-23 20:32:05 +0000846 "usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n"
Sergei Poselenov842404e2010-08-09 16:01:42 +0400847 " to memory address `addr'\n"
Mahavir Jain127e1082009-11-03 12:22:10 +0530848 "usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'\n"
849 " from memory address `addr'"
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000850#endif /* CONFIG_USB_STORAGE */
wdenk8bde7f72003-06-27 21:31:46 +0000851);
852
853
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000854#ifdef CONFIG_USB_STORAGE
wdenk0d498392003-07-01 21:06:45 +0000855U_BOOT_CMD(
856 usbboot, 3, 1, do_usbboot,
Peter Tyser2fb26042009-01-27 18:03:12 -0600857 "boot from USB device",
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200858 "loadAddr dev:part"
wdenk8bde7f72003-06-27 21:31:46 +0000859);
Julius Werner7d9aa8f2013-02-28 18:08:40 +0000860#endif /* CONFIG_USB_STORAGE */