]>
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> | |
6a1b206d | 16 | #include <dm.h> |
414eec35 | 17 | #include <asm/byteorder.h> |
b2fb47f1 | 18 | #include <asm/unaligned.h> |
735dd97b | 19 | #include <part.h> |
e887afc9 | 20 | #include <usb.h> |
e887afc9 | 21 | |
1968e615 | 22 | #ifdef CONFIG_USB_STORAGE |
d0ff51ba | 23 | static int usb_stor_curr_dev = -1; /* current device */ |
1968e615 | 24 | #endif |
c8c2797c | 25 | #if defined(CONFIG_USB_HOST_ETHER) && !defined(CONFIG_DM_ETH) |
69559093 | 26 | static int __maybe_unused usb_ether_curr_dev = -1; /* current ethernet device */ |
89d48367 | 27 | #endif |
e887afc9 | 28 | |
a2663ea4 | 29 | /* some display routines (info command) */ |
088f1b19 | 30 | static char *usb_get_class_desc(unsigned char dclass) |
e887afc9 | 31 | { |
de39f8c1 MT |
32 | switch (dclass) { |
33 | case USB_CLASS_PER_INTERFACE: | |
34 | return "See Interface"; | |
35 | case USB_CLASS_AUDIO: | |
36 | return "Audio"; | |
37 | case USB_CLASS_COMM: | |
38 | return "Communication"; | |
39 | case USB_CLASS_HID: | |
40 | return "Human Interface"; | |
41 | case USB_CLASS_PRINTER: | |
42 | return "Printer"; | |
43 | case USB_CLASS_MASS_STORAGE: | |
44 | return "Mass Storage"; | |
45 | case USB_CLASS_HUB: | |
46 | return "Hub"; | |
47 | case USB_CLASS_DATA: | |
48 | return "CDC Data"; | |
49 | case USB_CLASS_VENDOR_SPEC: | |
50 | return "Vendor specific"; | |
51 | default: | |
52 | return ""; | |
e887afc9 WD |
53 | } |
54 | } | |
55 | ||
088f1b19 KP |
56 | static void usb_display_class_sub(unsigned char dclass, unsigned char subclass, |
57 | unsigned char proto) | |
e887afc9 | 58 | { |
de39f8c1 MT |
59 | switch (dclass) { |
60 | case USB_CLASS_PER_INTERFACE: | |
61 | printf("See Interface"); | |
62 | break; | |
63 | case USB_CLASS_HID: | |
64 | printf("Human Interface, Subclass: "); | |
65 | switch (subclass) { | |
66 | case USB_SUB_HID_NONE: | |
67 | printf("None"); | |
e887afc9 | 68 | break; |
de39f8c1 MT |
69 | case USB_SUB_HID_BOOT: |
70 | printf("Boot "); | |
71 | switch (proto) { | |
72 | case USB_PROT_HID_NONE: | |
73 | printf("None"); | |
74 | break; | |
75 | case USB_PROT_HID_KEYBOARD: | |
76 | printf("Keyboard"); | |
77 | break; | |
78 | case USB_PROT_HID_MOUSE: | |
79 | printf("Mouse"); | |
80 | break; | |
81 | default: | |
82 | printf("reserved"); | |
83 | break; | |
e887afc9 WD |
84 | } |
85 | break; | |
de39f8c1 MT |
86 | default: |
87 | printf("reserved"); | |
88 | break; | |
89 | } | |
90 | break; | |
91 | case USB_CLASS_MASS_STORAGE: | |
92 | printf("Mass Storage, "); | |
93 | switch (subclass) { | |
94 | case US_SC_RBC: | |
95 | printf("RBC "); | |
96 | break; | |
97 | case US_SC_8020: | |
98 | printf("SFF-8020i (ATAPI)"); | |
99 | break; | |
100 | case US_SC_QIC: | |
101 | printf("QIC-157 (Tape)"); | |
102 | break; | |
103 | case US_SC_UFI: | |
104 | printf("UFI"); | |
105 | break; | |
106 | case US_SC_8070: | |
107 | printf("SFF-8070"); | |
108 | break; | |
109 | case US_SC_SCSI: | |
110 | printf("Transp. SCSI"); | |
111 | break; | |
112 | default: | |
113 | printf("reserved"); | |
114 | break; | |
115 | } | |
116 | printf(", "); | |
117 | switch (proto) { | |
118 | case US_PR_CB: | |
119 | printf("Command/Bulk"); | |
120 | break; | |
121 | case US_PR_CBI: | |
122 | printf("Command/Bulk/Int"); | |
123 | break; | |
124 | case US_PR_BULK: | |
125 | printf("Bulk only"); | |
e887afc9 WD |
126 | break; |
127 | default: | |
de39f8c1 MT |
128 | printf("reserved"); |
129 | break; | |
130 | } | |
131 | break; | |
132 | default: | |
133 | printf("%s", usb_get_class_desc(dclass)); | |
134 | break; | |
e887afc9 WD |
135 | } |
136 | } | |
137 | ||
088f1b19 | 138 | static void usb_display_string(struct usb_device *dev, int index) |
e887afc9 | 139 | { |
f5766139 PS |
140 | ALLOC_CACHE_ALIGN_BUFFER(char, buffer, 256); |
141 | ||
de39f8c1 MT |
142 | if (index != 0) { |
143 | if (usb_string(dev, index, &buffer[0], 256) > 0) | |
144 | printf("String: \"%s\"", buffer); | |
e887afc9 WD |
145 | } |
146 | } | |
147 | ||
088f1b19 | 148 | static void usb_display_desc(struct usb_device *dev) |
e887afc9 | 149 | { |
de39f8c1 MT |
150 | if (dev->descriptor.bDescriptorType == USB_DT_DEVICE) { |
151 | printf("%d: %s, USB Revision %x.%x\n", dev->devnum, | |
8f8bd565 | 152 | usb_get_class_desc(dev->config.if_desc[0].desc.bInterfaceClass), |
de39f8c1 MT |
153 | (dev->descriptor.bcdUSB>>8) & 0xff, |
154 | dev->descriptor.bcdUSB & 0xff); | |
155 | ||
156 | if (strlen(dev->mf) || strlen(dev->prod) || | |
157 | strlen(dev->serial)) | |
158 | printf(" - %s %s %s\n", dev->mf, dev->prod, | |
159 | dev->serial); | |
e887afc9 WD |
160 | if (dev->descriptor.bDeviceClass) { |
161 | printf(" - Class: "); | |
de39f8c1 MT |
162 | usb_display_class_sub(dev->descriptor.bDeviceClass, |
163 | dev->descriptor.bDeviceSubClass, | |
164 | dev->descriptor.bDeviceProtocol); | |
e887afc9 | 165 | printf("\n"); |
de39f8c1 MT |
166 | } else { |
167 | printf(" - Class: (from Interface) %s\n", | |
168 | usb_get_class_desc( | |
8f8bd565 | 169 | dev->config.if_desc[0].desc.bInterfaceClass)); |
e887afc9 | 170 | } |
de39f8c1 MT |
171 | printf(" - PacketSize: %d Configurations: %d\n", |
172 | dev->descriptor.bMaxPacketSize0, | |
173 | dev->descriptor.bNumConfigurations); | |
174 | printf(" - Vendor: 0x%04x Product 0x%04x Version %d.%d\n", | |
175 | dev->descriptor.idVendor, dev->descriptor.idProduct, | |
176 | (dev->descriptor.bcdDevice>>8) & 0xff, | |
177 | dev->descriptor.bcdDevice & 0xff); | |
e887afc9 WD |
178 | } |
179 | ||
180 | } | |
181 | ||
c60795f4 | 182 | static void usb_display_conf_desc(struct usb_config_descriptor *config, |
088f1b19 | 183 | struct usb_device *dev) |
e887afc9 | 184 | { |
de39f8c1 MT |
185 | printf(" Configuration: %d\n", config->bConfigurationValue); |
186 | printf(" - Interfaces: %d %s%s%dmA\n", config->bNumInterfaces, | |
187 | (config->bmAttributes & 0x40) ? "Self Powered " : "Bus Powered ", | |
188 | (config->bmAttributes & 0x20) ? "Remote Wakeup " : "", | |
8f8bd565 | 189 | config->bMaxPower*2); |
e887afc9 WD |
190 | if (config->iConfiguration) { |
191 | printf(" - "); | |
de39f8c1 | 192 | usb_display_string(dev, config->iConfiguration); |
e887afc9 WD |
193 | printf("\n"); |
194 | } | |
195 | } | |
196 | ||
088f1b19 KP |
197 | static void usb_display_if_desc(struct usb_interface_descriptor *ifdesc, |
198 | struct usb_device *dev) | |
e887afc9 | 199 | { |
de39f8c1 MT |
200 | printf(" Interface: %d\n", ifdesc->bInterfaceNumber); |
201 | printf(" - Alternate Setting %d, Endpoints: %d\n", | |
202 | ifdesc->bAlternateSetting, ifdesc->bNumEndpoints); | |
e887afc9 | 203 | printf(" - Class "); |
de39f8c1 MT |
204 | usb_display_class_sub(ifdesc->bInterfaceClass, |
205 | ifdesc->bInterfaceSubClass, ifdesc->bInterfaceProtocol); | |
e887afc9 WD |
206 | printf("\n"); |
207 | if (ifdesc->iInterface) { | |
208 | printf(" - "); | |
de39f8c1 | 209 | usb_display_string(dev, ifdesc->iInterface); |
e887afc9 WD |
210 | printf("\n"); |
211 | } | |
212 | } | |
213 | ||
088f1b19 | 214 | static void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc) |
e887afc9 | 215 | { |
de39f8c1 MT |
216 | printf(" - Endpoint %d %s ", epdesc->bEndpointAddress & 0xf, |
217 | (epdesc->bEndpointAddress & 0x80) ? "In" : "Out"); | |
218 | switch ((epdesc->bmAttributes & 0x03)) { | |
219 | case 0: | |
220 | printf("Control"); | |
221 | break; | |
222 | case 1: | |
223 | printf("Isochronous"); | |
224 | break; | |
225 | case 2: | |
226 | printf("Bulk"); | |
227 | break; | |
228 | case 3: | |
229 | printf("Interrupt"); | |
230 | break; | |
e887afc9 | 231 | } |
b2fb47f1 | 232 | printf(" MaxPacket %d", get_unaligned(&epdesc->wMaxPacketSize)); |
de39f8c1 MT |
233 | if ((epdesc->bmAttributes & 0x03) == 0x3) |
234 | printf(" Interval %dms", epdesc->bInterval); | |
e887afc9 WD |
235 | printf("\n"); |
236 | } | |
237 | ||
238 | /* main routine to diasplay the configs, interfaces and endpoints */ | |
088f1b19 | 239 | static void usb_display_config(struct usb_device *dev) |
e887afc9 | 240 | { |
8f8bd565 TR |
241 | struct usb_config *config; |
242 | struct usb_interface *ifdesc; | |
e887afc9 | 243 | struct usb_endpoint_descriptor *epdesc; |
de39f8c1 MT |
244 | int i, ii; |
245 | ||
246 | config = &dev->config; | |
8f8bd565 | 247 | usb_display_conf_desc(&config->desc, dev); |
de39f8c1 MT |
248 | for (i = 0; i < config->no_of_if; i++) { |
249 | ifdesc = &config->if_desc[i]; | |
8f8bd565 | 250 | usb_display_if_desc(&ifdesc->desc, dev); |
de39f8c1 MT |
251 | for (ii = 0; ii < ifdesc->no_of_ep; ii++) { |
252 | epdesc = &ifdesc->ep_desc[ii]; | |
e887afc9 WD |
253 | usb_display_ep_desc(epdesc); |
254 | } | |
255 | } | |
256 | printf("\n"); | |
257 | } | |
258 | ||
6a1b206d SG |
259 | /* |
260 | * With driver model this isn't right since we can have multiple controllers | |
261 | * and the device numbering starts at 1 on each bus. | |
262 | * TODO(sjg@chromium.org): Add a way to specify the controller/bus. | |
263 | */ | |
7d9aa8fd JW |
264 | static struct usb_device *usb_find_device(int devnum) |
265 | { | |
6a1b206d SG |
266 | #ifdef CONFIG_DM_USB |
267 | struct usb_device *udev; | |
268 | struct udevice *hub; | |
269 | struct uclass *uc; | |
270 | int ret; | |
271 | ||
272 | /* Device addresses start at 1 */ | |
273 | devnum++; | |
274 | ret = uclass_get(UCLASS_USB_HUB, &uc); | |
275 | if (ret) | |
276 | return NULL; | |
277 | ||
278 | uclass_foreach_dev(hub, uc) { | |
279 | struct udevice *dev; | |
280 | ||
281 | if (!device_active(hub)) | |
282 | continue; | |
283 | udev = dev_get_parentdata(hub); | |
284 | if (udev->devnum == devnum) | |
285 | return udev; | |
286 | ||
287 | for (device_find_first_child(hub, &dev); | |
288 | dev; | |
289 | device_find_next_child(&dev)) { | |
290 | if (!device_active(hub)) | |
291 | continue; | |
292 | ||
293 | udev = dev_get_parentdata(dev); | |
294 | if (udev->devnum == devnum) | |
295 | return udev; | |
296 | } | |
297 | } | |
298 | #else | |
cad4291c | 299 | struct usb_device *udev; |
7d9aa8fd JW |
300 | int d; |
301 | ||
302 | for (d = 0; d < USB_MAX_DEVICE; d++) { | |
cad4291c SG |
303 | udev = usb_get_dev_index(d); |
304 | if (udev == NULL) | |
7d9aa8fd | 305 | return NULL; |
cad4291c SG |
306 | if (udev->devnum == devnum) |
307 | return udev; | |
7d9aa8fd | 308 | } |
6a1b206d | 309 | #endif |
7d9aa8fd JW |
310 | |
311 | return NULL; | |
312 | } | |
313 | ||
f1c1f540 SR |
314 | static inline char *portspeed(int speed) |
315 | { | |
6497c667 VG |
316 | char *speed_str; |
317 | ||
318 | switch (speed) { | |
319 | case USB_SPEED_SUPER: | |
320 | speed_str = "5 Gb/s"; | |
321 | break; | |
322 | case USB_SPEED_HIGH: | |
323 | speed_str = "480 Mb/s"; | |
324 | break; | |
325 | case USB_SPEED_LOW: | |
326 | speed_str = "1.5 Mb/s"; | |
327 | break; | |
328 | default: | |
329 | speed_str = "12 Mb/s"; | |
330 | break; | |
331 | } | |
332 | ||
333 | return speed_str; | |
f1c1f540 SR |
334 | } |
335 | ||
e887afc9 | 336 | /* shows the device tree recursively */ |
088f1b19 | 337 | static void usb_show_tree_graph(struct usb_device *dev, char *pre) |
e887afc9 | 338 | { |
6a1b206d | 339 | int index; |
10f4dd78 | 340 | int has_child, last_child; |
e887afc9 | 341 | |
de39f8c1 MT |
342 | index = strlen(pre); |
343 | printf(" %s", pre); | |
6a1b206d SG |
344 | #ifdef CONFIG_DM_USB |
345 | has_child = device_has_active_children(dev->dev); | |
346 | #else | |
e887afc9 | 347 | /* check if the device has connected children */ |
6a1b206d SG |
348 | int i; |
349 | ||
de39f8c1 MT |
350 | has_child = 0; |
351 | for (i = 0; i < dev->maxchild; i++) { | |
352 | if (dev->children[i] != NULL) | |
353 | has_child = 1; | |
e887afc9 | 354 | } |
6a1b206d | 355 | #endif |
e887afc9 | 356 | /* check if we are the last one */ |
6a1b206d | 357 | #ifdef CONFIG_DM_USB |
c27b3290 HG |
358 | /* Not the root of the usb tree? */ |
359 | if (device_get_uclass_id(dev->dev->parent) != UCLASS_USB) { | |
360 | last_child = device_is_last_sibling(dev->dev); | |
6a1b206d | 361 | #else |
c27b3290 HG |
362 | if (dev->parent != NULL) { /* not root? */ |
363 | last_child = 1; | |
de39f8c1 | 364 | for (i = 0; i < dev->parent->maxchild; i++) { |
e887afc9 | 365 | /* search for children */ |
de39f8c1 MT |
366 | if (dev->parent->children[i] == dev) { |
367 | /* found our pointer, see if we have a | |
368 | * little sister | |
369 | */ | |
de39f8c1 MT |
370 | while (i++ < dev->parent->maxchild) { |
371 | if (dev->parent->children[i] != NULL) { | |
e887afc9 | 372 | /* found a sister */ |
de39f8c1 | 373 | last_child = 0; |
e887afc9 WD |
374 | break; |
375 | } /* if */ | |
376 | } /* while */ | |
377 | } /* device found */ | |
378 | } /* for all children of the parent */ | |
6a1b206d | 379 | #endif |
e887afc9 WD |
380 | printf("\b+-"); |
381 | /* correct last child */ | |
cad4291c | 382 | if (last_child && index) |
de39f8c1 | 383 | pre[index-1] = ' '; |
e887afc9 WD |
384 | } /* if not root hub */ |
385 | else | |
386 | printf(" "); | |
de39f8c1 MT |
387 | printf("%d ", dev->devnum); |
388 | pre[index++] = ' '; | |
389 | pre[index++] = has_child ? '|' : ' '; | |
390 | pre[index] = 0; | |
391 | printf(" %s (%s, %dmA)\n", usb_get_class_desc( | |
8f8bd565 | 392 | dev->config.if_desc[0].desc.bInterfaceClass), |
f1c1f540 | 393 | portspeed(dev->speed), |
8f8bd565 | 394 | dev->config.desc.bMaxPower * 2); |
de39f8c1 MT |
395 | if (strlen(dev->mf) || strlen(dev->prod) || strlen(dev->serial)) |
396 | printf(" %s %s %s %s\n", pre, dev->mf, dev->prod, dev->serial); | |
397 | printf(" %s\n", pre); | |
6a1b206d SG |
398 | #ifdef CONFIG_DM_USB |
399 | struct udevice *child; | |
400 | ||
401 | for (device_find_first_child(dev->dev, &child); | |
402 | child; | |
403 | device_find_next_child(&child)) { | |
404 | struct usb_device *udev; | |
405 | ||
406 | if (!device_active(child)) | |
407 | continue; | |
408 | ||
409 | udev = dev_get_parentdata(child); | |
410 | ||
411 | /* Ignore emulators, we only want real devices */ | |
412 | if (device_get_uclass_id(child) != UCLASS_USB_EMUL) { | |
413 | usb_show_tree_graph(udev, pre); | |
414 | pre[index] = 0; | |
415 | } | |
416 | } | |
417 | #else | |
de39f8c1 MT |
418 | if (dev->maxchild > 0) { |
419 | for (i = 0; i < dev->maxchild; i++) { | |
420 | if (dev->children[i] != NULL) { | |
421 | usb_show_tree_graph(dev->children[i], pre); | |
422 | pre[index] = 0; | |
e887afc9 WD |
423 | } |
424 | } | |
425 | } | |
6a1b206d | 426 | #endif |
e887afc9 WD |
427 | } |
428 | ||
429 | /* main routine for the tree command */ | |
088f1b19 | 430 | static void usb_show_tree(struct usb_device *dev) |
e887afc9 WD |
431 | { |
432 | char preamble[32]; | |
433 | ||
cad4291c | 434 | memset(preamble, '\0', sizeof(preamble)); |
de39f8c1 | 435 | usb_show_tree_graph(dev, &preamble[0]); |
e887afc9 WD |
436 | } |
437 | ||
7d9aa8fd JW |
438 | static int usb_test(struct usb_device *dev, int port, char* arg) |
439 | { | |
440 | int mode; | |
441 | ||
442 | if (port > dev->maxchild) { | |
443 | printf("Device is no hub or does not have %d ports.\n", port); | |
444 | return 1; | |
445 | } | |
446 | ||
447 | switch (arg[0]) { | |
448 | case 'J': | |
449 | case 'j': | |
450 | printf("Setting Test_J mode"); | |
451 | mode = USB_TEST_MODE_J; | |
452 | break; | |
453 | case 'K': | |
454 | case 'k': | |
455 | printf("Setting Test_K mode"); | |
456 | mode = USB_TEST_MODE_K; | |
457 | break; | |
458 | case 'S': | |
459 | case 's': | |
460 | printf("Setting Test_SE0_NAK mode"); | |
461 | mode = USB_TEST_MODE_SE0_NAK; | |
462 | break; | |
463 | case 'P': | |
464 | case 'p': | |
465 | printf("Setting Test_Packet mode"); | |
466 | mode = USB_TEST_MODE_PACKET; | |
467 | break; | |
468 | case 'F': | |
469 | case 'f': | |
470 | printf("Setting Test_Force_Enable mode"); | |
471 | mode = USB_TEST_MODE_FORCE_ENABLE; | |
472 | break; | |
473 | default: | |
474 | printf("Unrecognized test mode: %s\nAvailable modes: " | |
475 | "J, K, S[E0_NAK], P[acket], F[orce_Enable]\n", arg); | |
476 | return 1; | |
477 | } | |
478 | ||
479 | if (port) | |
480 | printf(" on downstream facing port %d...\n", port); | |
481 | else | |
482 | printf(" on upstream facing port...\n"); | |
483 | ||
484 | if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_FEATURE, | |
485 | port ? USB_RT_PORT : USB_RECIP_DEVICE, | |
486 | port ? USB_PORT_FEAT_TEST : USB_FEAT_TEST, | |
487 | (mode << 8) | port, | |
488 | NULL, 0, USB_CNTL_TIMEOUT) == -1) { | |
489 | printf("Error during SET_FEATURE.\n"); | |
490 | return 1; | |
491 | } else { | |
492 | printf("Test mode successfully set. Use 'usb start' " | |
493 | "to return to normal operation.\n"); | |
494 | return 0; | |
495 | } | |
496 | } | |
497 | ||
e887afc9 | 498 | |
e887afc9 WD |
499 | /****************************************************************************** |
500 | * usb boot command intepreter. Derived from diskboot | |
501 | */ | |
502 | #ifdef CONFIG_USB_STORAGE | |
088f1b19 | 503 | static int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
e887afc9 | 504 | { |
7405a133 | 505 | return common_diskboot(cmdtp, "usb", argc, argv); |
e887afc9 WD |
506 | } |
507 | #endif /* CONFIG_USB_STORAGE */ | |
508 | ||
8a8a2257 | 509 | static int do_usb_stop_keyboard(int force) |
6e78c74f HG |
510 | { |
511 | #ifdef CONFIG_USB_KEYBOARD | |
8a8a2257 | 512 | if (usb_kbd_deregister(force) != 0) { |
6e78c74f HG |
513 | printf("USB not stopped: usbkbd still using USB\n"); |
514 | return 1; | |
515 | } | |
516 | #endif | |
517 | return 0; | |
518 | } | |
e887afc9 | 519 | |
b5072264 HG |
520 | static void do_usb_start(void) |
521 | { | |
522 | bootstage_mark_name(BOOTSTAGE_ID_USB_START, "usb_start"); | |
523 | ||
524 | if (usb_init() < 0) | |
525 | return; | |
526 | ||
6a1b206d SG |
527 | /* Driver model will probe the devices as they are found */ |
528 | #ifndef CONFIG_DM_USB | |
b5072264 HG |
529 | #ifdef CONFIG_USB_STORAGE |
530 | /* try to recognize storage devices immediately */ | |
531 | usb_stor_curr_dev = usb_stor_scan(1); | |
532 | #endif | |
389f1856 | 533 | #endif |
b5072264 | 534 | #ifdef CONFIG_USB_HOST_ETHER |
69559093 | 535 | # ifdef CONFIG_DM_ETH |
389f1856 MZ |
536 | # ifndef CONFIG_DM_USB |
537 | # error "You must use CONFIG_DM_USB if you want to use CONFIG_USB_HOST_ETHER with CONFIG_DM_ETH" | |
538 | # endif | |
539 | # else | |
b5072264 HG |
540 | /* try to recognize ethernet devices immediately */ |
541 | usb_ether_curr_dev = usb_host_eth_scan(1); | |
389f1856 | 542 | # endif |
69559093 | 543 | #endif |
b5072264 HG |
544 | #ifdef CONFIG_USB_KEYBOARD |
545 | drv_usb_kbd_init(); | |
546 | #endif | |
547 | } | |
548 | ||
6a1b206d SG |
549 | #ifdef CONFIG_DM_USB |
550 | static void show_info(struct udevice *dev) | |
551 | { | |
552 | struct udevice *child; | |
553 | struct usb_device *udev; | |
554 | ||
555 | udev = dev_get_parentdata(dev); | |
556 | usb_display_desc(udev); | |
557 | usb_display_config(udev); | |
558 | for (device_find_first_child(dev, &child); | |
559 | child; | |
560 | device_find_next_child(&child)) { | |
561 | if (device_active(child)) | |
562 | show_info(child); | |
563 | } | |
564 | } | |
565 | ||
566 | static int usb_device_info(void) | |
567 | { | |
568 | struct udevice *bus; | |
569 | ||
570 | for (uclass_first_device(UCLASS_USB, &bus); | |
571 | bus; | |
572 | uclass_next_device(&bus)) { | |
573 | struct udevice *hub; | |
574 | ||
575 | device_find_first_child(bus, &hub); | |
576 | if (device_get_uclass_id(hub) == UCLASS_USB_HUB && | |
577 | device_active(hub)) { | |
578 | show_info(hub); | |
579 | } | |
580 | } | |
581 | ||
582 | return 0; | |
583 | } | |
584 | #endif | |
585 | ||
de39f8c1 | 586 | /****************************************************************************** |
e887afc9 WD |
587 | * usb command intepreter |
588 | */ | |
088f1b19 | 589 | static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
e887afc9 | 590 | { |
cad4291c | 591 | struct usb_device *udev = NULL; |
e887afc9 | 592 | int i; |
e51aae38 | 593 | extern char usb_started; |
1968e615 | 594 | #ifdef CONFIG_USB_STORAGE |
e887afc9 | 595 | block_dev_desc_t *stor_dev; |
1968e615 | 596 | #endif |
e887afc9 | 597 | |
47e26b1b | 598 | if (argc < 2) |
4c12eeb8 | 599 | return CMD_RET_USAGE; |
65d34254 | 600 | |
b5072264 HG |
601 | if (strncmp(argv[1], "start", 5) == 0) { |
602 | if (usb_started) | |
603 | return 0; /* Already started */ | |
604 | printf("starting USB...\n"); | |
605 | do_usb_start(); | |
606 | return 0; | |
607 | } | |
608 | ||
609 | if (strncmp(argv[1], "reset", 5) == 0) { | |
610 | printf("resetting USB...\n"); | |
8a8a2257 | 611 | if (do_usb_stop_keyboard(1) != 0) |
6e78c74f | 612 | return 1; |
e887afc9 | 613 | usb_stop(); |
b5072264 | 614 | do_usb_start(); |
e887afc9 WD |
615 | return 0; |
616 | } | |
de39f8c1 | 617 | if (strncmp(argv[1], "stop", 4) == 0) { |
6e78c74f | 618 | if (argc != 2) |
de39f8c1 | 619 | console_assign(stdin, "serial"); |
8a8a2257 | 620 | if (do_usb_stop_keyboard(0) != 0) |
6e78c74f | 621 | return 1; |
e887afc9 WD |
622 | printf("stopping USB..\n"); |
623 | usb_stop(); | |
624 | return 0; | |
625 | } | |
e51aae38 BS |
626 | if (!usb_started) { |
627 | printf("USB is stopped. Please issue 'usb start' first.\n"); | |
628 | return 1; | |
629 | } | |
de39f8c1 | 630 | if (strncmp(argv[1], "tree", 4) == 0) { |
93c2582f | 631 | puts("USB device tree:\n"); |
6a1b206d SG |
632 | #ifdef CONFIG_DM_USB |
633 | struct udevice *bus; | |
634 | ||
635 | for (uclass_first_device(UCLASS_USB, &bus); | |
636 | bus; | |
637 | uclass_next_device(&bus)) { | |
638 | struct usb_device *udev; | |
fd1bd21b | 639 | struct udevice *dev; |
6a1b206d | 640 | |
fd1bd21b HG |
641 | device_find_first_child(bus, &dev); |
642 | if (dev && device_active(dev)) { | |
643 | udev = dev_get_parentdata(dev); | |
6a1b206d SG |
644 | usb_show_tree(udev); |
645 | } | |
646 | } | |
647 | #else | |
93c2582f | 648 | for (i = 0; i < USB_MAX_DEVICE; i++) { |
cad4291c SG |
649 | udev = usb_get_dev_index(i); |
650 | if (udev == NULL) | |
93c2582f | 651 | break; |
cad4291c SG |
652 | if (udev->parent == NULL) |
653 | usb_show_tree(udev); | |
93c2582f | 654 | } |
6a1b206d | 655 | #endif |
e887afc9 WD |
656 | return 0; |
657 | } | |
de39f8c1 | 658 | if (strncmp(argv[1], "inf", 3) == 0) { |
de39f8c1 | 659 | if (argc == 2) { |
6a1b206d SG |
660 | #ifdef CONFIG_DM_USB |
661 | usb_device_info(); | |
662 | #else | |
663 | int d; | |
de39f8c1 | 664 | for (d = 0; d < USB_MAX_DEVICE; d++) { |
cad4291c SG |
665 | udev = usb_get_dev_index(d); |
666 | if (udev == NULL) | |
e887afc9 | 667 | break; |
cad4291c SG |
668 | usb_display_desc(udev); |
669 | usb_display_config(udev); | |
e887afc9 | 670 | } |
6a1b206d | 671 | #endif |
e887afc9 | 672 | return 0; |
de39f8c1 | 673 | } else { |
6a1b206d SG |
674 | /* |
675 | * With driver model this isn't right since we can | |
676 | * have multiple controllers and the device numbering | |
677 | * starts at 1 on each bus. | |
678 | */ | |
7d9aa8fd | 679 | i = simple_strtoul(argv[2], NULL, 10); |
de39f8c1 | 680 | printf("config for device %d\n", i); |
cad4291c SG |
681 | udev = usb_find_device(i); |
682 | if (udev == NULL) { | |
6052cbab | 683 | printf("*** No device available ***\n"); |
e887afc9 | 684 | return 0; |
de39f8c1 | 685 | } else { |
cad4291c SG |
686 | usb_display_desc(udev); |
687 | usb_display_config(udev); | |
e887afc9 WD |
688 | } |
689 | } | |
690 | return 0; | |
691 | } | |
7d9aa8fd JW |
692 | if (strncmp(argv[1], "test", 4) == 0) { |
693 | if (argc < 5) | |
694 | return CMD_RET_USAGE; | |
695 | i = simple_strtoul(argv[2], NULL, 10); | |
cad4291c SG |
696 | udev = usb_find_device(i); |
697 | if (udev == NULL) { | |
7d9aa8fd JW |
698 | printf("Device %d does not exist.\n", i); |
699 | return 1; | |
700 | } | |
701 | i = simple_strtoul(argv[3], NULL, 10); | |
cad4291c | 702 | return usb_test(udev, i, argv[4]); |
7d9aa8fd | 703 | } |
e887afc9 | 704 | #ifdef CONFIG_USB_STORAGE |
de39f8c1 | 705 | if (strncmp(argv[1], "stor", 4) == 0) |
f6b44e0e | 706 | return usb_stor_info(); |
9c998aa8 | 707 | |
de39f8c1 | 708 | if (strncmp(argv[1], "part", 4) == 0) { |
d4b5f3fa | 709 | int devno, ok = 0; |
de39f8c1 | 710 | if (argc == 2) { |
aaad108b | 711 | for (devno = 0; ; ++devno) { |
de39f8c1 | 712 | stor_dev = usb_stor_get_dev(devno); |
aaad108b KH |
713 | if (stor_dev == NULL) |
714 | break; | |
de39f8c1 | 715 | if (stor_dev->type != DEV_TYPE_UNKNOWN) { |
d4b5f3fa CE |
716 | ok++; |
717 | if (devno) | |
718 | printf("\n"); | |
060f2853 | 719 | debug("print_part of %x\n", devno); |
d4b5f3fa CE |
720 | print_part(stor_dev); |
721 | } | |
722 | } | |
de39f8c1 MT |
723 | } else { |
724 | devno = simple_strtoul(argv[2], NULL, 16); | |
725 | stor_dev = usb_stor_get_dev(devno); | |
aaad108b KH |
726 | if (stor_dev != NULL && |
727 | stor_dev->type != DEV_TYPE_UNKNOWN) { | |
e887afc9 | 728 | ok++; |
060f2853 | 729 | debug("print_part of %x\n", devno); |
e887afc9 WD |
730 | print_part(stor_dev); |
731 | } | |
732 | } | |
733 | if (!ok) { | |
734 | printf("\nno USB devices available\n"); | |
735 | return 1; | |
736 | } | |
737 | return 0; | |
738 | } | |
de39f8c1 MT |
739 | if (strcmp(argv[1], "read") == 0) { |
740 | if (usb_stor_curr_dev < 0) { | |
e887afc9 WD |
741 | printf("no current device selected\n"); |
742 | return 1; | |
743 | } | |
de39f8c1 | 744 | if (argc == 5) { |
e887afc9 WD |
745 | unsigned long addr = simple_strtoul(argv[2], NULL, 16); |
746 | unsigned long blk = simple_strtoul(argv[3], NULL, 16); | |
747 | unsigned long cnt = simple_strtoul(argv[4], NULL, 16); | |
748 | unsigned long n; | |
de39f8c1 MT |
749 | printf("\nUSB read: device %d block # %ld, count %ld" |
750 | " ... ", usb_stor_curr_dev, blk, cnt); | |
751 | stor_dev = usb_stor_get_dev(usb_stor_curr_dev); | |
752 | n = stor_dev->block_read(usb_stor_curr_dev, blk, cnt, | |
753 | (ulong *)addr); | |
754 | printf("%ld blocks read: %s\n", n, | |
755 | (n == cnt) ? "OK" : "ERROR"); | |
756 | if (n == cnt) | |
e887afc9 WD |
757 | return 0; |
758 | return 1; | |
759 | } | |
760 | } | |
127e1084 MJ |
761 | if (strcmp(argv[1], "write") == 0) { |
762 | if (usb_stor_curr_dev < 0) { | |
763 | printf("no current device selected\n"); | |
764 | return 1; | |
765 | } | |
766 | if (argc == 5) { | |
767 | unsigned long addr = simple_strtoul(argv[2], NULL, 16); | |
768 | unsigned long blk = simple_strtoul(argv[3], NULL, 16); | |
769 | unsigned long cnt = simple_strtoul(argv[4], NULL, 16); | |
770 | unsigned long n; | |
771 | printf("\nUSB write: device %d block # %ld, count %ld" | |
772 | " ... ", usb_stor_curr_dev, blk, cnt); | |
773 | stor_dev = usb_stor_get_dev(usb_stor_curr_dev); | |
774 | n = stor_dev->block_write(usb_stor_curr_dev, blk, cnt, | |
775 | (ulong *)addr); | |
776 | printf("%ld blocks write: %s\n", n, | |
777 | (n == cnt) ? "OK" : "ERROR"); | |
778 | if (n == cnt) | |
779 | return 0; | |
780 | return 1; | |
781 | } | |
782 | } | |
9c998aa8 WD |
783 | if (strncmp(argv[1], "dev", 3) == 0) { |
784 | if (argc == 3) { | |
e887afc9 | 785 | int dev = (int)simple_strtoul(argv[2], NULL, 10); |
de39f8c1 | 786 | printf("\nUSB device %d: ", dev); |
aaad108b KH |
787 | stor_dev = usb_stor_get_dev(dev); |
788 | if (stor_dev == NULL) { | |
e887afc9 WD |
789 | printf("unknown device\n"); |
790 | return 1; | |
791 | } | |
de39f8c1 | 792 | printf("\n Device %d: ", dev); |
e887afc9 | 793 | dev_print(stor_dev); |
de39f8c1 | 794 | if (stor_dev->type == DEV_TYPE_UNKNOWN) |
e887afc9 | 795 | return 1; |
e887afc9 WD |
796 | usb_stor_curr_dev = dev; |
797 | printf("... is now current device\n"); | |
798 | return 0; | |
de39f8c1 MT |
799 | } else { |
800 | printf("\nUSB device %d: ", usb_stor_curr_dev); | |
801 | stor_dev = usb_stor_get_dev(usb_stor_curr_dev); | |
e887afc9 | 802 | dev_print(stor_dev); |
de39f8c1 | 803 | if (stor_dev->type == DEV_TYPE_UNKNOWN) |
e887afc9 | 804 | return 1; |
e887afc9 WD |
805 | return 0; |
806 | } | |
807 | return 0; | |
808 | } | |
809 | #endif /* CONFIG_USB_STORAGE */ | |
4c12eeb8 | 810 | return CMD_RET_USAGE; |
e887afc9 WD |
811 | } |
812 | ||
0d498393 WD |
813 | U_BOOT_CMD( |
814 | usb, 5, 1, do_usb, | |
2fb2604d | 815 | "USB sub-system", |
1af9f963 VPP |
816 | "start - start (scan) USB controller\n" |
817 | "usb reset - reset (rescan) USB controller\n" | |
b3813a22 VPP |
818 | "usb stop [f] - stop USB [f]=force stop\n" |
819 | "usb tree - show USB device tree\n" | |
5cf91d6b | 820 | "usb info [dev] - show available USB devices\n" |
7d9aa8fd JW |
821 | "usb test [dev] [port] [mode] - set USB 2.0 test mode\n" |
822 | " (specify port 0 to indicate the device's upstream port)\n" | |
823 | " Available modes: J, K, S[E0_NAK], P[acket], F[orce_Enable]\n" | |
824 | #ifdef CONFIG_USB_STORAGE | |
b3813a22 | 825 | "usb storage - show details of USB storage devices\n" |
342717f7 | 826 | "usb dev [dev] - show or set current USB storage device\n" |
de39f8c1 | 827 | "usb part [dev] - print partition table of one or all USB storage" |
7d9aa8fd | 828 | " devices\n" |
5cf91d6b | 829 | "usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n" |
842404ea | 830 | " to memory address `addr'\n" |
127e1084 MJ |
831 | "usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'\n" |
832 | " from memory address `addr'" | |
7d9aa8fd | 833 | #endif /* CONFIG_USB_STORAGE */ |
8bde7f77 WD |
834 | ); |
835 | ||
836 | ||
7d9aa8fd | 837 | #ifdef CONFIG_USB_STORAGE |
0d498393 WD |
838 | U_BOOT_CMD( |
839 | usbboot, 3, 1, do_usbboot, | |
2fb2604d | 840 | "boot from USB device", |
a89c33db | 841 | "loadAddr dev:part" |
8bde7f77 | 842 | ); |
7d9aa8fd | 843 | #endif /* CONFIG_USB_STORAGE */ |