[people/ms/u-boot.git] / common / cmd_usb.c

/*
 * (C) Copyright 2001
 * Denis Peter, MPL AG Switzerland
 *
 * Most of this source has been derived from the Linux USB
 * project.
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <command.h>
#include <asm/byteorder.h>
#include <asm/unaligned.h>
#include <part.h>
#include <usb.h>

#ifdef CONFIG_USB_STORAGE
static int usb_stor_curr_dev = -1; /* current device */
#endif
#ifdef CONFIG_USB_HOST_ETHER
static int usb_ether_curr_dev = -1; /* current ethernet device */
#endif

/* some display routines (info command) */
static char *usb_get_class_desc(unsigned char dclass)
{
	switch (dclass) {
	case USB_CLASS_PER_INTERFACE:
		return "See Interface";
	case USB_CLASS_AUDIO:
		return "Audio";
	case USB_CLASS_COMM:
		return "Communication";
	case USB_CLASS_HID:
		return "Human Interface";
	case USB_CLASS_PRINTER:
		return "Printer";
	case USB_CLASS_MASS_STORAGE:
		return "Mass Storage";
	case USB_CLASS_HUB:
		return "Hub";
	case USB_CLASS_DATA:
		return "CDC Data";
	case USB_CLASS_VENDOR_SPEC:
		return "Vendor specific";
	default:
		return "";
	}
}

static void usb_display_class_sub(unsigned char dclass, unsigned char subclass,
				  unsigned char proto)
{
	switch (dclass) {
	case USB_CLASS_PER_INTERFACE:
		printf("See Interface");
		break;
	case USB_CLASS_HID:
		printf("Human Interface, Subclass: ");
		switch (subclass) {
		case USB_SUB_HID_NONE:
			printf("None");
			break;
		case USB_SUB_HID_BOOT:
			printf("Boot ");
			switch (proto) {
			case USB_PROT_HID_NONE:
				printf("None");
				break;
			case USB_PROT_HID_KEYBOARD:
				printf("Keyboard");
				break;
			case USB_PROT_HID_MOUSE:
				printf("Mouse");
				break;
			default:
				printf("reserved");
				break;
			}
			break;
		default:
			printf("reserved");
			break;
		}
		break;
	case USB_CLASS_MASS_STORAGE:
		printf("Mass Storage, ");
		switch (subclass) {
		case US_SC_RBC:
			printf("RBC ");
			break;
		case US_SC_8020:
			printf("SFF-8020i (ATAPI)");
			break;
		case US_SC_QIC:
			printf("QIC-157 (Tape)");
			break;
		case US_SC_UFI:
			printf("UFI");
			break;
		case US_SC_8070:
			printf("SFF-8070");
			break;
		case US_SC_SCSI:
			printf("Transp. SCSI");
			break;
		default:
			printf("reserved");
			break;
		}
		printf(", ");
		switch (proto) {
		case US_PR_CB:
			printf("Command/Bulk");
			break;
		case US_PR_CBI:
			printf("Command/Bulk/Int");
			break;
		case US_PR_BULK:
			printf("Bulk only");
			break;
		default:
			printf("reserved");
			break;
		}
		break;
	default:
		printf("%s", usb_get_class_desc(dclass));
		break;
	}
}

static void usb_display_string(struct usb_device *dev, int index)
{
	ALLOC_CACHE_ALIGN_BUFFER(char, buffer, 256);

	if (index != 0) {
		if (usb_string(dev, index, &buffer[0], 256) > 0)
			printf("String: \"%s\"", buffer);
	}
}

