[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 */

static int do_usb_stop_keyboard(int force)
{
#ifdef CONFIG_USB_KEYBOARD
	if (usb_kbd_deregister(force) != 0) {
		printf("USB not stopped: usbkbd still using USB\n");
		return 1;
	}
#endif
	return 0;
}

/******************************************************************************
 * 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");
		if (do_usb_stop_keyboard(1) != 0)
			return 1;
		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) {
		if (argc != 2)
			console_assign(stdin, "serial");
		if (do_usb_stop_keyboard(0) != 0)
			return 1;
		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
8a8a2257	433	static int do_usb_stop_keyboard(int force)
6e78c74f HG	434	{
6e78c74f HG	435	#ifdef CONFIG_USB_KEYBOARD
8a8a2257	436	if (usb_kbd_deregister(force) != 0) {
6e78c74f HG	437	printf("USB not stopped: usbkbd still using USB\n");
	438	return 1;
	439	}
	440	#endif
	441	return 0;
	442	}
e887afc9	443
de39f8c1	444	/******************************************************************************
e887afc9 WD	445	* usb command intepreter
e887afc9 WD	446	*/
088f1b19	447	static int do_usb(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
e887afc9 WD	448	{
	449
	450	int i;
	451	struct usb_device *dev = NULL;
e51aae38	452	extern char usb_started;
1968e615	453	#ifdef CONFIG_USB_STORAGE
e887afc9	454	block_dev_desc_t *stor_dev;
1968e615	455	#endif
e887afc9	456
47e26b1b	457	if (argc < 2)
4c12eeb8	458	return CMD_RET_USAGE;
65d34254	459
9c998aa8	460	if ((strncmp(argv[1], "reset", 5) == 0) \|\|
de39f8c1	461	(strncmp(argv[1], "start", 5) == 0)) {
573f14fe	462	bootstage_mark_name(BOOTSTAGE_ID_USB_START, "usb_start");
8a8a2257	463	if (do_usb_stop_keyboard(1) != 0)
6e78c74f	464	return 1;
e887afc9 WD	465	usb_stop();
e887afc9 WD	466	printf("(Re)start USB...\n");
93c2582f	467	if (usb_init() >= 0) {
9c998aa8	468	#ifdef CONFIG_USB_STORAGE
89d48367	469	/* try to recognize storage devices immediately */
53677ef1	470	usb_stor_curr_dev = usb_stor_scan(1);
9c998aa8	471	#endif
89d48367 SG	472	#ifdef CONFIG_USB_HOST_ETHER
	473	/* try to recognize ethernet devices immediately */
	474	usb_ether_curr_dev = usb_host_eth_scan(1);
93c2582f LS	475	#endif
	476	#ifdef CONFIG_USB_KEYBOARD
	477	drv_usb_kbd_init();
89d48367 SG	478	#endif
89d48367 SG	479	}
e887afc9 WD	480	return 0;
e887afc9 WD	481	}
de39f8c1	482	if (strncmp(argv[1], "stop", 4) == 0) {
6e78c74f	483	if (argc != 2)
de39f8c1	484	console_assign(stdin, "serial");
8a8a2257	485	if (do_usb_stop_keyboard(0) != 0)
6e78c74f	486	return 1;
e887afc9 WD	487	printf("stopping USB..\n");
	488	usb_stop();
	489	return 0;
	490	}
e51aae38 BS	491	if (!usb_started) {
	492	printf("USB is stopped. Please issue 'usb start' first.\n");
	493	return 1;
	494	}
de39f8c1	495	if (strncmp(argv[1], "tree", 4) == 0) {
93c2582f LS	496	puts("USB device tree:\n");
	497	for (i = 0; i < USB_MAX_DEVICE; i++) {
	498	dev = usb_get_dev_index(i);
	499	if (dev == NULL)
	500	break;
	501	if (dev->parent == NULL)
	502	usb_show_tree(dev);
	503	}
e887afc9 WD	504	return 0;
e887afc9 WD	505	}
de39f8c1	506	if (strncmp(argv[1], "inf", 3) == 0) {
e887afc9	507	int d;
de39f8c1 MT	508	if (argc == 2) {
	509	for (d = 0; d < USB_MAX_DEVICE; d++) {
	510	dev = usb_get_dev_index(d);
	511	if (dev == NULL)
e887afc9 WD	512	break;
	513	usb_display_desc(dev);
	514	usb_display_config(dev);
	515	}
	516	return 0;
de39f8c1	517	} else {
7d9aa8fd	518	i = simple_strtoul(argv[2], NULL, 10);
de39f8c1	519	printf("config for device %d\n", i);
7d9aa8fd	520	dev = usb_find_device(i);
de39f8c1	521	if (dev == NULL) {
6052cbab	522	printf("* No device available *\n");
e887afc9	523	return 0;
de39f8c1	524	} else {
e887afc9 WD	525	usb_display_desc(dev);
	526	usb_display_config(dev);
	527	}
	528	}
	529	return 0;
	530	}
7d9aa8fd JW	531	if (strncmp(argv[1], "test", 4) == 0) {
	532	if (argc < 5)
	533	return CMD_RET_USAGE;
	534	i = simple_strtoul(argv[2], NULL, 10);
	535	dev = usb_find_device(i);
	536	if (dev == NULL) {
	537	printf("Device %d does not exist.\n", i);
	538	return 1;
	539	}
	540	i = simple_strtoul(argv[3], NULL, 10);
	541	return usb_test(dev, i, argv[4]);
	542	}
e887afc9	543	#ifdef CONFIG_USB_STORAGE
de39f8c1	544	if (strncmp(argv[1], "stor", 4) == 0)
f6b44e0e	545	return usb_stor_info();
9c998aa8	546
de39f8c1	547	if (strncmp(argv[1], "part", 4) == 0) {
d4b5f3fa	548	int devno, ok = 0;
de39f8c1	549	if (argc == 2) {
aaad108b	550	for (devno = 0; ; ++devno) {
de39f8c1	551	stor_dev = usb_stor_get_dev(devno);
aaad108b KH	552	if (stor_dev == NULL)
aaad108b KH	553	break;
de39f8c1	554	if (stor_dev->type != DEV_TYPE_UNKNOWN) {
d4b5f3fa CE	555	ok++;
	556	if (devno)
	557	printf("\n");
060f2853	558	debug("print_part of %x\n", devno);
d4b5f3fa CE	559	print_part(stor_dev);
	560	}
	561	}
de39f8c1 MT	562	} else {
	563	devno = simple_strtoul(argv[2], NULL, 16);
	564	stor_dev = usb_stor_get_dev(devno);
aaad108b KH	565	if (stor_dev != NULL &&
aaad108b KH	566	stor_dev->type != DEV_TYPE_UNKNOWN) {
e887afc9	567	ok++;
060f2853	568	debug("print_part of %x\n", devno);
e887afc9 WD	569	print_part(stor_dev);
	570	}
	571	}
	572	if (!ok) {
	573	printf("\nno USB devices available\n");
	574	return 1;
	575	}
	576	return 0;
	577	}
de39f8c1 MT	578	if (strcmp(argv[1], "read") == 0) {
de39f8c1 MT	579	if (usb_stor_curr_dev < 0) {
e887afc9 WD	580	printf("no current device selected\n");
	581	return 1;
	582	}
de39f8c1	583	if (argc == 5) {
e887afc9 WD	584	unsigned long addr = simple_strtoul(argv[2], NULL, 16);
	585	unsigned long blk = simple_strtoul(argv[3], NULL, 16);
	586	unsigned long cnt = simple_strtoul(argv[4], NULL, 16);
	587	unsigned long n;
de39f8c1 MT	588	printf("\nUSB read: device %d block # %ld, count %ld"
	589	" ... ", usb_stor_curr_dev, blk, cnt);
	590	stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
	591	n = stor_dev->block_read(usb_stor_curr_dev, blk, cnt,
	592	(ulong *)addr);
	593	printf("%ld blocks read: %s\n", n,
	594	(n == cnt) ? "OK" : "ERROR");
	595	if (n == cnt)
e887afc9 WD	596	return 0;
	597	return 1;
	598	}
	599	}
127e1084 MJ	600	if (strcmp(argv[1], "write") == 0) {
	601	if (usb_stor_curr_dev < 0) {
	602	printf("no current device selected\n");
	603	return 1;
	604	}
	605	if (argc == 5) {
	606	unsigned long addr = simple_strtoul(argv[2], NULL, 16);
	607	unsigned long blk = simple_strtoul(argv[3], NULL, 16);
	608	unsigned long cnt = simple_strtoul(argv[4], NULL, 16);
	609	unsigned long n;
	610	printf("\nUSB write: device %d block # %ld, count %ld"
	611	" ... ", usb_stor_curr_dev, blk, cnt);
	612	stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
	613	n = stor_dev->block_write(usb_stor_curr_dev, blk, cnt,
	614	(ulong *)addr);
	615	printf("%ld blocks write: %s\n", n,
	616	(n == cnt) ? "OK" : "ERROR");
	617	if (n == cnt)
	618	return 0;
	619	return 1;
	620	}
	621	}
9c998aa8 WD	622	if (strncmp(argv[1], "dev", 3) == 0) {
9c998aa8 WD	623	if (argc == 3) {
e887afc9	624	int dev = (int)simple_strtoul(argv[2], NULL, 10);
de39f8c1	625	printf("\nUSB device %d: ", dev);
aaad108b KH	626	stor_dev = usb_stor_get_dev(dev);
aaad108b KH	627	if (stor_dev == NULL) {
e887afc9 WD	628	printf("unknown device\n");
	629	return 1;
	630	}
de39f8c1	631	printf("\n Device %d: ", dev);
e887afc9	632	dev_print(stor_dev);
de39f8c1	633	if (stor_dev->type == DEV_TYPE_UNKNOWN)
e887afc9	634	return 1;
e887afc9 WD	635	usb_stor_curr_dev = dev;
	636	printf("... is now current device\n");
	637	return 0;
de39f8c1 MT	638	} else {
	639	printf("\nUSB device %d: ", usb_stor_curr_dev);
	640	stor_dev = usb_stor_get_dev(usb_stor_curr_dev);
e887afc9	641	dev_print(stor_dev);
de39f8c1	642	if (stor_dev->type == DEV_TYPE_UNKNOWN)
e887afc9	643	return 1;
e887afc9 WD	644	return 0;
	645	}
	646	return 0;
	647	}
	648	#endif /* CONFIG_USB_STORAGE */
4c12eeb8	649	return CMD_RET_USAGE;
e887afc9 WD	650	}
e887afc9 WD	651
0d498393 WD	652	U_BOOT_CMD(
0d498393 WD	653	usb, 5, 1, do_usb,
2fb2604d	654	"USB sub-system",
1af9f963 VPP	655	"start - start (scan) USB controller\n"
1af9f963 VPP	656	"usb reset - reset (rescan) USB controller\n"
b3813a22 VPP	657	"usb stop [f] - stop USB [f]=force stop\n"
b3813a22 VPP	658	"usb tree - show USB device tree\n"
5cf91d6b	659	"usb info [dev] - show available USB devices\n"
7d9aa8fd JW	660	"usb test [dev] [port] [mode] - set USB 2.0 test mode\n"
	661	" (specify port 0 to indicate the device's upstream port)\n"
	662	" Available modes: J, K, S[E0_NAK], P[acket], F[orce_Enable]\n"
	663	#ifdef CONFIG_USB_STORAGE
b3813a22	664	"usb storage - show details of USB storage devices\n"
342717f7	665	"usb dev [dev] - show or set current USB storage device\n"
de39f8c1	666	"usb part [dev] - print partition table of one or all USB storage"
7d9aa8fd	667	" devices\n"
5cf91d6b	668	"usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n"
842404ea	669	" to memory address `addr'\n"
127e1084 MJ	670	"usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'\n"
127e1084 MJ	671	" from memory address `addr'"
7d9aa8fd	672	#endif /* CONFIG_USB_STORAGE */
8bde7f77 WD	673	);
	674
	675
7d9aa8fd	676	#ifdef CONFIG_USB_STORAGE
0d498393 WD	677	U_BOOT_CMD(
0d498393 WD	678	usbboot, 3, 1, do_usbboot,
2fb2604d	679	"boot from USB device",
a89c33db	680	"loadAddr dev:part"
8bde7f77	681	);
7d9aa8fd	682	#endif /* CONFIG_USB_STORAGE */