1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2001
4 * Denis Peter, MPL AG Switzerland
5 *
6 * Adapted for U-Boot driver model
7 * (C) Copyright 2015 Google, Inc
8 *
9 * Most of this source has been derived from the Linux USB
10 * project.
11 */
12
13 #include <common.h>
14 #include <command.h>
15 #include <console.h>
16 #include <dm.h>
17 #include <dm/uclass-internal.h>
18 #include <memalign.h>
19 #include <asm/byteorder.h>
20 #include <asm/unaligned.h>
21 #include <part.h>
22 #include <usb.h>
23
24 #ifdef CONFIG_USB_STORAGE
25 static int usb_stor_curr_dev = -1; /* current device */
26 #endif
27 #if defined(CONFIG_USB_HOST_ETHER) && !defined(CONFIG_DM_ETH)
28 static int __maybe_unused usb_ether_curr_dev = -1; /* current ethernet device */
29 #endif
30
31 /* some display routines (info command) */
usb_get_class_desc(unsigned char dclass)32 static char *usb_get_class_desc(unsigned char dclass)
33 {
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 "";
55 }
56 }
57
usb_display_class_sub(unsigned char dclass,unsigned char subclass,unsigned char proto)58 static void usb_display_class_sub(unsigned char dclass, unsigned char subclass,
59 unsigned char proto)
60 {
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");
70 break;
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;
86 }
87 break;
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");
128 break;
129 default:
130 printf("reserved");
131 break;
132 }
133 break;
134 default:
135 printf("%s", usb_get_class_desc(dclass));
136 break;
137 }
138 }
139
usb_display_string(struct usb_device * dev,int index)140 static void usb_display_string(struct usb_device *dev, int index)
141 {
142 ALLOC_CACHE_ALIGN_BUFFER(char, buffer, 256);
143
144 if (index != 0) {
145 if (usb_string(dev, index, &buffer[0], 256) > 0)
146 printf("String: \"%s\"", buffer);
147 }
148 }
149
usb_display_desc(struct usb_device * dev)150 static void usb_display_desc(struct usb_device *dev)
151 {
152 uint packet_size = dev->descriptor.bMaxPacketSize0;
153
154 if (dev->descriptor.bDescriptorType == USB_DT_DEVICE) {
155 printf("%d: %s, USB Revision %x.%x\n", dev->devnum,
156 usb_get_class_desc(dev->config.if_desc[0].desc.bInterfaceClass),
157 (dev->descriptor.bcdUSB>>8) & 0xff,
158 dev->descriptor.bcdUSB & 0xff);
159
160 if (strlen(dev->mf) || strlen(dev->prod) ||
161 strlen(dev->serial))
162 printf(" - %s %s %s\n", dev->mf, dev->prod,
163 dev->serial);
164 if (dev->descriptor.bDeviceClass) {
165 printf(" - Class: ");
166 usb_display_class_sub(dev->descriptor.bDeviceClass,
167 dev->descriptor.bDeviceSubClass,
168 dev->descriptor.bDeviceProtocol);
169 printf("\n");
170 } else {
171 printf(" - Class: (from Interface) %s\n",
172 usb_get_class_desc(
173 dev->config.if_desc[0].desc.bInterfaceClass));
174 }
175 if (dev->descriptor.bcdUSB >= cpu_to_le16(0x0300))
176 packet_size = 1 << packet_size;
177 printf(" - PacketSize: %d Configurations: %d\n",
178 packet_size, dev->descriptor.bNumConfigurations);
179 printf(" - Vendor: 0x%04x Product 0x%04x Version %d.%d\n",
180 dev->descriptor.idVendor, dev->descriptor.idProduct,
181 (dev->descriptor.bcdDevice>>8) & 0xff,
182 dev->descriptor.bcdDevice & 0xff);
183 }
184
185 }
186
usb_display_conf_desc(struct usb_config_descriptor * config,struct usb_device * dev)187 static void usb_display_conf_desc(struct usb_config_descriptor *config,
188 struct usb_device *dev)
189 {
190 printf(" Configuration: %d\n", config->bConfigurationValue);
191 printf(" - Interfaces: %d %s%s%dmA\n", config->bNumInterfaces,
192 (config->bmAttributes & 0x40) ? "Self Powered " : "Bus Powered ",
193 (config->bmAttributes & 0x20) ? "Remote Wakeup " : "",
194 config->bMaxPower*2);
195 if (config->iConfiguration) {
196 printf(" - ");
197 usb_display_string(dev, config->iConfiguration);
198 printf("\n");
199 }
200 }
201
usb_display_if_desc(struct usb_interface_descriptor * ifdesc,struct usb_device * dev)202 static void usb_display_if_desc(struct usb_interface_descriptor *ifdesc,
203 struct usb_device *dev)
204 {
205 printf(" Interface: %d\n", ifdesc->bInterfaceNumber);
206 printf(" - Alternate Setting %d, Endpoints: %d\n",
207 ifdesc->bAlternateSetting, ifdesc->bNumEndpoints);
208 printf(" - Class ");
209 usb_display_class_sub(ifdesc->bInterfaceClass,
210 ifdesc->bInterfaceSubClass, ifdesc->bInterfaceProtocol);
211 printf("\n");
212 if (ifdesc->iInterface) {
213 printf(" - ");
214 usb_display_string(dev, ifdesc->iInterface);
215 printf("\n");
216 }
217 }
218
usb_display_ep_desc(struct usb_endpoint_descriptor * epdesc)219 static void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc)
220 {
221 printf(" - Endpoint %d %s ", epdesc->bEndpointAddress & 0xf,
222 (epdesc->bEndpointAddress & 0x80) ? "In" : "Out");
223 switch ((epdesc->bmAttributes & 0x03)) {
224 case 0:
225 printf("Control");
226 break;
227 case 1:
228 printf("Isochronous");
229 break;
230 case 2:
231 printf("Bulk");
232 break;
233 case 3:
234 printf("Interrupt");
235 break;
236 }
237 printf(" MaxPacket %d", get_unaligned(&epdesc->wMaxPacketSize));
238 if ((epdesc->bmAttributes & 0x03) == 0x3)
239 printf(" Interval %dms", epdesc->bInterval);
240 printf("\n");
241 }
242
243 /* main routine to diasplay the configs, interfaces and endpoints */
usb_display_config(struct usb_device * dev)244 static void usb_display_config(struct usb_device *dev)
245 {
246 struct usb_config *config;
247 struct usb_interface *ifdesc;
248 struct usb_endpoint_descriptor *epdesc;
249 int i, ii;
250
251 config = &dev->config;
252 usb_display_conf_desc(&config->desc, dev);
253 for (i = 0; i < config->no_of_if; i++) {
254 ifdesc = &config->if_desc[i];
255 usb_display_if_desc(&ifdesc->desc, dev);
256 for (ii = 0; ii < ifdesc->no_of_ep; ii++) {
257 epdesc = &ifdesc->ep_desc[ii];
258 usb_display_ep_desc(epdesc);
259 }
260 }
261 printf("\n");
262 }
263
264 /*
265 * With driver model this isn't right since we can have multiple controllers
266 * and the device numbering starts at 1 on each bus.
267 * TODO(sjg@chromium.org): Add a way to specify the controller/bus.
268 */
usb_find_device(int devnum)269 static struct usb_device *usb_find_device(int devnum)
270 {
271 #ifdef CONFIG_DM_USB
272 struct usb_device *udev;
273 struct udevice *hub;
274 struct uclass *uc;
275 int ret;
276
277 /* Device addresses start at 1 */
278 devnum++;
279 ret = uclass_get(UCLASS_USB_HUB, &uc);
280 if (ret)
281 return NULL;
282
283 uclass_foreach_dev(hub, uc) {
284 struct udevice *dev;
285
286 if (!device_active(hub))
287 continue;
288 udev = dev_get_parent_priv(hub);
289 if (udev->devnum == devnum)
290 return udev;
291
292 for (device_find_first_child(hub, &dev);
293 dev;
294 device_find_next_child(&dev)) {
295 if (!device_active(hub))
296 continue;
297
298 udev = dev_get_parent_priv(dev);
299 if (udev->devnum == devnum)
300 return udev;
301 }
302 }
303 #else
304 struct usb_device *udev;
305 int d;
306
307 for (d = 0; d < USB_MAX_DEVICE; d++) {
308 udev = usb_get_dev_index(d);
309 if (udev == NULL)
310 return NULL;
311 if (udev->devnum == devnum)
312 return udev;
313 }
314 #endif
315
316 return NULL;
317 }
318
portspeed(int speed)319 static inline const char *portspeed(int speed)
320 {
321 switch (speed) {
322 case USB_SPEED_SUPER:
323 return "5 Gb/s";
324 case USB_SPEED_HIGH:
325 return "480 Mb/s";
326 case USB_SPEED_LOW:
327 return "1.5 Mb/s";
328 default:
329 return "12 Mb/s";
330 }
331 }
332
333 /* shows the device tree recursively */
usb_show_tree_graph(struct usb_device * dev,char * pre)334 static void usb_show_tree_graph(struct usb_device *dev, char *pre)
335 {
336 int index;
337 int has_child, last_child;
338
339 index = strlen(pre);
340 printf(" %s", pre);
341 #ifdef CONFIG_DM_USB
342 has_child = device_has_active_children(dev->dev);
343 if (device_get_uclass_id(dev->dev) == UCLASS_MASS_STORAGE) {
344 struct udevice *child;
345
346 for (device_find_first_child(dev->dev, &child);
347 child;
348 device_find_next_child(&child)) {
349 if (device_get_uclass_id(child) == UCLASS_BLK)
350 has_child = 0;
351 }
352 }
353 #else
354 /* check if the device has connected children */
355 int i;
356
357 has_child = 0;
358 for (i = 0; i < dev->maxchild; i++) {
359 if (dev->children[i] != NULL)
360 has_child = 1;
361 }
362 #endif
363 /* check if we are the last one */
364 #ifdef CONFIG_DM_USB
365 /* Not the root of the usb tree? */
366 if (device_get_uclass_id(dev->dev->parent) != UCLASS_USB) {
367 last_child = device_is_last_sibling(dev->dev);
368 #else
369 if (dev->parent != NULL) { /* not root? */
370 last_child = 1;
371 for (i = 0; i < dev->parent->maxchild; i++) {
372 /* search for children */
373 if (dev->parent->children[i] == dev) {
374 /* found our pointer, see if we have a
375 * little sister
376 */
377 while (i++ < dev->parent->maxchild) {
378 if (dev->parent->children[i] != NULL) {
379 /* found a sister */
380 last_child = 0;
381 break;
382 } /* if */
383 } /* while */
384 } /* device found */
385 } /* for all children of the parent */
386 #endif
387 printf("\b+-");
388 /* correct last child */
389 if (last_child && index)
390 pre[index-1] = ' ';
391 } /* if not root hub */
392 else
393 printf(" ");
394 printf("%d ", dev->devnum);
395 pre[index++] = ' ';
396 pre[index++] = has_child ? '|' : ' ';
397 pre[index] = 0;
398 printf(" %s (%s, %dmA)\n", usb_get_class_desc(
399 dev->config.if_desc[0].desc.bInterfaceClass),
400 portspeed(dev->speed),
401 dev->config.desc.bMaxPower * 2);
402 if (strlen(dev->mf) || strlen(dev->prod) || strlen(dev->serial))
403 printf(" %s %s %s %s\n", pre, dev->mf, dev->prod, dev->serial);
404 printf(" %s\n", pre);
405 #ifdef CONFIG_DM_USB
406 struct udevice *child;
407
408 for (device_find_first_child(dev->dev, &child);
409 child;
410 device_find_next_child(&child)) {
411 struct usb_device *udev;
412
413 if (!device_active(child))
414 continue;
415
416 udev = dev_get_parent_priv(child);
417
418 /*
419 * Ignore emulators and block child devices, we only want
420 * real devices
421 */
422 if ((device_get_uclass_id(child) != UCLASS_USB_EMUL) &&
423 (device_get_uclass_id(child) != UCLASS_BLK)) {
424 usb_show_tree_graph(udev, pre);
425 pre[index] = 0;
426 }
427 }
428 #else
429 if (dev->maxchild > 0) {
430 for (i = 0; i < dev->maxchild; i++) {
431 if (dev->children[i] != NULL) {
432 usb_show_tree_graph(dev->children[i], pre);
433 pre[index] = 0;
434 }
435 }
436 }
437 #endif
438 }
439
440 /* main routine for the tree command */
441 static void usb_show_subtree(struct usb_device *dev)
442 {
443 char preamble[32];
444
445 memset(preamble, '\0', sizeof(preamble));
446 usb_show_tree_graph(dev, &preamble[0]);
447 }
448
449 #ifdef CONFIG_DM_USB
450 typedef void (*usb_dev_func_t)(struct usb_device *udev);
451
452 static void usb_for_each_root_dev(usb_dev_func_t func)
453 {
454 struct udevice *bus;
455
456 for (uclass_find_first_device(UCLASS_USB, &bus);
457 bus;
458 uclass_find_next_device(&bus)) {
459 struct usb_device *udev;
460 struct udevice *dev;
461
462 if (!device_active(bus))
463 continue;
464
465 device_find_first_child(bus, &dev);
466 if (dev && device_active(dev)) {
467 udev = dev_get_parent_priv(dev);
468 func(udev);
469 }
470 }
471 }
472 #endif
473
474 void usb_show_tree(void)
475 {
476 #ifdef CONFIG_DM_USB
477 usb_for_each_root_dev(usb_show_subtree);
478 #else
479 struct usb_device *udev;
480 int i;
481
482 for (i = 0; i < USB_MAX_DEVICE; i++) {
483 udev = usb_get_dev_index(i);
484 if (udev == NULL)
485 break;
486 if (udev->parent == NULL)
487 usb_show_subtree(udev);
488 }
489 #endif
490 }
491
492 static int usb_test(struct usb_device *dev, int port, char* arg)
493 {
494 int mode;
495
496 if (port > dev->maxchild) {
497 printf("Device is no hub or does not have %d ports.\n", port);
498 return 1;
499 }
500
501 switch (arg[0]) {
502 case 'J':
503 case 'j':
504 printf("Setting Test_J mode");
505 mode = USB_TEST_MODE_J;
506 break;
507 case 'K':
508 case 'k':
509 printf("Setting Test_K mode");
510 mode = USB_TEST_MODE_K;
511 break;
512 case 'S':
513 case 's':
514 printf("Setting Test_SE0_NAK mode");
515 mode = USB_TEST_MODE_SE0_NAK;
516 break;
517 case 'P':
518 case 'p':
519 printf("Setting Test_Packet mode");
520 mode = USB_TEST_MODE_PACKET;
521 break;
522 case 'F':
523 case 'f':
524 printf("Setting Test_Force_Enable mode");
525 mode = USB_TEST_MODE_FORCE_ENABLE;
526 break;
527 default:
528 printf("Unrecognized test mode: %s\nAvailable modes: "
529 "J, K, S[E0_NAK], P[acket], F[orce_Enable]\n", arg);
530 return 1;
531 }
532
533 if (port)
534 printf(" on downstream facing port %d...\n", port);
535 else
536 printf(" on upstream facing port...\n");
537
538 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_FEATURE,
539 port ? USB_RT_PORT : USB_RECIP_DEVICE,
540 port ? USB_PORT_FEAT_TEST : USB_FEAT_TEST,
541 (mode << 8) | port,
542 NULL, 0, USB_CNTL_TIMEOUT) == -1) {
543 printf("Error during SET_FEATURE.\n");
544 return 1;
545 } else {
546 printf("Test mode successfully set. Use 'usb start' "
547 "to return to normal operation.\n");
548 return 0;
549 }
550 }
551
552
553 /******************************************************************************
554 * usb boot command intepreter. Derived from diskboot
555 */
556 #ifdef CONFIG_USB_STORAGE
557 static int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
558 {
559 return common_diskboot(cmdtp, "usb", argc, argv);
560 }
561 #endif /* CONFIG_USB_STORAGE */
562
563 static int do_usb_stop_keyboard(int force)
564 {
565 #if !defined CONFIG_DM_USB && defined CONFIG_USB_KEYBOARD
566 if (usb_kbd_deregister(force) != 0) {
567 printf("USB not stopped: usbkbd still using USB\n");
568 return 1;
569 }
570 #endif
571 return 0;
572 }
573
574 static void do_usb_start(void)
575 {
576 bootstage_mark_name(BOOTSTAGE_ID_USB_START, "usb_start");
577
578 if (usb_init() < 0)
579 return;
580
581 /* Driver model will probe the devices as they are found */
582 # ifdef CONFIG_USB_STORAGE
583 /* try to recognize storage devices immediately */
584 usb_stor_curr_dev = usb_stor_scan(1);
585 # endif
586 #ifndef CONFIG_DM_USB
587 # ifdef CONFIG_USB_KEYBOARD
588 drv_usb_kbd_init();
589 # endif
590 #endif /* !CONFIG_DM_USB */
591 #ifdef CONFIG_USB_HOST_ETHER
592 # ifdef CONFIG_DM_ETH
593 # ifndef CONFIG_DM_USB
594 # error "You must use CONFIG_DM_USB if you want to use CONFIG_USB_HOST_ETHER with CONFIG_DM_ETH"
595 # endif
596 # else
597 /* try to recognize ethernet devices immediately */
598 usb_ether_curr_dev = usb_host_eth_scan(1);
599 # endif
600 #endif
601 }
602
603 #ifdef CONFIG_DM_USB
604 static void usb_show_info(struct usb_device *udev)
605 {
606 struct udevice *child;
607
608 usb_display_desc(udev);
609 usb_display_config(udev);
610 for (device_find_first_child(udev->dev, &child);
611 child;
612 device_find_next_child(&child)) {
613 if (device_active(child) &&
614 (device_get_uclass_id(child) != UCLASS_USB_EMUL) &&
615 (device_get_uclass_id(child) != UCLASS_BLK)) {
616 udev = dev_get_parent_priv(child);
617 usb_show_info(udev);
618 }
619 }
620 }
621 #endif
622
623 /******************************************************************************
624 * usb command intepreter
625 */
626 static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
627 {
628 struct usb_device *udev = NULL;
629 int i;
630 extern char usb_started;
631
632 if (argc < 2)
633 return CMD_RET_USAGE;
634
635 if (strncmp(argv[1], "start", 5) == 0) {
636 if (usb_started)
637 return 0; /* Already started */
638 printf("starting USB...\n");
639 do_usb_start();
640 return 0;
641 }
642
643 if (strncmp(argv[1], "reset", 5) == 0) {
644 printf("resetting USB...\n");
645 if (do_usb_stop_keyboard(1) != 0)
646 return 1;
647 usb_stop();
648 do_usb_start();
649 return 0;
650 }
651 if (strncmp(argv[1], "stop", 4) == 0) {
652 if (argc != 2)
653 console_assign(stdin, "serial");
654 if (do_usb_stop_keyboard(0) != 0)
655 return 1;
656 printf("stopping USB..\n");
657 usb_stop();
658 return 0;
659 }
660 if (!usb_started) {
661 printf("USB is stopped. Please issue 'usb start' first.\n");
662 return 1;
663 }
664 if (strncmp(argv[1], "tree", 4) == 0) {
665 puts("USB device tree:\n");
666 usb_show_tree();
667 return 0;
668 }
669 if (strncmp(argv[1], "inf", 3) == 0) {
670 if (argc == 2) {
671 #ifdef CONFIG_DM_USB
672 usb_for_each_root_dev(usb_show_info);
673 #else
674 int d;
675 for (d = 0; d < USB_MAX_DEVICE; d++) {
676 udev = usb_get_dev_index(d);
677 if (udev == NULL)
678 break;
679 usb_display_desc(udev);
680 usb_display_config(udev);
681 }
682 #endif
683 return 0;
684 } else {
685 /*
686 * With driver model this isn't right since we can
687 * have multiple controllers and the device numbering
688 * starts at 1 on each bus.
689 */
690 i = simple_strtoul(argv[2], NULL, 10);
691 printf("config for device %d\n", i);
692 udev = usb_find_device(i);
693 if (udev == NULL) {
694 printf("*** No device available ***\n");
695 return 0;
696 } else {
697 usb_display_desc(udev);
698 usb_display_config(udev);
699 }
700 }
701 return 0;
702 }
703 if (strncmp(argv[1], "test", 4) == 0) {
704 if (argc < 5)
705 return CMD_RET_USAGE;
706 i = simple_strtoul(argv[2], NULL, 10);
707 udev = usb_find_device(i);
708 if (udev == NULL) {
709 printf("Device %d does not exist.\n", i);
710 return 1;
711 }
712 i = simple_strtoul(argv[3], NULL, 10);
713 return usb_test(udev, i, argv[4]);
714 }
715 #ifdef CONFIG_USB_STORAGE
716 if (strncmp(argv[1], "stor", 4) == 0)
717 return usb_stor_info();
718
719 return blk_common_cmd(argc, argv, IF_TYPE_USB, &usb_stor_curr_dev);
720 #else
721 return CMD_RET_USAGE;
722 #endif /* CONFIG_USB_STORAGE */
723 }
724
725 U_BOOT_CMD(
726 usb, 5, 1, do_usb,
727 "USB sub-system",
728 "start - start (scan) USB controller\n"
729 "usb reset - reset (rescan) USB controller\n"
730 "usb stop [f] - stop USB [f]=force stop\n"
731 "usb tree - show USB device tree\n"
732 "usb info [dev] - show available USB devices\n"
733 "usb test [dev] [port] [mode] - set USB 2.0 test mode\n"
734 " (specify port 0 to indicate the device's upstream port)\n"
735 " Available modes: J, K, S[E0_NAK], P[acket], F[orce_Enable]\n"
736 #ifdef CONFIG_USB_STORAGE
737 "usb storage - show details of USB storage devices\n"
738 "usb dev [dev] - show or set current USB storage device\n"
739 "usb part [dev] - print partition table of one or all USB storage"
740 " devices\n"
741 "usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n"
742 " to memory address `addr'\n"
743 "usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'\n"
744 " from memory address `addr'"
745 #endif /* CONFIG_USB_STORAGE */
746 );
747
748
749 #ifdef CONFIG_USB_STORAGE
750 U_BOOT_CMD(
751 usbboot, 3, 1, do_usbboot,
752 "boot from USB device",
753 "loadAddr dev:part"
754 );
755 #endif /* CONFIG_USB_STORAGE */
756