static void usb_display_desc(struct usb_device *dev)
{
	if (dev->descriptor.bDescriptorType == USB_DT_DEVICE) {
		printf("%d: %s,  USB Revision %x.%x\n", dev->devnum,
		usb_get_class_desc(dev->config.if_desc[0].desc.bInterfaceClass),
				   (dev->descriptor.bcdUSB>>8) & 0xff,
				   dev->descriptor.bcdUSB & 0xff);

		if (strlen(dev->mf) || strlen(dev->prod) ||
		    strlen(dev->serial))
			printf(" - %s %s %s\n", dev->mf, dev->prod,
				dev->serial);
		if (dev->descriptor.bDeviceClass) {
			printf(" - Class: ");
			usb_display_class_sub(dev->descriptor.bDeviceClass,
					      dev->descriptor.bDeviceSubClass,
					      dev->descriptor.bDeviceProtocol);
			printf("\n");
		} else {
			printf(" - Class: (from Interface) %s\n",
			       usb_get_class_desc(
				dev->config.if_desc[0].desc.bInterfaceClass));
		}
		printf(" - PacketSize: %d  Configurations: %d\n",
			dev->descriptor.bMaxPacketSize0,
			dev->descriptor.bNumConfigurations);
		printf(" - Vendor: 0x%04x  Product 0x%04x Version %d.%d\n",
			dev->descriptor.idVendor, dev->descriptor.idProduct,
			(dev->descriptor.bcdDevice>>8) & 0xff,
			dev->descriptor.bcdDevice & 0xff);
	}

}

static void usb_display_conf_desc(struct usb_config_descriptor *config,
				  struct usb_device *dev)
{
	printf("   Configuration: %d\n", config->bConfigurationValue);
	printf("   - Interfaces: %d %s%s%dmA\n", config->bNumInterfaces,
	       (config->bmAttributes & 0x40) ? "Self Powered " : "Bus Powered ",
	       (config->bmAttributes & 0x20) ? "Remote Wakeup " : "",
		config->bMaxPower*2);
	if (config->iConfiguration) {
		printf("   - ");
		usb_display_string(dev, config->iConfiguration);
		printf("\n");
	}
}

static void usb_display_if_desc(struct usb_interface_descriptor *ifdesc,
				struct usb_device *dev)
{
	printf("     Interface: %d\n", ifdesc->bInterfaceNumber);
	printf("     - Alternate Setting %d, Endpoints: %d\n",
		ifdesc->bAlternateSetting, ifdesc->bNumEndpoints);
	printf("     - Class ");
	usb_display_class_sub(ifdesc->bInterfaceClass,
		ifdesc->bInterfaceSubClass, ifdesc->bInterfaceProtocol);
	printf("\n");
	if (ifdesc->iInterface) {
		printf("     - ");
		usb_display_string(dev, ifdesc->iInterface);
		printf("\n");
	}
}

static void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc)
{
	printf("     - Endpoint %d %s ", epdesc->bEndpointAddress & 0xf,
		(epdesc->bEndpointAddress & 0x80) ? "In" : "Out");
	switch ((epdesc->bmAttributes & 0x03)) {
	case 0:
		printf("Control");
		break;
	case 1:
		printf("Isochronous");
		break;
	case 2:
		printf("Bulk");
		break;
	case 3:
		printf("Interrupt");
		break;
	}
	printf(" MaxPacket %d", get_unaligned(&epdesc->wMaxPacketSize));
	if ((epdesc->bmAttributes & 0x03) == 0x3)
		printf(" Interval %dms", epdesc->bInterval);
	printf("\n");
}

/* main routine to diasplay the configs, interfaces and endpoints */
static void usb_display_config(struct usb_device *dev)
{
	struct usb_config *config;
	struct usb_interface *ifdesc;
	struct usb_endpoint_descriptor *epdesc;
	int i, ii;

	config = &dev->config;
	usb_display_conf_desc(&config->desc, dev);
	for (i = 0; i < config->no_of_if; i++) {
		ifdesc = &config->if_desc[i];
		usb_display_if_desc(&ifdesc->desc, dev);
		for (ii = 0; ii < ifdesc->no_of_ep; ii++) {
			epdesc = &ifdesc->ep_desc[ii];
			usb_display_ep_desc(epdesc);
		}
	}
	printf("\n");
}

static struct usb_device *usb_find_device(int devnum)
{
	struct usb_device *dev;
	int d;

	for (d = 0; d < USB_MAX_DEVICE; d++) {
		dev = usb_get_dev_index(d);
		if (dev == NULL)
			return NULL;
		if (dev->devnum == devnum)
			return dev;
	}

	return NULL;
}

