]>
Commit | Line | Data |
---|---|---|
e887afc9 WD |
1 | /* |
2 | * (C) Copyright 2001 | |
3 | * Denis Peter, MPL AG Switzerland | |
4 | * | |
6a1b206d SG |
5 | * Adapted for U-Boot driver model |
6 | * (C) Copyright 2015 Google, Inc | |
7 | * | |
e887afc9 WD |
8 | * Most of this source has been derived from the Linux USB |
9 | * project. | |
10 | * | |
1a459660 | 11 | * SPDX-License-Identifier: GPL-2.0+ |
e887afc9 WD |
12 | */ |
13 | ||
14 | #include <common.h> | |
15 | #include <command.h> | |
24b852a7 | 16 | #include <console.h> |
6a1b206d | 17 | #include <dm.h> |
192eab93 | 18 | #include <dm/uclass-internal.h> |
cf92e05c | 19 | #include <memalign.h> |
414eec35 | 20 | #include <asm/byteorder.h> |
b2fb47f1 | 21 | #include <asm/unaligned.h> |
735dd97b | 22 | #include <part.h> |
e887afc9 | 23 | #include <usb.h> |
e887afc9 | 24 | |
1968e615 | 25 | #ifdef CONFIG_USB_STORAGE |
d0ff51ba | 26 | static int usb_stor_curr_dev = -1; /* current device */ |
1968e615 | 27 | #endif |
c8c2797c | 28 | #if defined(CONFIG_USB_HOST_ETHER) && !defined(CONFIG_DM_ETH) |
69559093 | 29 | static int __maybe_unused usb_ether_curr_dev = -1; /* current ethernet device */ |
89d48367 | 30 | #endif |
e887afc9 | 31 | |
a2663ea4 | 32 | /* some display routines (info command) */ |
088f1b19 | 33 | static char *usb_get_class_desc(unsigned char dclass) |
e887afc9 | 34 | { |
de39f8c1 MT |
35 | 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 ""; | |
e887afc9 WD |
56 | } |
57 | } | |
58 | ||
088f1b19 KP |
59 | static void usb_display_class_sub(unsigned char dclass, unsigned char subclass, |
60 | unsigned char proto) | |
e887afc9 | 61 | { |
de39f8c1 MT |
62 | 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"); | |
e887afc9 | 71 | break; |
de39f8c1 MT |
72 | 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; | |
e887afc9 WD |
87 | } |
88 | break; | |
de39f8c1 MT |
89 | default: |
90 | 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"); | |
e887afc9 WD |
129 | break; |
130 | default: | |
de39f8c1 MT |
131 | printf("reserved"); |
132 | break; | |
133 | } | |
134 | break; | |
135 | default: | |
136 | printf("%s", usb_get_class_desc(dclass)); | |
137 | break; | |
e887afc9 WD |
138 | } |
139 | } | |
140 | ||
088f1b19 | 141 | static void usb_display_string(struct usb_device *dev, int index) |
e887afc9 | 142 | { |
f5766139 PS |
143 | ALLOC_CACHE_ALIGN_BUFFER(char, buffer, 256); |
144 | ||
de39f8c1 MT |
145 | if (index != 0) { |
146 | if (usb_string(dev, index, &buffer[0], 256) > 0) | |
147 | printf("String: \"%s\"", buffer); | |
e887afc9 WD |
148 | } |
149 | } | |
150 | ||
088f1b19 | 151 | static void usb_display_desc(struct usb_device *dev) |
e887afc9 | 152 | { |
de39f8c1 MT |
153 | if (dev->descriptor.bDescriptorType == USB_DT_DEVICE) { |
154 | printf("%d: %s, USB Revision %x.%x\n", dev->devnum, | |
8f8bd565 | 155 | usb_get_class_desc(dev->config.if_desc[0].desc.bInterfaceClass), |
de39f8c1 MT |
156 | (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); | |
e887afc9 WD |
163 | if (dev->descriptor.bDeviceClass) { |
164 | printf(" - Class: "); | |
de39f8c1 MT |
165 | usb_display_class_sub(dev->descriptor.bDeviceClass, |
166 | dev->descriptor.bDeviceSubClass, | |
167 | dev->descriptor.bDeviceProtocol); | |
e887afc9 | 168 | printf("\n"); |
de39f8c1 MT |
169 | } else { |
170 | printf(" - Class: (from Interface) %s\n", | |
171 | usb_get_class_desc( | |
8f8bd565 | 172 | dev->config.if_desc[0].desc.bInterfaceClass)); |
e887afc9 | 173 | } |
de39f8c1 MT |
174 | 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); | |
e887afc9 WD |
181 | } |
182 | ||
183 | } | |
184 | ||
c60795f4 | 185 | static void usb_display_conf_desc(struct usb_config_descriptor *config, |
088f1b19 | 186 | struct usb_device *dev) |
e887afc9 | 187 | { |
de39f8c1 MT |
188 | 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 " : "", | |
8f8bd565 | 192 | config->bMaxPower*2); |
e887afc9 WD |
193 | if (config->iConfiguration) { |
194 | printf(" - "); | |
de39f8c1 | 195 | usb_display_string(dev, config->iConfiguration); |
e887afc9 WD |
196 | printf("\n"); |
197 | } | |
198 | } | |
199 | ||
088f1b19 KP |
200 | static void usb_display_if_desc(struct usb_interface_descriptor *ifdesc, |
201 | struct usb_device *dev) | |
e887afc9 | 202 | { |
de39f8c1 MT |
203 | printf(" Interface: %d\n", ifdesc->bInterfaceNumber); |
204 | printf(" - Alternate Setting %d, Endpoints: %d\n", | |
205 | ifdesc->bAlternateSetting, ifdesc->bNumEndpoints); | |
e887afc9 | 206 | printf(" - Class "); |
de39f8c1 MT |
207 | usb_display_class_sub(ifdesc->bInterfaceClass, |
208 | ifdesc->bInterfaceSubClass, ifdesc->bInterfaceProtocol); | |
e887afc9 WD |
209 | printf("\n"); |
210 | if (ifdesc->iInterface) { | |
211 | printf(" - "); | |
de39f8c1 | 212 | usb_display_string(dev, ifdesc->iInterface); |
e887afc9 WD |
213 | printf("\n"); |
214 | } | |
215 | } | |
216 | ||
088f1b19 | 217 | static void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc) |
e887afc9 | 218 | { |
de39f8c1 MT |
219 | 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; | |
e887afc9 | 234 | } |
b2fb47f1 | 235 | printf(" MaxPacket %d", get_unaligned(&epdesc->wMaxPacketSize)); |
de39f8c1 MT |
236 | if ((epdesc->bmAttributes & 0x03) == 0x3) |
237 | printf(" Interval %dms", epdesc->bInterval); | |
e887afc9 WD |
238 | printf("\n"); |
239 | } | |
240 | ||
241 | /* main routine to diasplay the configs, interfaces and endpoints */ | |
088f1b19 | 242 | static void usb_display_config(struct usb_device *dev) |
e887afc9 | 243 | { |
8f8bd565 TR |
244 | struct usb_config *config; |
245 | struct usb_interface *ifdesc; | |
e887afc9 | 246 | struct usb_endpoint_descriptor *epdesc; |
de39f8c1 MT |
247 | int i, ii; |
248 | ||
249 | config = &dev->config; | |
8f8bd565 | 250 | usb_display_conf_desc(&config->desc, dev); |
de39f8c1 MT |
251 | for (i = 0; i < config->no_of_if; i++) { |
252 | ifdesc = &config->if_desc[i]; | |
8f8bd565 | 253 | usb_display_if_desc(&ifdesc->desc, dev); |
de39f8c1 MT |
254 | for (ii = 0; ii < ifdesc->no_of_ep; ii++) { |
255 | epdesc = &ifdesc->ep_desc[ii]; | |
e887afc9 WD |
256 | usb_display_ep_desc(epdesc); |
257 | } | |
258 | } | |
259 | printf("\n"); | |
260 | } | |
261 | ||
6a1b206d SG |
262 | /* |
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 | */ | |
7d9aa8fd JW |
267 | static struct usb_device *usb_find_device(int devnum) |
268 | { | |
6a1b206d SG |
269 | #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; | |
bcbe3d15 | 286 | udev = dev_get_parent_priv(hub); |
6a1b206d SG |
287 | 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 | ||
bcbe3d15 | 296 | udev = dev_get_parent_priv(dev); |
6a1b206d SG |
297 | if (udev->devnum == devnum) |
298 | return udev; | |
299 | } | |
300 | } | |
301 | #else | |
cad4291c | 302 | struct usb_device *udev; |
7d9aa8fd JW |
303 | int d; |
304 | ||
305 | for (d = 0; d < USB_MAX_DEVICE; d++) { | |
cad4291c SG |
306 | udev = usb_get_dev_index(d); |
307 | if (udev == NULL) | |
7d9aa8fd | 308 | return NULL; |
cad4291c SG |
309 | if (udev->devnum == devnum) |
310 | return udev; | |
7d9aa8fd | 311 | } |
6a1b206d | 312 | #endif |
7d9aa8fd JW |
313 | |
314 | return NULL; | |
315 | } | |
316 | ||
f1c1f540 SR |
317 | static inline char *portspeed(int speed) |
318 | { | |
6497c667 VG |
319 | 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; | |
f1c1f540 SR |
337 | } |
338 | ||
e887afc9 | 339 | /* shows the device tree recursively */ |
088f1b19 | 340 | static void usb_show_tree_graph(struct usb_device *dev, char *pre) |
e887afc9 | 341 | { |
6a1b206d | 342 | int index; |
10f4dd78 | 343 | int has_child, last_child; |
e887afc9 | 344 | |
de39f8c1 MT |
345 | index = strlen(pre); |
346 | printf(" %s", pre); | |
6a1b206d SG |
347 | #ifdef CONFIG_DM_USB |
348 | has_child = device_has_active_children(dev->dev); | |
349 | #else | |
e887afc9 | 350 | /* check if the device has connected children */ |
6a1b206d SG |
351 | int i; |
352 | ||
de39f8c1 MT |
353 | has_child = 0; |
354 | for (i = 0; i < dev->maxchild; i++) { | |
355 | if (dev->children[i] != NULL) | |
356 | has_child = 1; | |
e887afc9 | 357 | } |
6a1b206d | 358 | #endif |
e887afc9 | 359 | /* check if we are the last one */ |
6a1b206d | 360 | #ifdef CONFIG_DM_USB |
c27b3290 HG |
361 | /* 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); | |
6a1b206d | 364 | #else |
c27b3290 HG |
365 | if (dev->parent != NULL) { /* not root? */ |
366 | last_child = 1; | |
de39f8c1 | 367 | for (i = 0; i < dev->parent->maxchild; i++) { |
e887afc9 | 368 | /* search for children */ |
de39f8c1 MT |
369 | if (dev->parent->children[i] == dev) { |
370 | /* found our pointer, see if we have a | |
371 | * little sister | |
372 | */ | |
de39f8c1 MT |
373 | while (i++ < dev->parent->maxchild) { |
374 | if (dev->parent->children[i] != NULL) { | |
e887afc9 | 375 | /* found a sister */ |
de39f8c1 | 376 | last_child = 0; |
e887afc9 WD |
377 | break; |
378 | } /* if */ | |
379 | } /* while */ | |
380 | } /* device found */ | |
381 | } /* for all children of the parent */ | |
6a1b206d | 382 | #endif |
e887afc9 WD |
383 | printf("\b+-"); |
384 | /* correct last child */ | |
cad4291c | 385 | if (last_child && index) |
de39f8c1 | 386 | pre[index-1] = ' '; |
e887afc9 WD |
387 | } /* if not root hub */ |
388 | else | |
389 | printf(" "); | |
de39f8c1 MT |
390 | 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( | |
8f8bd565 | 395 | dev->config.if_desc[0].desc.bInterfaceClass), |
f1c1f540 | 396 | portspeed(dev->speed), |
8f8bd565 | 397 | dev->config.desc.bMaxPower * 2); |
de39f8c1 MT |
398 | 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); | |
6a1b206d SG |
401 | #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 | ||
bcbe3d15 | 412 | udev = dev_get_parent_priv(child); |
6a1b206d SG |
413 | |
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 | |
de39f8c1 MT |
421 | 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; | |
e887afc9 WD |
426 | } |
427 | } | |
428 | } | |
6a1b206d | 429 | #endif |
e887afc9 WD |
430 | } |
431 | ||
432 | /* main routine for the tree command */ | |
45bfa47e | 433 | static void usb_show_subtree(struct usb_device *dev) |
e887afc9 WD |
434 | { |
435 | char preamble[32]; | |
436 | ||
cad4291c | 437 | memset(preamble, '\0', sizeof(preamble)); |
de39f8c1 | 438 | usb_show_tree_graph(dev, &preamble[0]); |
e887afc9 WD |
439 | } |
440 | ||
45bfa47e SG |
441 | void usb_show_tree(void) |
442 | { | |
443 | #ifdef CONFIG_DM_USB | |
444 | struct udevice *bus; | |
445 | ||
192eab93 | 446 | for (uclass_find_first_device(UCLASS_USB, &bus); |
45bfa47e | 447 | bus; |
192eab93 | 448 | uclass_find_next_device(&bus)) { |
45bfa47e SG |
449 | struct usb_device *udev; |
450 | struct udevice *dev; | |
451 | ||
192eab93 HG |
452 | if (!device_active(bus)) |
453 | continue; | |
454 | ||
45bfa47e SG |
455 | 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 | ||
7d9aa8fd JW |
475 | static 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 | ||
e887afc9 | 535 | |
e887afc9 WD |
536 | /****************************************************************************** |
537 | * usb boot command intepreter. Derived from diskboot | |
538 | */ | |
539 | #ifdef CONFIG_USB_STORAGE | |
088f1b19 | 540 | static int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
e887afc9 | 541 | { |
7405a133 | 542 | return common_diskboot(cmdtp, "usb", argc, argv); |
e887afc9 WD |
543 | } |
544 | #endif /* CONFIG_USB_STORAGE */ | |
545 | ||
8a8a2257 | 546 | static int do_usb_stop_keyboard(int force) |
6e78c74f | 547 | { |
9a80e714 | 548 | #if !defined CONFIG_DM_USB && defined CONFIG_USB_KEYBOARD |
8a8a2257 | 549 | if (usb_kbd_deregister(force) != 0) { |
6e78c74f HG |
550 | printf("USB not stopped: usbkbd still using USB\n"); |
551 | return 1; | |
552 | } | |
553 | #endif | |
554 | return 0; | |
555 | } | |
e887afc9 | 556 | |
b5072264 HG |
557 | static 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 | ||
6a1b206d SG |
564 | /* Driver model will probe the devices as they are found */ |
565 | #ifndef CONFIG_DM_USB | |
34ab37ee | 566 | # ifdef CONFIG_USB_STORAGE |
b5072264 HG |
567 | /* try to recognize storage devices immediately */ |
568 | usb_stor_curr_dev = usb_stor_scan(1); | |
34ab37ee SG |
569 | # endif |
570 | # ifdef CONFIG_USB_KEYBOARD | |
571 | drv_usb_kbd_init(); | |
572 | # endif | |
573 | #endif /* !CONFIG_DM_USB */ | |
b5072264 | 574 | #ifdef CONFIG_USB_HOST_ETHER |
69559093 | 575 | # ifdef CONFIG_DM_ETH |
389f1856 MZ |
576 | # 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 | |
b5072264 HG |
580 | /* try to recognize ethernet devices immediately */ |
581 | usb_ether_curr_dev = usb_host_eth_scan(1); | |
389f1856 | 582 | # endif |
69559093 | 583 | #endif |
b5072264 HG |
584 | } |
585 | ||
6a1b206d SG |
586 | #ifdef CONFIG_DM_USB |
587 | static void show_info(struct udevice *dev) | |
588 | { | |
589 | struct udevice *child; | |
590 | struct usb_device *udev; | |
591 | ||
bcbe3d15 | 592 | udev = dev_get_parent_priv(dev); |
6a1b206d SG |
593 | 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 | ||
603 | static 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 | ||
de39f8c1 | 623 | /****************************************************************************** |
e887afc9 WD |
624 | * usb command intepreter |
625 | */ | |
088f1b19 | 626 | static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
e887afc9 | 627 | { |
cad4291c | 628 | struct usb_device *udev = NULL; |
e887afc9 | 629 | int i; |
e51aae38 | 630 | extern char usb_started; |
1968e615 | 631 | #ifdef CONFIG_USB_STORAGE |
4101f687 | 632 | struct blk_desc *stor_dev; |
1968e615 | 633 | #endif |
e887afc9 | 634 | |
47e26b1b | 635 | if (argc < 2) |
4c12eeb8 | 636 | return CMD_RET_USAGE; |
65d34254 | 637 | |
b5072264 HG |
638 | 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"); | |
8a8a2257 | 648 | if (do_usb_stop_keyboard(1) != 0) |
6e78c74f | 649 | return 1; |
e887afc9 | 650 | usb_stop(); |
b5072264 | 651 | do_usb_start(); |
e887afc9 WD |
652 | return 0; |
653 | } | |
de39f8c1 | 654 | if (strncmp(argv[1], "stop", 4) == 0) { |
6e78c74f | 655 | if (argc != 2) |
de39f8c1 | 656 | console_assign(stdin, "serial"); |
8a8a2257 | 657 | if (do_usb_stop_keyboard(0) != 0) |
6e78c74f | 658 | return 1; |
e887afc9 WD |
659 | printf("stopping USB..\n"); |
660 | usb_stop(); | |
661 | return 0; | |
662 | } | |
e51aae38 BS |
663 | if (!usb_started) { |
664 | printf("USB is stopped. Please issue 'usb start' first.\n"); | |
665 | return 1; | |
666 | } | |
de39f8c1 | 667 | if (strncmp(argv[1], "tree", 4) == 0) { |
93c2582f | 668 | puts("USB device tree:\n"); |
45bfa47e | 669 | usb_show_tree(); |
e887afc9 WD |
670 | return 0; |
671 | } | |
de39f8c1 | 672 | if (strncmp(argv[1], "inf", 3) == 0) { |
de39f8c1 | 673 | if (argc == 2) { |
6a1b206d SG |
674 | #ifdef CONFIG_DM_USB |
675 | usb_device_info(); | |
676 | #else | |
677 | int d; | |
de39f8c1 | 678 | for (d = 0; d < USB_MAX_DEVICE; d++) { |
cad4291c SG |
679 | udev = usb_get_dev_index(d); |
680 | if (udev == NULL) | |
e887afc9 | 681 | break; |
cad4291c SG |
682 | usb_display_desc(udev); |
683 | usb_display_config(udev); | |
e887afc9 | 684 | } |
6a1b206d | 685 | #endif |
e887afc9 | 686 | return 0; |
de39f8c1 | 687 | } else { |
6a1b206d SG |
688 | /* |
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 | */ | |
7d9aa8fd | 693 | i = simple_strtoul(argv[2], NULL, 10); |
de39f8c1 | 694 | printf("config for device %d\n", i); |
cad4291c SG |
695 | udev = usb_find_device(i); |
696 | if (udev == NULL) { | |
6052cbab | 697 | printf("*** No device available ***\n"); |
e887afc9 | 698 | return 0; |
de39f8c1 | 699 | } else { |
cad4291c SG |
700 | usb_display_desc(udev); |
701 | usb_display_config(udev); | |
e887afc9 WD |
702 | } |
703 | } | |
704 | return 0; | |
705 | } | |
7d9aa8fd JW |
706 | if (strncmp(argv[1], "test", 4) == 0) { |
707 | if (argc < 5) | |
708 | return CMD_RET_USAGE; | |
709 | i = simple_strtoul(argv[2], NULL, 10); | |
cad4291c SG |
710 | udev = usb_find_device(i); |
711 | if (udev == NULL) { | |
7d9aa8fd JW |
712 | printf("Device %d does not exist.\n", i); |
713 | return 1; | |
714 | } | |
715 | i = simple_strtoul(argv[3], NULL, 10); | |
cad4291c | 716 | return usb_test(udev, i, argv[4]); |
7d9aa8fd | 717 | } |
e887afc9 | 718 | #ifdef CONFIG_USB_STORAGE |
de39f8c1 | 719 | if (strncmp(argv[1], "stor", 4) == 0) |
f6b44e0e | 720 | return usb_stor_info(); |
9c998aa8 | 721 | |
de39f8c1 | 722 | if (strncmp(argv[1], "part", 4) == 0) { |
d4b5f3fa | 723 | int devno, ok = 0; |
de39f8c1 | 724 | if (argc == 2) { |
aaad108b | 725 | for (devno = 0; ; ++devno) { |
57ebf67b SG |
726 | stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, |
727 | devno); | |
aaad108b KH |
728 | if (stor_dev == NULL) |
729 | break; | |
de39f8c1 | 730 | if (stor_dev->type != DEV_TYPE_UNKNOWN) { |
d4b5f3fa CE |
731 | ok++; |
732 | if (devno) | |
733 | printf("\n"); | |
060f2853 | 734 | debug("print_part of %x\n", devno); |
3e8bd469 | 735 | part_print(stor_dev); |
d4b5f3fa CE |
736 | } |
737 | } | |
de39f8c1 MT |
738 | } else { |
739 | devno = simple_strtoul(argv[2], NULL, 16); | |
57ebf67b | 740 | stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, devno); |
aaad108b KH |
741 | if (stor_dev != NULL && |
742 | stor_dev->type != DEV_TYPE_UNKNOWN) { | |
e887afc9 | 743 | ok++; |
060f2853 | 744 | debug("print_part of %x\n", devno); |
3e8bd469 | 745 | part_print(stor_dev); |
e887afc9 WD |
746 | } |
747 | } | |
748 | if (!ok) { | |
749 | printf("\nno USB devices available\n"); | |
750 | return 1; | |
751 | } | |
752 | return 0; | |
753 | } | |
de39f8c1 MT |
754 | if (strcmp(argv[1], "read") == 0) { |
755 | if (usb_stor_curr_dev < 0) { | |
e887afc9 WD |
756 | printf("no current device selected\n"); |
757 | return 1; | |
758 | } | |
de39f8c1 | 759 | if (argc == 5) { |
e887afc9 WD |
760 | 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; | |
de39f8c1 MT |
764 | printf("\nUSB read: device %d block # %ld, count %ld" |
765 | " ... ", usb_stor_curr_dev, blk, cnt); | |
57ebf67b SG |
766 | stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, |
767 | usb_stor_curr_dev); | |
2a981dc2 | 768 | n = blk_dread(stor_dev, blk, cnt, (ulong *)addr); |
de39f8c1 MT |
769 | printf("%ld blocks read: %s\n", n, |
770 | (n == cnt) ? "OK" : "ERROR"); | |
771 | if (n == cnt) | |
e887afc9 WD |
772 | return 0; |
773 | return 1; | |
774 | } | |
775 | } | |
127e1084 MJ |
776 | 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); | |
57ebf67b SG |
788 | stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, |
789 | usb_stor_curr_dev); | |
2a981dc2 | 790 | n = blk_dwrite(stor_dev, blk, cnt, (ulong *)addr); |
127e1084 MJ |
791 | printf("%ld blocks write: %s\n", n, |
792 | (n == cnt) ? "OK" : "ERROR"); | |
793 | if (n == cnt) | |
794 | return 0; | |
795 | return 1; | |
796 | } | |
797 | } | |
9c998aa8 WD |
798 | if (strncmp(argv[1], "dev", 3) == 0) { |
799 | if (argc == 3) { | |
e887afc9 | 800 | int dev = (int)simple_strtoul(argv[2], NULL, 10); |
de39f8c1 | 801 | printf("\nUSB device %d: ", dev); |
57ebf67b | 802 | stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, dev); |
7839f5f8 PF |
803 | if ((stor_dev == NULL) || |
804 | (stor_dev->if_type == IF_TYPE_UNKNOWN)) { | |
e887afc9 WD |
805 | printf("unknown device\n"); |
806 | return 1; | |
807 | } | |
de39f8c1 | 808 | printf("\n Device %d: ", dev); |
e887afc9 | 809 | dev_print(stor_dev); |
de39f8c1 | 810 | if (stor_dev->type == DEV_TYPE_UNKNOWN) |
e887afc9 | 811 | return 1; |
e887afc9 WD |
812 | usb_stor_curr_dev = dev; |
813 | printf("... is now current device\n"); | |
814 | return 0; | |
de39f8c1 MT |
815 | } else { |
816 | printf("\nUSB device %d: ", usb_stor_curr_dev); | |
57ebf67b SG |
817 | stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, |
818 | usb_stor_curr_dev); | |
e887afc9 | 819 | dev_print(stor_dev); |
de39f8c1 | 820 | if (stor_dev->type == DEV_TYPE_UNKNOWN) |
e887afc9 | 821 | return 1; |
e887afc9 WD |
822 | return 0; |
823 | } | |
824 | return 0; | |
825 | } | |
826 | #endif /* CONFIG_USB_STORAGE */ | |
4c12eeb8 | 827 | return CMD_RET_USAGE; |
e887afc9 WD |
828 | } |
829 | ||
0d498393 WD |
830 | U_BOOT_CMD( |
831 | usb, 5, 1, do_usb, | |
2fb2604d | 832 | "USB sub-system", |
1af9f963 VPP |
833 | "start - start (scan) USB controller\n" |
834 | "usb reset - reset (rescan) USB controller\n" | |
b3813a22 VPP |
835 | "usb stop [f] - stop USB [f]=force stop\n" |
836 | "usb tree - show USB device tree\n" | |
5cf91d6b | 837 | "usb info [dev] - show available USB devices\n" |
7d9aa8fd JW |
838 | "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 | |
b3813a22 | 842 | "usb storage - show details of USB storage devices\n" |
342717f7 | 843 | "usb dev [dev] - show or set current USB storage device\n" |
de39f8c1 | 844 | "usb part [dev] - print partition table of one or all USB storage" |
7d9aa8fd | 845 | " devices\n" |
5cf91d6b | 846 | "usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n" |
842404ea | 847 | " to memory address `addr'\n" |
127e1084 MJ |
848 | "usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'\n" |
849 | " from memory address `addr'" | |
7d9aa8fd | 850 | #endif /* CONFIG_USB_STORAGE */ |
8bde7f77 WD |
851 | ); |
852 | ||
853 | ||
7d9aa8fd | 854 | #ifdef CONFIG_USB_STORAGE |
0d498393 WD |
855 | U_BOOT_CMD( |
856 | usbboot, 3, 1, do_usbboot, | |
2fb2604d | 857 | "boot from USB device", |
a89c33db | 858 | "loadAddr dev:part" |
8bde7f77 | 859 | ); |
7d9aa8fd | 860 | #endif /* CONFIG_USB_STORAGE */ |