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 char *portspeed(int speed)
320 {
321 char *speed_str;
322
323 switch (speed) {
324 case USB_SPEED_SUPER:
325 speed_str = "5 Gb/s";
326 break;
327 case USB_SPEED_HIGH:
328 speed_str = "480 Mb/s";
329 break;
330 case USB_SPEED_LOW:
331 speed_str = "1.5 Mb/s";
332 break;
333 default:
334 speed_str = "12 Mb/s";
335 break;
336 }
337
338 return speed_str;
339 }
340
341 /* shows the device tree recursively */
usb_show_tree_graph(struct usb_device * dev,char * pre)342 static void usb_show_tree_graph(struct usb_device *dev, char *pre)
343 {
344 int index;
345 int has_child, last_child;
346
347 index = strlen(pre);
348 printf(" %s", pre);
349 #ifdef CONFIG_DM_USB
350 has_child = device_has_active_children(dev->dev);
351 if (device_get_uclass_id(dev->dev) == UCLASS_MASS_STORAGE) {
352 struct udevice *child;
353
354 for (device_find_first_child(dev->dev, &child);
355 child;
356 device_find_next_child(&child)) {
357 if (device_get_uclass_id(child) == UCLASS_BLK)
358 has_child = 0;
359 }
360 }
361 #else
362 /* check if the device has connected children */
363 int i;
364
365 has_child = 0;
366 for (i = 0; i < dev->maxchild; i++) {
367 if (dev->children[i] != NULL)
368 has_child = 1;
369 }
370 #endif
371 /* check if we are the last one */
372 #ifdef CONFIG_DM_USB
373 /* Not the root of the usb tree? */
374 if (device_get_uclass_id(dev->dev->parent) != UCLASS_USB) {
375 last_child = device_is_last_sibling(dev->dev);
376 #else
377 if (dev->parent != NULL) { /* not root? */
378 last_child = 1;
379 for (i = 0; i < dev->parent->maxchild; i++) {
380 /* search for children */
381 if (dev->parent->children[i] == dev) {
382 /* found our pointer, see if we have a
383 * little sister
384 */
385 while (i++ < dev->parent->maxchild) {
386 if (dev->parent->children[i] != NULL) {
387 /* found a sister */
388 last_child = 0;
389 break;
390 } /* if */
391 } /* while */
392 } /* device found */
393 } /* for all children of the parent */
394 #endif
395 printf("\b+-");
396 /* correct last child */
397 if (last_child && index)
398 pre[index-1] = ' ';
399 } /* if not root hub */
400 else
401 printf(" ");
402 printf("%d ", dev->devnum);
403 pre[index++] = ' ';
404 pre[index++] = has_child ? '|' : ' ';
405 pre[index] = 0;
406 printf(" %s (%s, %dmA)\n", usb_get_class_desc(
407 dev->config.if_desc[0].desc.bInterfaceClass),
408 portspeed(dev->speed),
409 dev->config.desc.bMaxPower * 2);
410 if (strlen(dev->mf) || strlen(dev->prod) || strlen(dev->serial))
411 printf(" %s %s %s %s\n", pre, dev->mf, dev->prod, dev->serial);
412 printf(" %s\n", pre);
413 #ifdef CONFIG_DM_USB
414 struct udevice *child;
415
416 for (device_find_first_child(dev->dev, &child);
417 child;
418 device_find_next_child(&child)) {
419 struct usb_device *udev;
420
421 if (!device_active(child))
422 continue;
423
424 udev = dev_get_parent_priv(child);
425
426 /*
427 * Ignore emulators and block child devices, we only want
428 * real devices
429 */
430 if ((device_get_uclass_id(child) != UCLASS_USB_EMUL) &&
431 (device_get_uclass_id(child) != UCLASS_BLK)) {
432 usb_show_tree_graph(udev, pre);
433 pre[index] = 0;
434 }
435 }
436 #else
437 if (dev->maxchild > 0) {
438 for (i = 0; i < dev->maxchild; i++) {
439 if (dev->children[i] != NULL) {
440 usb_show_tree_graph(dev->children[i], pre);
441 pre[index] = 0;
442 }
443 }
444 }
445 #endif
446 }
447
448 /* main routine for the tree command */
449 static void usb_show_subtree(struct usb_device *dev)
450 {
451 char preamble[32];
452
453 memset(preamble, '\0', sizeof(preamble));
454 usb_show_tree_graph(dev, &preamble[0]);
455 }
456
457 #ifdef CONFIG_DM_USB
458 typedef void (*usb_dev_func_t)(struct usb_device *udev);
459
460 static void usb_for_each_root_dev(usb_dev_func_t func)
461 {
462 struct udevice *bus;
463
464 for (uclass_find_first_device(UCLASS_USB, &bus);
465 bus;
466 uclass_find_next_device(&bus)) {
467 struct usb_device *udev;
468 struct udevice *dev;
469
470 if (!device_active(bus))
471 continue;
472
473 device_find_first_child(bus, &dev);
474 if (dev && device_active(dev)) {
475 udev = dev_get_parent_priv(dev);
476 func(udev);
477 }
478 }
479 }
480 #endif
481
482 void usb_show_tree(void)
483 {
484 #ifdef CONFIG_DM_USB
485 usb_for_each_root_dev(usb_show_subtree);
486 #else
487 struct usb_device *udev;
488 int i;
489
490 for (i = 0; i < USB_MAX_DEVICE; i++) {
491 udev = usb_get_dev_index(i);
492 if (udev == NULL)
493 break;
494 if (udev->parent == NULL)
495 usb_show_subtree(udev);
496 }
497 #endif
498 }
499
500 static int usb_test(struct usb_device *dev, int port, char* arg)
501 {
502 int mode;
503
504 if (port > dev->maxchild) {
505 printf("Device is no hub or does not have %d ports.\n", port);
506 return 1;
507 }
508
509 switch (arg[0]) {
510 case 'J':
511 case 'j':
512 printf("Setting Test_J mode");
513 mode = USB_TEST_MODE_J;
514 break;
515 case 'K':
516 case 'k':
517 printf("Setting Test_K mode");
518 mode = USB_TEST_MODE_K;
519 break;
520 case 'S':
521 case 's':
522 printf("Setting Test_SE0_NAK mode");
523 mode = USB_TEST_MODE_SE0_NAK;
524 break;
525 case 'P':
526 case 'p':
527 printf("Setting Test_Packet mode");
528 mode = USB_TEST_MODE_PACKET;
529 break;
530 case 'F':
531 case 'f':
532 printf("Setting Test_Force_Enable mode");
533 mode = USB_TEST_MODE_FORCE_ENABLE;
534 break;
535 default:
536 printf("Unrecognized test mode: %s\nAvailable modes: "
537 "J, K, S[E0_NAK], P[acket], F[orce_Enable]\n", arg);
538 return 1;
539 }
540
541 if (port)
542 printf(" on downstream facing port %d...\n", port);
543 else
544 printf(" on upstream facing port...\n");
545
546 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_FEATURE,
547 port ? USB_RT_PORT : USB_RECIP_DEVICE,
548 port ? USB_PORT_FEAT_TEST : USB_FEAT_TEST,
549 (mode << 8) | port,
550 NULL, 0, USB_CNTL_TIMEOUT) == -1) {
551 printf("Error during SET_FEATURE.\n");
552 return 1;
553 } else {
554 printf("Test mode successfully set. Use 'usb start' "
555 "to return to normal operation.\n");
556 return 0;
557 }
558 }
559
560
561 /******************************************************************************
562 * usb boot command intepreter. Derived from diskboot
563 */
564 #ifdef CONFIG_USB_STORAGE
565 static int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
566 {
567 return common_diskboot(cmdtp, "usb", argc, argv);
568 }
569 #endif /* CONFIG_USB_STORAGE */
570
571 static int do_usb_stop_keyboard(int force)
572 {
573 #if !defined CONFIG_DM_USB && defined CONFIG_USB_KEYBOARD
574 if (usb_kbd_deregister(force) != 0) {
575 printf("USB not stopped: usbkbd still using USB\n");
576 return 1;
577 }
578 #endif
579 return 0;
580 }
581
582 static void do_usb_start(void)
583 {
584 bootstage_mark_name(BOOTSTAGE_ID_USB_START, "usb_start");
585
586 if (usb_init() < 0)
587 return;
588
589 /* Driver model will probe the devices as they are found */
590 # ifdef CONFIG_USB_STORAGE
591 /* try to recognize storage devices immediately */
592 usb_stor_curr_dev = usb_stor_scan(1);
593 # endif
594 #ifndef CONFIG_DM_USB
595 # ifdef CONFIG_USB_KEYBOARD
596 drv_usb_kbd_init();
597 # endif
598 #endif /* !CONFIG_DM_USB */
599 #ifdef CONFIG_USB_HOST_ETHER
600 # ifdef CONFIG_DM_ETH
601 # ifndef CONFIG_DM_USB
602 # error "You must use CONFIG_DM_USB if you want to use CONFIG_USB_HOST_ETHER with CONFIG_DM_ETH"
603 # endif
604 # else
605 /* try to recognize ethernet devices immediately */
606 usb_ether_curr_dev = usb_host_eth_scan(1);
607 # endif
608 #endif
609 }
610
611 #ifdef CONFIG_DM_USB
612 static void usb_show_info(struct usb_device *udev)
613 {
614 struct udevice *child;
615
616 usb_display_desc(udev);
617 usb_display_config(udev);
618 for (device_find_first_child(udev->dev, &child);
619 child;
620 device_find_next_child(&child)) {
621 if (device_active(child) &&
622 (device_get_uclass_id(child) != UCLASS_USB_EMUL) &&
623 (device_get_uclass_id(child) != UCLASS_BLK)) {
624 udev = dev_get_parent_priv(child);
625 usb_show_info(udev);
626 }
627 }
628 }
629 #endif
630
631 /******************************************************************************
632 * usb command intepreter
633 */
634 static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
635 {
636 struct usb_device *udev = NULL;
637 int i;
638 extern char usb_started;
639
640 if (argc < 2)
641 return CMD_RET_USAGE;
642
643 if (strncmp(argv[1], "start", 5) == 0) {
644 if (usb_started)
645 return 0; /* Already started */
646 printf("starting USB...\n");
647 do_usb_start();
648 return 0;
649 }
650
651 if (strncmp(argv[1], "reset", 5) == 0) {
652 printf("resetting USB...\n");
653 if (do_usb_stop_keyboard(1) != 0)
654 return 1;
655 usb_stop();
656 do_usb_start();
657 return 0;
658 }
659 if (strncmp(argv[1], "stop", 4) == 0) {
660 if (argc != 2)
661 console_assign(stdin, "serial");
662 if (do_usb_stop_keyboard(0) != 0)
663 return 1;
664 printf("stopping USB..\n");
665 usb_stop();
666 return 0;
667 }
668 if (!usb_started) {
669 printf("USB is stopped. Please issue 'usb start' first.\n");
670 return 1;
671 }
672 if (strncmp(argv[1], "tree", 4) == 0) {
673 puts("USB device tree:\n");
674 usb_show_tree();
675 return 0;
676 }
677 if (strncmp(argv[1], "inf", 3) == 0) {
678 if (argc == 2) {
679 #ifdef CONFIG_DM_USB
680 usb_for_each_root_dev(usb_show_info);
681 #else
682 int d;
683 for (d = 0; d < USB_MAX_DEVICE; d++) {
684 udev = usb_get_dev_index(d);
685 if (udev == NULL)
686 break;
687 usb_display_desc(udev);
688 usb_display_config(udev);
689 }
690 #endif
691 return 0;
692 } else {
693 /*
694 * With driver model this isn't right since we can
695 * have multiple controllers and the device numbering
696 * starts at 1 on each bus.
697 */
698 i = simple_strtoul(argv[2], NULL, 10);
699 printf("config for device %d\n", i);
700 udev = usb_find_device(i);
701 if (udev == NULL) {
702 printf("*** No device available ***\n");
703 return 0;
704 } else {
705 usb_display_desc(udev);
706 usb_display_config(udev);
707 }
708 }
709 return 0;
710 }
711 if (strncmp(argv[1], "test", 4) == 0) {
712 if (argc < 5)
713 return CMD_RET_USAGE;
714 i = simple_strtoul(argv[2], NULL, 10);
715 udev = usb_find_device(i);
716 if (udev == NULL) {
717 printf("Device %d does not exist.\n", i);
718 return 1;
719 }
720 i = simple_strtoul(argv[3], NULL, 10);
721 return usb_test(udev, i, argv[4]);
722 }
723 #ifdef CONFIG_USB_STORAGE
724 if (strncmp(argv[1], "stor", 4) == 0)
725 return usb_stor_info();
726
727 return blk_common_cmd(argc, argv, IF_TYPE_USB, &usb_stor_curr_dev);
728 #else
729 return CMD_RET_USAGE;
730 #endif /* CONFIG_USB_STORAGE */
731 }
732
733 U_BOOT_CMD(
734 usb, 5, 1, do_usb,
735 "USB sub-system",
736 "start - start (scan) USB controller\n"
737 "usb reset - reset (rescan) USB controller\n"
738 "usb stop [f] - stop USB [f]=force stop\n"
739 "usb tree - show USB device tree\n"
740 "usb info [dev] - show available USB devices\n"
741 "usb test [dev] [port] [mode] - set USB 2.0 test mode\n"
742 " (specify port 0 to indicate the device's upstream port)\n"
743 " Available modes: J, K, S[E0_NAK], P[acket], F[orce_Enable]\n"
744 #ifdef CONFIG_USB_STORAGE
745 "usb storage - show details of USB storage devices\n"
746 "usb dev [dev] - show or set current USB storage device\n"
747 "usb part [dev] - print partition table of one or all USB storage"
748 " devices\n"
749 "usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n"
750 " to memory address `addr'\n"
751 "usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'\n"
752 " from memory address `addr'"
753 #endif /* CONFIG_USB_STORAGE */
754 );
755
756
757 #ifdef CONFIG_USB_STORAGE
758 U_BOOT_CMD(
759 usbboot, 3, 1, do_usbboot,
760 "boot from USB device",
761 "loadAddr dev:part"
762 );
763 #endif /* CONFIG_USB_STORAGE */
764