static inline char *portspeed(int speed)
{
	char *speed_str;

	switch (speed) {
	case USB_SPEED_SUPER:
		speed_str = "5 Gb/s";
		break;
	case USB_SPEED_HIGH:
		speed_str = "480 Mb/s";
		break;
	case USB_SPEED_LOW:
		speed_str = "1.5 Mb/s";
		break;
	default:
		speed_str = "12 Mb/s";
		break;
	}

	return speed_str;
}

/* shows the device tree recursively */
static void usb_show_tree_graph(struct usb_device *dev, char *pre)
{
	int i, index;
	int has_child, last_child;

	index = strlen(pre);
	printf(" %s", pre);
	/* check if the device has connected children */
	has_child = 0;
	for (i = 0; i < dev->maxchild; i++) {
		if (dev->children[i] != NULL)
			has_child = 1;
	}
	/* check if we are the last one */
	last_child = 1;
	if (dev->parent != NULL) {
		for (i = 0; i < dev->parent->maxchild; i++) {
			/* search for children */
			if (dev->parent->children[i] == dev) {
				/* found our pointer, see if we have a
				 * little sister
				 */
				while (i++ < dev->parent->maxchild) {
					if (dev->parent->children[i] != NULL) {
						/* found a sister */
						last_child = 0;
						break;
					} /* if */
				} /* while */
			} /* device found */
		} /* for all children of the parent */
		printf("\b+-");
		/* correct last child */
		if (last_child)
			pre[index-1] = ' ';
	} /* if not root hub */
	else
		printf(" ");
	printf("%d ", dev->devnum);
	pre[index++] = ' ';
	pre[index++] = has_child ? '|' : ' ';
	pre[index] = 0;
	printf(" %s (%s, %dmA)\n", usb_get_class_desc(
					dev->config.if_desc[0].desc.bInterfaceClass),
					portspeed(dev->speed),
					dev->config.desc.bMaxPower * 2);
	if (strlen(dev->mf) || strlen(dev->prod) || strlen(dev->serial))
		printf(" %s  %s %s %s\n", pre, dev->mf, dev->prod, dev->serial);
	printf(" %s\n", pre);
	if (dev->maxchild > 0) {
		for (i = 0; i < dev->maxchild; i++) {
			if (dev->children[i] != NULL) {
				usb_show_tree_graph(dev->children[i], pre);
				pre[index] = 0;
			}
		}
	}
}

/* main routine for the tree command */
static void usb_show_tree(struct usb_device *dev)
{
	char preamble[32];

	memset(preamble, 0, 32);
	usb_show_tree_graph(dev, &preamble[0]);
}

static int usb_test(struct usb_device *dev, int port, char* arg)
{
	int mode;

	if (port > dev->maxchild) {
		printf("Device is no hub or does not have %d ports.\n", port);
		return 1;
	}

	switch (arg[0]) {
	case 'J':
	case 'j':
		printf("Setting Test_J mode");
		mode = USB_TEST_MODE_J;
		break;
	case 'K':
	case 'k':
		printf("Setting Test_K mode");
		mode = USB_TEST_MODE_K;
		break;
	case 'S':
	case 's':
		printf("Setting Test_SE0_NAK mode");
		mode = USB_TEST_MODE_SE0_NAK;
		break;
	case 'P':
	case 'p':
		printf("Setting Test_Packet mode");
		mode = USB_TEST_MODE_PACKET;
		break;
	case 'F':
	case 'f':
		printf("Setting Test_Force_Enable mode");
		mode = USB_TEST_MODE_FORCE_ENABLE;
		break;
	default:
		printf("Unrecognized test mode: %s\nAvailable modes: "
		       "J, K, S[E0_NAK], P[acket], F[orce_Enable]\n", arg);
		return 1;
	}

	if (port)
		printf(" on downstream facing port %d...\n", port);
	else
		printf(" on upstream facing port...\n");

	if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_FEATURE,
			    port ? USB_RT_PORT : USB_RECIP_DEVICE,
			    port ? USB_PORT_FEAT_TEST : USB_FEAT_TEST,
			    (mode << 8) | port,
			    NULL, 0, USB_CNTL_TIMEOUT) == -1) {
		printf("Error during SET_FEATURE.\n");
		return 1;
	} else {
		printf("Test mode successfully set. Use 'usb start' "
		       "to return to normal operation.\n");
		return 0;
	}
}


