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