/******************************************************************************
 * usb boot command intepreter. Derived from diskboot
 */
#ifdef CONFIG_USB_STORAGE
static int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	return common_diskboot(cmdtp, "usb", argc, argv);
}
#endif /* CONFIG_USB_STORAGE */


/******************************************************************************
 * usb command intepreter
 */
static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{

	int i;
	struct usb_device *dev = NULL;
	extern char usb_started;
#ifdef CONFIG_USB_STORAGE
	block_dev_desc_t *stor_dev;
#endif

	if (argc < 2)
		return CMD_RET_USAGE;

	if ((strncmp(argv[1], "reset", 5) == 0) ||
		 (strncmp(argv[1], "start", 5) == 0)) {
		bootstage_mark_name(BOOTSTAGE_ID_USB_START, "usb_start");
		usb_stop();
		printf("(Re)start USB...\n");
		if (usb_init() >= 0) {
#ifdef CONFIG_USB_STORAGE
			/* try to recognize storage devices immediately */
			usb_stor_curr_dev = usb_stor_scan(1);
#endif
#ifdef CONFIG_USB_HOST_ETHER
			/* try to recognize ethernet devices immediately */
			usb_ether_curr_dev = usb_host_eth_scan(1);
#endif
#ifdef CONFIG_USB_KEYBOARD
			drv_usb_kbd_init();
#endif
		}
		return 0;
	}
	if (strncmp(argv[1], "stop", 4) == 0) {
#ifdef CONFIG_USB_KEYBOARD
		if (argc == 2) {
			if (usb_kbd_deregister() != 0) {
				printf("USB not stopped: usbkbd still"
					" using USB\n");
				return 1;
			}
		} else {
			/* forced stop, switch console in to serial */
			console_assign(stdin, "serial");
			usb_kbd_deregister();
		}
#endif
		printf("stopping USB..\n");
		usb_stop();
		return 0;
	}
	if (!usb_started) {
		printf("USB is stopped. Please issue 'usb start' first.\n");
		return 1;
	}
	if (strncmp(argv[1], "tree", 4) == 0) {
		puts("USB device tree:\n");
		for (i = 0; i < USB_MAX_DEVICE; i++) {
			dev = usb_get_dev_index(i);
			if (dev == NULL)
				break;
			if (dev->parent == NULL)
				usb_show_tree(dev);
		}
		return 0;
	}
	if (strncmp(argv[1], "inf", 3) == 0) {
		int d;
		if (argc == 2) {
			for (d = 0; d < USB_MAX_DEVICE; d++) {
				dev = usb_get_dev_index(d);
				if (dev == NULL)
					break;
				usb_display_desc(dev);
				usb_display_config(dev);
			}
			return 0;
		} else {
			i = simple_strtoul(argv[2], NULL, 10);
			printf("config for device %d\n", i);
			dev = usb_find_device(i);
			if (dev == NULL) {
				printf("*** No device available ***\n");
				return 0;
			} else {
				usb_display_desc(dev);
				usb_display_config(dev);
			}
		}
		return 0;
	}
	if (strncmp(argv[1], "test", 4) == 0) {
		if (argc < 5)
			return CMD_RET_USAGE;
		i = simple_strtoul(argv[2], NULL, 10);
		dev = usb_find_device(i);
		if (dev == NULL) {
			printf("Device %d does not exist.\n", i);
			return 1;
		}
		i = simple_strtoul(argv[3], NULL, 10);
		return usb_test(dev, i, argv[4]);
	}
#ifdef CONFIG_USB_STORAGE
	if (strncmp(argv[1], "stor", 4) == 0)
		return usb_stor_info();

	if (strncmp(argv[1], "part", 4) == 0) {
		int devno, ok = 0;
		if (argc == 2) {
			for (devno = 0; ; ++devno) {
				stor_dev = usb_stor_get_dev(devno);
				if (stor_dev == NULL)
					break;
				if (stor_dev->type != DEV_TYPE_UNKNOWN) {
					ok++;
					if (devno)
						printf("\n");
					debug("print_part of %x\n", devno);
					print_part(stor_dev);
				}
			}
		} else {
			devno = simple_strtoul(argv[2], NULL, 16);
			stor_dev = usb_stor_get_dev(devno);
			if (stor_dev != NULL &&
			    stor_dev->type != DEV_TYPE_UNKNOWN) {
				ok++;
				debug("print_part of %x\n", devno);
				print_part(stor_dev);
			}
		}
		if (!ok) {
			printf("\nno USB devices available\n");
			return 1;
		}
		return 0;
	}
	if (strcmp(argv[1], "read") == 0) {
		if (usb_stor_curr_dev < 0) {
			printf("no current device selected\n");
			return 1;
		}
		if (argc == 5) {
			unsigned long addr = simple_strtoul(argv[2], NULL, 16);
			unsigned long blk  = simple_strtoul(argv[3], NULL, 16);
			unsigned long cnt  = simple_strtoul(argv[4], NULL, 16);
			unsigned long n;
			printf("\nUSB read: device %d block # %ld, count %ld"
				" ... ", usb_stor_curr_dev, blk, cnt);
			stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
			n = stor_dev->block_read(usb_stor_curr_dev, blk, cnt,
						 (ulong *)addr);
			printf("%ld blocks read: %s\n", n,
				(n == cnt) ? "OK" : "ERROR");
			if (n == cnt)
				return 0;
			return 1;
		}
	}
	if (strcmp(argv[1], "write") == 0) {
		if (usb_stor_curr_dev < 0) {
			printf("no current device selected\n");
			return 1;
		}
		if (argc == 5) {
			unsigned long addr = simple_strtoul(argv[2], NULL, 16);
			unsigned long blk  = simple_strtoul(argv[3], NULL, 16);
			unsigned long cnt  = simple_strtoul(argv[4], NULL, 16);
			unsigned long n;
			printf("\nUSB write: device %d block # %ld, count %ld"
				" ... ", usb_stor_curr_dev, blk, cnt);
			stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
			n = stor_dev->block_write(usb_stor_curr_dev, blk, cnt,
						(ulong *)addr);
			printf("%ld blocks write: %s\n", n,
				(n == cnt) ? "OK" : "ERROR");
			if (n == cnt)
				return 0;
			return 1;
		}
	}
	if (strncmp(argv[1], "dev", 3) == 0) {
		if (argc == 3) {
			int dev = (int)simple_strtoul(argv[2], NULL, 10);
			printf("\nUSB device %d: ", dev);
			stor_dev = usb_stor_get_dev(dev);
			if (stor_dev == NULL) {
				printf("unknown device\n");
				return 1;
			}
			printf("\n    Device %d: ", dev);
			dev_print(stor_dev);
			if (stor_dev->type == DEV_TYPE_UNKNOWN)
				return 1;
			usb_stor_curr_dev = dev;
			printf("... is now current device\n");
			return 0;
		} else {
			printf("\nUSB device %d: ", usb_stor_curr_dev);
			stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
			dev_print(stor_dev);
			if (stor_dev->type == DEV_TYPE_UNKNOWN)
				return 1;
			return 0;
		}
		return 0;
	}
#endif /* CONFIG_USB_STORAGE */
	return CMD_RET_USAGE;
}

U_BOOT_CMD(
	usb,	5,	1,	do_usb,
	"USB sub-system",
	"start - start (scan) USB controller\n"
	"usb reset - reset (rescan) USB controller\n"
	"usb stop [f] - stop USB [f]=force stop\n"
	"usb tree - show USB device tree\n"
	"usb info [dev] - show available USB devices\n"
	"usb test [dev] [port] [mode] - set USB 2.0 test mode\n"
	"    (specify port 0 to indicate the device's upstream port)\n"
	"    Available modes: J, K, S[E0_NAK], P[acket], F[orce_Enable]\n"
#ifdef CONFIG_USB_STORAGE
	"usb storage - show details of USB storage devices\n"
	"usb dev [dev] - show or set current USB storage device\n"
	"usb part [dev] - print partition table of one or all USB storage"
	"    devices\n"
	"usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n"
	"    to memory address `addr'\n"
	"usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'\n"
	"    from memory address `addr'"
#endif /* CONFIG_USB_STORAGE */
);


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