Eric Lee / smarc-uboot | Embedian Git Server

Browse Code »

Commit 8a6b088aff969a125cf4ed21f7608112f8b722e5

Authored by Tom Rini 2014-10-07 03:49:50 +0800

2 parents 04de09f89b e2140588dd

Exists in v2017.01-smarct4x and in 37 other branches

Merge branch 'master' of git://git.denx.de/u-boot-usb

Showing 16 changed files Inline Diff

common/cmd_usb.c
common/stdio.c
common/usb_kbd.c
drivers/serial/serial-uclass.c
drivers/usb/gadget/ci_udc.c
drivers/usb/gadget/f_dfu.c
drivers/usb/gadget/f_fastboot.c
drivers/usb/gadget/f_mass_storage.c
drivers/usb/gadget/f_thor.c
drivers/usb/host/ehci-hcd.c
drivers/usb/host/ehci-tegra.c
drivers/usb/host/ehci.h
drivers/usb/musb-new/musb_core.c
include/configs/siemens-am33x-common.h
include/stdio_dev.h
include/usb.h

common/cmd_usb.c

Diff comments View file @ 8a6b088

 /*
  * (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) {
-#ifdef CONFIG_USB_KEYBOARD
+		if (argc != 2)
-		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();
+		if (do_usb_stop_keyboard(0) != 0)
-		}
+			return 1;
-#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 */
 );

common/stdio.c

Diff comments View file @ 8a6b088

 /*
  * Copyright (C) 2009 Sergey Kubushyn <ksi@koi8.net>
  *
  * Changes for multibus/multiadapter I2C support.
  *
  * (C) Copyright 2000
  * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <config.h>
 #include <common.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <malloc.h>
 #include <stdio_dev.h>
 #include <serial.h>
 #ifdef CONFIG_LOGBUFFER
 #include <logbuff.h>
 #endif
 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SYS_I2C)
 #include <i2c.h>
 #endif
 DECLARE_GLOBAL_DATA_PTR;
 static struct stdio_dev devs;
 struct stdio_dev *stdio_devices[] = { NULL, NULL, NULL };
 char *stdio_names[MAX_FILES] = { "stdin", "stdout", "stderr" };
 #if defined(CONFIG_SPLASH_SCREEN) && !defined(CONFIG_SYS_DEVICE_NULLDEV)
 #define	CONFIG_SYS_DEVICE_NULLDEV	1
 #endif
+#ifdef	CONFIG_SYS_STDIO_DEREGISTER
+#define	CONFIG_SYS_DEVICE_NULLDEV	1
+#endif
 #ifdef CONFIG_SYS_DEVICE_NULLDEV
 void nulldev_putc(struct stdio_dev *dev, const char c)
 {
 	/* nulldev is empty! */
 }
 void nulldev_puts(struct stdio_dev *dev, const char *s)
 {
 	/* nulldev is empty! */
 }
 int nulldev_input(struct stdio_dev *dev)
 {
 	/* nulldev is empty! */
 	return 0;
 }
 #endif
 void stdio_serial_putc(struct stdio_dev *dev, const char c)
 {
 	serial_putc(c);
 }
 void stdio_serial_puts(struct stdio_dev *dev, const char *s)
 {
 	serial_puts(s);
 }
 int stdio_serial_getc(struct stdio_dev *dev)
 {
 	return serial_getc();
 }
 int stdio_serial_tstc(struct stdio_dev *dev)
 {
 	return serial_tstc();
 }
 /**************************************************************************
  * SYSTEM DRIVERS
  **************************************************************************
  */
 static void drv_system_init (void)
 {
 	struct stdio_dev dev;
 	memset (&dev, 0, sizeof (dev));
 	strcpy (dev.name, "serial");
 	dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
 	dev.putc = stdio_serial_putc;
 	dev.puts = stdio_serial_puts;
 	dev.getc = stdio_serial_getc;
 	dev.tstc = stdio_serial_tstc;
 	stdio_register (&dev);
 #ifdef CONFIG_SYS_DEVICE_NULLDEV
 	memset (&dev, 0, sizeof (dev));
 	strcpy (dev.name, "nulldev");
 	dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
 	dev.putc = nulldev_putc;
 	dev.puts = nulldev_puts;
 	dev.getc = nulldev_input;
 	dev.tstc = nulldev_input;
 	stdio_register (&dev);
 #endif
 }
 /**************************************************************************
  * DEVICES
  **************************************************************************
  */
 struct list_head* stdio_get_list(void)
 {
 	return &(devs.list);
 }
 struct stdio_dev* stdio_get_by_name(const char *name)
 {
 	struct list_head *pos;
 	struct stdio_dev *dev;
 	if(!name)
 		return NULL;
 	list_for_each(pos, &(devs.list)) {
 		dev = list_entry(pos, struct stdio_dev, list);
 		if(strcmp(dev->name, name) == 0)
 			return dev;
 	}
 	return NULL;
 }
 struct stdio_dev* stdio_clone(struct stdio_dev *dev)
 {
 	struct stdio_dev *_dev;
 	if(!dev)
 		return NULL;
 	_dev = calloc(1, sizeof(struct stdio_dev));
 	if(!_dev)
 		return NULL;
 	memcpy(_dev, dev, sizeof(struct stdio_dev));
 	return _dev;
 }
 int stdio_register_dev(struct stdio_dev *dev, struct stdio_dev **devp)
 {
 	struct stdio_dev *_dev;
 	_dev = stdio_clone(dev);
 	if(!_dev)
 		return -ENODEV;
 	list_add_tail(&(_dev->list), &(devs.list));
 	if (devp)
 		*devp = _dev;
 	return 0;
 }
 int stdio_register(struct stdio_dev *dev)
 {
 	return stdio_register_dev(dev, NULL);
 }
 /* deregister the device "devname".
  * returns 0 if success, -1 if device is assigned and 1 if devname not found
  */
 #ifdef	CONFIG_SYS_STDIO_DEREGISTER
-int stdio_deregister_dev(struct stdio_dev *dev)
+int stdio_deregister_dev(struct stdio_dev *dev, int force)
 {
 	int l;
 	struct list_head *pos;
 	char temp_names[3][16];
 	/* get stdio devices (ListRemoveItem changes the dev list) */
 	for (l=0 ; l< MAX_FILES; l++) {
 		if (stdio_devices[l] == dev) {
+			if (force) {
+				strcpy(temp_names[l], "nulldev");
+				continue;
+			}
 			/* Device is assigned -> report error */
 			return -1;
 		}
 		memcpy (&temp_names[l][0],
 			stdio_devices[l]->name,
 			sizeof(temp_names[l]));
 	}
 	list_del(&(dev->list));
 	/* reassign Device list */
 	list_for_each(pos, &(devs.list)) {
 		dev = list_entry(pos, struct stdio_dev, list);
 		for (l=0 ; l< MAX_FILES; l++) {
 			if(strcmp(dev->name, temp_names[l]) == 0)
 				stdio_devices[l] = dev;
 		}
 	}
 	return 0;
 }
-int stdio_deregister(const char *devname)
+int stdio_deregister(const char *devname, int force)
 {
 	struct stdio_dev *dev;
 	dev = stdio_get_by_name(devname);
 	if (!dev) /* device not found */
 		return -ENODEV;
-	return stdio_deregister_dev(dev);
+	return stdio_deregister_dev(dev, force);
 }
 #endif	/* CONFIG_SYS_STDIO_DEREGISTER */
 int stdio_init_tables(void)
 {
 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 	/* already relocated for current ARM implementation */
 	ulong relocation_offset = gd->reloc_off;
 	int i;
 	/* relocate device name pointers */
 	for (i = 0; i < (sizeof (stdio_names) / sizeof (char *)); ++i) {
 		stdio_names[i] = (char *) (((ulong) stdio_names[i]) +
 						relocation_offset);
 	}
 #endif /* CONFIG_NEEDS_MANUAL_RELOC */
 	/* Initialize the list */
 	INIT_LIST_HEAD(&(devs.list));
 	return 0;
 }
 int stdio_add_devices(void)
 {
 #ifdef CONFIG_SYS_I2C
 	i2c_init_all();
 #else
 #if defined(CONFIG_HARD_I2C)
 	i2c_init (CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
 #endif
 #endif
 #ifdef CONFIG_LCD
 	drv_lcd_init ();
 #endif
 #if defined(CONFIG_VIDEO) || defined(CONFIG_CFB_CONSOLE)
 	drv_video_init ();
 #endif
 #ifdef CONFIG_KEYBOARD
 	drv_keyboard_init ();
 #endif
 #ifdef CONFIG_LOGBUFFER
 	drv_logbuff_init ();
 #endif
 	drv_system_init ();
 	serial_stdio_init ();
 #ifdef CONFIG_USB_TTY
 	drv_usbtty_init ();
 #endif
 #ifdef CONFIG_NETCONSOLE
 	drv_nc_init ();
 #endif
 #ifdef CONFIG_JTAG_CONSOLE
 	drv_jtag_console_init ();
 #endif
 #ifdef CONFIG_CBMEM_CONSOLE
 	cbmemc_init();
 #endif
 	return 0;
 }
 int stdio_init(void)
 {
 	stdio_init_tables();
 	stdio_add_devices();
 	return 0;
 }

common/usb_kbd.c

Diff comments View file @ 8a6b088

 /*
  * (C) Copyright 2001
  * Denis Peter, MPL AG Switzerland
  *
  * Part of this source has been derived from the Linux USB
  * project.
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
+#include <errno.h>
 #include <malloc.h>
 #include <stdio_dev.h>
 #include <asm/byteorder.h>
 #include <usb.h>
 /*
  * If overwrite_console returns 1, the stdin, stderr and stdout
  * are switched to the serial port, else the settings in the
  * environment are used
  */
 #ifdef CONFIG_SYS_CONSOLE_OVERWRITE_ROUTINE
 extern int overwrite_console(void);
 #else
 int overwrite_console(void)
 {
 	return 0;
 }
 #endif
 /* Keyboard sampling rate */
 #define REPEAT_RATE	(40 / 4)	/* 40msec -> 25cps */
 #define REPEAT_DELAY	10		/* 10 x REPEAT_RATE = 400msec */
 #define NUM_LOCK	0x53
 #define CAPS_LOCK	0x39
 #define SCROLL_LOCK	0x47
 /* Modifier bits */
 #define LEFT_CNTR	(1 << 0)
 #define LEFT_SHIFT	(1 << 1)
 #define LEFT_ALT	(1 << 2)
 #define LEFT_GUI	(1 << 3)
 #define RIGHT_CNTR	(1 << 4)
 #define RIGHT_SHIFT	(1 << 5)
 #define RIGHT_ALT	(1 << 6)
 #define RIGHT_GUI	(1 << 7)
 /* Size of the keyboard buffer */
 #define USB_KBD_BUFFER_LEN	0x20
 /* Device name */
 #define DEVNAME			"usbkbd"
 /* Keyboard maps */
 static const unsigned char usb_kbd_numkey[] = {
 	'1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
 	'\r', 0x1b, '\b', '\t', ' ', '-', '=', '[', ']',
 	'\\', '#', ';', '\'', '`', ',', '.', '/'
 };
 static const unsigned char usb_kbd_numkey_shifted[] = {
 	'!', '@', '#', '$', '%', '^', '&', '*', '(', ')',
 	'\r', 0x1b, '\b', '\t', ' ', '_', '+', '{', '}',
 	'|', '~', ':', '"', '~', '<', '>', '?'
 };
 static const unsigned char usb_kbd_num_keypad[] = {
 	'/', '*', '-', '+', '\r',
 	'1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
 	'.', 0, 0, 0, '='
 };
 /*
  * map arrow keys to ^F/^B ^N/^P, can't really use the proper
  * ANSI sequence for arrow keys because the queuing code breaks
  * when a single keypress expands to 3 queue elements
  */
 static const unsigned char usb_kbd_arrow[] = {
 	0x6, 0x2, 0xe, 0x10
 };
 /*
  * NOTE: It's important for the NUM, CAPS, SCROLL-lock bits to be in this
  *       order. See usb_kbd_setled() function!
  */
 #define USB_KBD_NUMLOCK		(1 << 0)
 #define USB_KBD_CAPSLOCK	(1 << 1)
 #define USB_KBD_SCROLLLOCK	(1 << 2)
 #define USB_KBD_CTRL		(1 << 3)
 #define USB_KBD_LEDMASK		\
 	(USB_KBD_NUMLOCK | USB_KBD_CAPSLOCK | USB_KBD_SCROLLLOCK)
 /*
  * USB Keyboard reports are 8 bytes in boot protocol.
  * Appendix B of HID Device Class Definition 1.11
  */
 #define USB_KBD_BOOT_REPORT_SIZE 8
 struct usb_kbd_pdata {
 	uint32_t	repeat_delay;
 	uint32_t	usb_in_pointer;
 	uint32_t	usb_out_pointer;
 	uint8_t		usb_kbd_buffer[USB_KBD_BUFFER_LEN];
 	uint8_t		*new;
 	uint8_t		old[USB_KBD_BOOT_REPORT_SIZE];
 	uint8_t		flags;
 };
 extern int __maybe_unused net_busy_flag;
 /* The period of time between two calls of usb_kbd_testc(). */
 static unsigned long __maybe_unused kbd_testc_tms;
 /* Generic keyboard event polling. */
 void usb_kbd_generic_poll(void)
 {
 	struct stdio_dev *dev;
 	struct usb_device *usb_kbd_dev;
 	struct usb_kbd_pdata *data;
 	struct usb_interface *iface;
 	struct usb_endpoint_descriptor *ep;
 	int pipe;
 	int maxp;
 	/* Get the pointer to USB Keyboard device pointer */
 	dev = stdio_get_by_name(DEVNAME);
 	usb_kbd_dev = (struct usb_device *)dev->priv;
 	data = usb_kbd_dev->privptr;
 	iface = &usb_kbd_dev->config.if_desc[0];
 	ep = &iface->ep_desc[0];
 	pipe = usb_rcvintpipe(usb_kbd_dev, ep->bEndpointAddress);
 	/* Submit a interrupt transfer request */
 	maxp = usb_maxpacket(usb_kbd_dev, pipe);
 	usb_submit_int_msg(usb_kbd_dev, pipe, data->new,
 		min(maxp, USB_KBD_BOOT_REPORT_SIZE),
 		ep->bInterval);
 }
 /* Puts character in the queue and sets up the in and out pointer. */
 static void usb_kbd_put_queue(struct usb_kbd_pdata *data, char c)
 {
 	if (data->usb_in_pointer == USB_KBD_BUFFER_LEN - 1) {
 		/* Check for buffer full. */
 		if (data->usb_out_pointer == 0)
 			return;
 		data->usb_in_pointer = 0;
 	} else {
 		/* Check for buffer full. */
 		if (data->usb_in_pointer == data->usb_out_pointer - 1)
 			return;
 		data->usb_in_pointer++;
 	}
 	data->usb_kbd_buffer[data->usb_in_pointer] = c;
 }
 /*
  * Set the LEDs. Since this is used in the irq routine, the control job is
  * issued with a timeout of 0. This means, that the job is queued without
  * waiting for job completion.
  */
 static void usb_kbd_setled(struct usb_device *dev)
 {
 	struct usb_interface *iface = &dev->config.if_desc[0];
 	struct usb_kbd_pdata *data = dev->privptr;
-	uint32_t leds = data->flags & USB_KBD_LEDMASK;
+	ALLOC_ALIGN_BUFFER(uint32_t, leds, 1, USB_DMA_MINALIGN);
+	*leds = data->flags & USB_KBD_LEDMASK;
 	usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 		USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-		0x200, iface->desc.bInterfaceNumber, (void *)&leds, 1, 0);
+		0x200, iface->desc.bInterfaceNumber, leds, 1, 0);
 }
 #define CAPITAL_MASK	0x20
 /* Translate the scancode in ASCII */
 static int usb_kbd_translate(struct usb_kbd_pdata *data, unsigned char scancode,
 				unsigned char modifier, int pressed)
 {
 	uint8_t keycode = 0;
 	/* Key released */
 	if (pressed == 0) {
 		data->repeat_delay = 0;
 		return 0;
 	}
 	if (pressed == 2) {
 		data->repeat_delay++;
 		if (data->repeat_delay < REPEAT_DELAY)
 			return 0;
 		data->repeat_delay = REPEAT_DELAY;
 	}
 	/* Alphanumeric values */
 	if ((scancode > 3) && (scancode <= 0x1d)) {
 		keycode = scancode - 4 + 'a';
 		if (data->flags & USB_KBD_CAPSLOCK)
 			keycode &= ~CAPITAL_MASK;
 		if (modifier & (LEFT_SHIFT | RIGHT_SHIFT)) {
 			/* Handle CAPSLock + Shift pressed simultaneously */
 			if (keycode & CAPITAL_MASK)
 				keycode &= ~CAPITAL_MASK;
 			else
 				keycode |= CAPITAL_MASK;
 		}
 	}
 	if ((scancode > 0x1d) && (scancode < 0x3a)) {
 		/* Shift pressed */
 		if (modifier & (LEFT_SHIFT | RIGHT_SHIFT))
 			keycode = usb_kbd_numkey_shifted[scancode - 0x1e];
 		else
 			keycode = usb_kbd_numkey[scancode - 0x1e];
 	}
 	/* Arrow keys */
 	if ((scancode >= 0x4f) && (scancode <= 0x52))
 		keycode = usb_kbd_arrow[scancode - 0x4f];
 	/* Numeric keypad */
 	if ((scancode >= 0x54) && (scancode <= 0x67))
 		keycode = usb_kbd_num_keypad[scancode - 0x54];
 	if (data->flags & USB_KBD_CTRL)
 		keycode = scancode - 0x3;
 	if (pressed == 1) {
 		if (scancode == NUM_LOCK) {
 			data->flags ^= USB_KBD_NUMLOCK;
 			return 1;
 		}
 		if (scancode == CAPS_LOCK) {
 			data->flags ^= USB_KBD_CAPSLOCK;
 			return 1;
 		}
 		if (scancode == SCROLL_LOCK) {
 			data->flags ^= USB_KBD_SCROLLLOCK;
 			return 1;
 		}
 	}
 	/* Report keycode if any */
 	if (keycode) {
 		debug("%c", keycode);
 		usb_kbd_put_queue(data, keycode);
 	}
 	return 0;
 }
 static uint32_t usb_kbd_service_key(struct usb_device *dev, int i, int up)
 {
 	uint32_t res = 0;
 	struct usb_kbd_pdata *data = dev->privptr;
 	uint8_t *new;
 	uint8_t *old;
 	if (up) {
 		new = data->old;
 		old = data->new;
 	} else {
 		new = data->new;
 		old = data->old;
 	}
 	if ((old[i] > 3) &&
 	    (memscan(new + 2, old[i], USB_KBD_BOOT_REPORT_SIZE - 2) ==
 			new + USB_KBD_BOOT_REPORT_SIZE)) {
 		res |= usb_kbd_translate(data, old[i], data->new[0], up);
 	}
 	return res;
 }
 /* Interrupt service routine */
 static int usb_kbd_irq_worker(struct usb_device *dev)
 {
 	struct usb_kbd_pdata *data = dev->privptr;
 	int i, res = 0;
 	/* No combo key pressed */
 	if (data->new[0] == 0x00)
 		data->flags &= ~USB_KBD_CTRL;
 	/* Left or Right Ctrl pressed */
 	else if ((data->new[0] == LEFT_CNTR) || (data->new[0] == RIGHT_CNTR))
 		data->flags |= USB_KBD_CTRL;
 	for (i = 2; i < USB_KBD_BOOT_REPORT_SIZE; i++) {
 		res |= usb_kbd_service_key(dev, i, 0);
 		res |= usb_kbd_service_key(dev, i, 1);
 	}
 	/* Key is still pressed */
 	if ((data->new[2] > 3) && (data->old[2] == data->new[2]))
 		res |= usb_kbd_translate(data, data->new[2], data->new[0], 2);
 	if (res == 1)
 		usb_kbd_setled(dev);
 	memcpy(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE);
 	return 1;
 }
 /* Keyboard interrupt handler */
 static int usb_kbd_irq(struct usb_device *dev)
 {
 	if ((dev->irq_status != 0) ||
 	    (dev->irq_act_len != USB_KBD_BOOT_REPORT_SIZE)) {
 		debug("USB KBD: Error %lX, len %d\n",
 		      dev->irq_status, dev->irq_act_len);
 		return 1;
 	}
 	return usb_kbd_irq_worker(dev);
 }
 /* Interrupt polling */
 static inline void usb_kbd_poll_for_event(struct usb_device *dev)
 {
 #if	defined(CONFIG_SYS_USB_EVENT_POLL)
 	struct usb_interface *iface;
 	struct usb_endpoint_descriptor *ep;
 	struct usb_kbd_pdata *data;
 	int pipe;
 	int maxp;
 	/* Get the pointer to USB Keyboard device pointer */
 	data = dev->privptr;
 	iface = &dev->config.if_desc[0];
 	ep = &iface->ep_desc[0];
 	pipe = usb_rcvintpipe(dev, ep->bEndpointAddress);
 	/* Submit a interrupt transfer request */
 	maxp = usb_maxpacket(dev, pipe);
 	usb_submit_int_msg(dev, pipe, &data->new[0],
 		min(maxp, USB_KBD_BOOT_REPORT_SIZE),
 		ep->bInterval);
 	usb_kbd_irq_worker(dev);
 #elif	defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
 	struct usb_interface *iface;
 	struct usb_kbd_pdata *data = dev->privptr;
 	iface = &dev->config.if_desc[0];
 	usb_get_report(dev, iface->desc.bInterfaceNumber,
 		       1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE);
 	if (memcmp(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE))
 		usb_kbd_irq_worker(dev);
 #endif
 }
 /* test if a character is in the queue */
 static int usb_kbd_testc(struct stdio_dev *sdev)
 {
 	struct stdio_dev *dev;
 	struct usb_device *usb_kbd_dev;
 	struct usb_kbd_pdata *data;
 #ifdef CONFIG_CMD_NET
 	/*
 	 * If net_busy_flag is 1, NET transfer is running,
 	 * then we check key-pressed every second (first check may be
 	 * less than 1 second) to improve TFTP booting performance.
 	 */
 	if (net_busy_flag && (get_timer(kbd_testc_tms) < CONFIG_SYS_HZ))
 		return 0;
 	kbd_testc_tms = get_timer(0);
 #endif
 	dev = stdio_get_by_name(DEVNAME);
 	usb_kbd_dev = (struct usb_device *)dev->priv;
 	data = usb_kbd_dev->privptr;
 	usb_kbd_poll_for_event(usb_kbd_dev);
 	return !(data->usb_in_pointer == data->usb_out_pointer);
 }
 /* gets the character from the queue */
 static int usb_kbd_getc(struct stdio_dev *sdev)
 {
 	struct stdio_dev *dev;
 	struct usb_device *usb_kbd_dev;
 	struct usb_kbd_pdata *data;
 	dev = stdio_get_by_name(DEVNAME);
 	usb_kbd_dev = (struct usb_device *)dev->priv;
 	data = usb_kbd_dev->privptr;
 	while (data->usb_in_pointer == data->usb_out_pointer)
 		usb_kbd_poll_for_event(usb_kbd_dev);
 	if (data->usb_out_pointer == USB_KBD_BUFFER_LEN - 1)
 		data->usb_out_pointer = 0;
 	else
 		data->usb_out_pointer++;
 	return data->usb_kbd_buffer[data->usb_out_pointer];
 }
 /* probes the USB device dev for keyboard type. */
 static int usb_kbd_probe(struct usb_device *dev, unsigned int ifnum)
 {
 	struct usb_interface *iface;
 	struct usb_endpoint_descriptor *ep;
 	struct usb_kbd_pdata *data;
 	int pipe, maxp;
 	if (dev->descriptor.bNumConfigurations != 1)
 		return 0;
 	iface = &dev->config.if_desc[ifnum];
 	if (iface->desc.bInterfaceClass != 3)
 		return 0;
 	if (iface->desc.bInterfaceSubClass != 1)
 		return 0;
 	if (iface->desc.bInterfaceProtocol != 1)
 		return 0;
 	if (iface->desc.bNumEndpoints != 1)
 		return 0;
 	ep = &iface->ep_desc[0];
 	/* Check if endpoint 1 is interrupt endpoint */
 	if (!(ep->bEndpointAddress & 0x80))
 		return 0;
 	if ((ep->bmAttributes & 3) != 3)
 		return 0;
 	debug("USB KBD: found set protocol...\n");
 	data = malloc(sizeof(struct usb_kbd_pdata));
 	if (!data) {
 		printf("USB KBD: Error allocating private data\n");
 		return 0;
 	}
 	/* Clear private data */
 	memset(data, 0, sizeof(struct usb_kbd_pdata));
 	/* allocate input buffer aligned and sized to USB DMA alignment */
 	data->new = memalign(USB_DMA_MINALIGN,
 		roundup(USB_KBD_BOOT_REPORT_SIZE, USB_DMA_MINALIGN));
 	/* Insert private data into USB device structure */
 	dev->privptr = data;
 	/* Set IRQ handler */
 	dev->irq_handle = usb_kbd_irq;
 	pipe = usb_rcvintpipe(dev, ep->bEndpointAddress);
 	maxp = usb_maxpacket(dev, pipe);
 	/* We found a USB Keyboard, install it. */
 	usb_set_protocol(dev, iface->desc.bInterfaceNumber, 0);
 	debug("USB KBD: found set idle...\n");
 	usb_set_idle(dev, iface->desc.bInterfaceNumber, REPEAT_RATE, 0);
 	debug("USB KBD: enable interrupt pipe...\n");
 	if (usb_submit_int_msg(dev, pipe, data->new,
 			       min(maxp, USB_KBD_BOOT_REPORT_SIZE),
 			       ep->bInterval) < 0) {
 		printf("Failed to get keyboard state from device %04x:%04x\n",
 		       dev->descriptor.idVendor, dev->descriptor.idProduct);
 		/* Abort, we don't want to use that non-functional keyboard. */
 		return 0;
 	}
 	/* Success. */
 	return 1;
 }
 /* Search for keyboard and register it if found. */
 int drv_usb_kbd_init(void)
 {
-	struct stdio_dev usb_kbd_dev, *old_dev;
+	struct stdio_dev usb_kbd_dev;
 	struct usb_device *dev;
 	char *stdinname = getenv("stdin");
 	int error, i;
 	/* Scan all USB Devices */
 	for (i = 0; i < USB_MAX_DEVICE; i++) {
 		/* Get USB device. */
 		dev = usb_get_dev_index(i);
 		if (!dev)
 			return -1;
 		if (dev->devnum == -1)
 			continue;
 		/* Try probing the keyboard */
 		if (usb_kbd_probe(dev, 0) != 1)
 			continue;
-		/* We found a keyboard, check if it is already registered. */
-		debug("USB KBD: found set up device.\n");
-		old_dev = stdio_get_by_name(DEVNAME);
-		if (old_dev) {
-			/* Already registered, just return ok. */
-			debug("USB KBD: is already registered.\n");
-			usb_kbd_deregister();
-			return 1;
-		}
 		/* Register the keyboard */
 		debug("USB KBD: register.\n");
 		memset(&usb_kbd_dev, 0, sizeof(struct stdio_dev));
 		strcpy(usb_kbd_dev.name, DEVNAME);
 		usb_kbd_dev.flags =  DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
 		usb_kbd_dev.getc = usb_kbd_getc;
 		usb_kbd_dev.tstc = usb_kbd_testc;
 		usb_kbd_dev.priv = (void *)dev;
 		error = stdio_register(&usb_kbd_dev);
 		if (error)
 			return error;
 #ifdef CONFIG_CONSOLE_MUX
 		error = iomux_doenv(stdin, stdinname);
 		if (error)
 			return error;
 #else
 		/* Check if this is the standard input device. */
 		if (strcmp(stdinname, DEVNAME))
 			return 1;
 		/* Reassign the console */
 		if (overwrite_console())
 			return 1;
 		error = console_assign(stdin, DEVNAME);
 		if (error)
 			return error;
 #endif
 		return 1;
 	}
 	/* No USB Keyboard found */
 	return -1;
 }
 /* Deregister the keyboard. */
-int usb_kbd_deregister(void)
+int usb_kbd_deregister(int force)
 {
 #ifdef CONFIG_SYS_STDIO_DEREGISTER
-	return stdio_deregister(DEVNAME);
+	int ret = stdio_deregister(DEVNAME, force);
+	if (ret && ret != -ENODEV)
+		return ret;

drivers/serial/serial-uclass.c

Diff comments View file @ 8a6b088

1	/*	1	/*
2	* Copyright (c) 2014 The Chromium OS Authors.	2	* Copyright (c) 2014 The Chromium OS Authors.
3	*	3	*
4	* SPDX-License-Identifier: GPL-2.0+	4	* SPDX-License-Identifier: GPL-2.0+
5	*/	5	*/
6		6
7	#include <common.h>	7	#include <common.h>
8	#include <dm.h>	8	#include <dm.h>
9	#include <errno.h>	9	#include <errno.h>
10	#include <fdtdec.h>	10	#include <fdtdec.h>
11	#include <os.h>	11	#include <os.h>
12	#include <serial.h>	12	#include <serial.h>
13	#include <stdio_dev.h>	13	#include <stdio_dev.h>
14	#include <dm/lists.h>	14	#include <dm/lists.h>
15	#include <dm/device-internal.h>	15	#include <dm/device-internal.h>
16		16
17	DECLARE_GLOBAL_DATA_PTR;	17	DECLARE_GLOBAL_DATA_PTR;
18		18
19	/* The currently-selected console serial device */	19	/* The currently-selected console serial device */
20	struct udevice *cur_dev __attribute__ ((section(".data")));	20	struct udevice *cur_dev __attribute__ ((section(".data")));
21		21
22	#ifndef CONFIG_SYS_MALLOC_F_LEN	22	#ifndef CONFIG_SYS_MALLOC_F_LEN
23	#error "Serial is required before relocation - define CONFIG_SYS_MALLOC_F_LEN to make this work"	23	#error "Serial is required before relocation - define CONFIG_SYS_MALLOC_F_LEN to make this work"
24	#endif	24	#endif
25		25
26	static void serial_find_console_or_panic(void)	26	static void serial_find_console_or_panic(void)
27	{	27	{
28	#ifdef CONFIG_OF_CONTROL	28	#ifdef CONFIG_OF_CONTROL
29	int node;	29	int node;
30		30
31	/* Check for a chosen console */	31	/* Check for a chosen console */
32	node = fdtdec_get_chosen_node(gd->fdt_blob, "stdout-path");	32	node = fdtdec_get_chosen_node(gd->fdt_blob, "stdout-path");
33	if (node < 0)	33	if (node < 0)
34	node = fdtdec_get_alias_node(gd->fdt_blob, "console");	34	node = fdtdec_get_alias_node(gd->fdt_blob, "console");
35	if (!uclass_get_device_by_of_offset(UCLASS_SERIAL, node, &cur_dev))	35	if (!uclass_get_device_by_of_offset(UCLASS_SERIAL, node, &cur_dev))
36	return;	36	return;
37		37
38	/*	38	/*
39	* If the console is not marked to be bound before relocation, bind	39	* If the console is not marked to be bound before relocation, bind
40	* it anyway.	40	* it anyway.
41	*/	41	*/
42	if (node > 0 &&	42	if (node > 0 &&
43	!lists_bind_fdt(gd->dm_root, gd->fdt_blob, node, &cur_dev)) {	43	!lists_bind_fdt(gd->dm_root, gd->fdt_blob, node, &cur_dev)) {
44	if (!device_probe(cur_dev))	44	if (!device_probe(cur_dev))
45	return;	45	return;
46	cur_dev = NULL;	46	cur_dev = NULL;
47	}	47	}
48	#endif	48	#endif
49	/*	49	/*
50	* Failing that, get the device with sequence number 0, or in extremis	50	* Failing that, get the device with sequence number 0, or in extremis
51	* just the first serial device we can find. But we insist on having	51	* just the first serial device we can find. But we insist on having
52	* a console (even if it is silent).	52	* a console (even if it is silent).
53	*/	53	*/
54	if (uclass_get_device_by_seq(UCLASS_SERIAL, 0, &cur_dev) &&	54	if (uclass_get_device_by_seq(UCLASS_SERIAL, 0, &cur_dev) &&
55	(uclass_first_device(UCLASS_SERIAL, &cur_dev) \|\| !cur_dev))	55	(uclass_first_device(UCLASS_SERIAL, &cur_dev) \|\| !cur_dev))
56	panic("No serial driver found");	56	panic("No serial driver found");
57	}	57	}
58		58
59	/* Called prior to relocation */	59	/* Called prior to relocation */
60	int serial_init(void)	60	int serial_init(void)
61	{	61	{
62	serial_find_console_or_panic();	62	serial_find_console_or_panic();
63	gd->flags \|= GD_FLG_SERIAL_READY;	63	gd->flags \|= GD_FLG_SERIAL_READY;
64		64
65	return 0;	65	return 0;
66	}	66	}
67		67
68	/* Called after relocation */	68	/* Called after relocation */
69	void serial_initialize(void)	69	void serial_initialize(void)
70	{	70	{
71	serial_find_console_or_panic();	71	serial_find_console_or_panic();
72	}	72	}
73		73
74	void serial_putc(char ch)	74	void serial_putc(char ch)
75	{	75	{
76	struct dm_serial_ops *ops = serial_get_ops(cur_dev);	76	struct dm_serial_ops *ops = serial_get_ops(cur_dev);
77	int err;	77	int err;
78		78
79	do {	79	do {
80	err = ops->putc(cur_dev, ch);	80	err = ops->putc(cur_dev, ch);
81	} while (err == -EAGAIN);	81	} while (err == -EAGAIN);
82	if (ch == '\n')	82	if (ch == '\n')
83	serial_putc('\r');	83	serial_putc('\r');
84	}	84	}
85		85
86	void serial_setbrg(void)	86	void serial_setbrg(void)
87	{	87	{
88	struct dm_serial_ops *ops = serial_get_ops(cur_dev);	88	struct dm_serial_ops *ops = serial_get_ops(cur_dev);
89		89
90	if (ops->setbrg)	90	if (ops->setbrg)
91	ops->setbrg(cur_dev, gd->baudrate);	91	ops->setbrg(cur_dev, gd->baudrate);
92	}	92	}
93		93
94	void serial_puts(const char *str)	94	void serial_puts(const char *str)
95	{	95	{
96	while (*str)	96	while (*str)
97	serial_putc(*str++);	97	serial_putc(*str++);
98	}	98	}
99		99
100	int serial_tstc(void)	100	int serial_tstc(void)
101	{	101	{
102	struct dm_serial_ops *ops = serial_get_ops(cur_dev);	102	struct dm_serial_ops *ops = serial_get_ops(cur_dev);
103		103
104	if (ops->pending)	104	if (ops->pending)
105	return ops->pending(cur_dev, true);	105	return ops->pending(cur_dev, true);
106		106
107	return 1;	107	return 1;
108	}	108	}
109		109
110	int serial_getc(void)	110	int serial_getc(void)
111	{	111	{
112	struct dm_serial_ops *ops = serial_get_ops(cur_dev);	112	struct dm_serial_ops *ops = serial_get_ops(cur_dev);
113	int err;	113	int err;
114		114
115	do {	115	do {
116	err = ops->getc(cur_dev);	116	err = ops->getc(cur_dev);
117	} while (err == -EAGAIN);	117	} while (err == -EAGAIN);
118		118
119	return err >= 0 ? err : 0;	119	return err >= 0 ? err : 0;
120	}	120	}
121		121
122	void serial_stdio_init(void)	122	void serial_stdio_init(void)
123	{	123	{
124	}	124	}
125		125
126	void serial_stub_putc(struct stdio_dev *sdev, const char ch)	126	void serial_stub_putc(struct stdio_dev *sdev, const char ch)
127	{	127	{
128	struct udevice *dev = sdev->priv;	128	struct udevice *dev = sdev->priv;
129	struct dm_serial_ops *ops = serial_get_ops(dev);	129	struct dm_serial_ops *ops = serial_get_ops(dev);
130		130
131	ops->putc(dev, ch);	131	ops->putc(dev, ch);
132	}	132	}
133		133
134	void serial_stub_puts(struct stdio_dev sdev, const char str)	134	void serial_stub_puts(struct stdio_dev sdev, const char str)
135	{	135	{
136	while (*str)	136	while (*str)
137	serial_stub_putc(sdev, *str++);	137	serial_stub_putc(sdev, *str++);
138	}	138	}
139		139
140	int serial_stub_getc(struct stdio_dev *sdev)	140	int serial_stub_getc(struct stdio_dev *sdev)
141	{	141	{
142	struct udevice *dev = sdev->priv;	142	struct udevice *dev = sdev->priv;
143	struct dm_serial_ops *ops = serial_get_ops(dev);	143	struct dm_serial_ops *ops = serial_get_ops(dev);
144		144
145	int err;	145	int err;
146		146
147	do {	147	do {
148	err = ops->getc(dev);	148	err = ops->getc(dev);
149	} while (err == -EAGAIN);	149	} while (err == -EAGAIN);
150		150
151	return err >= 0 ? err : 0;	151	return err >= 0 ? err : 0;
152	}	152	}
153		153
154	int serial_stub_tstc(struct stdio_dev *sdev)	154	int serial_stub_tstc(struct stdio_dev *sdev)
155	{	155	{
156	struct udevice *dev = sdev->priv;	156	struct udevice *dev = sdev->priv;
157	struct dm_serial_ops *ops = serial_get_ops(dev);	157	struct dm_serial_ops *ops = serial_get_ops(dev);
158		158
159	if (ops->pending)	159	if (ops->pending)
160	return ops->pending(dev, true);	160	return ops->pending(dev, true);
161		161
162	return 1;	162	return 1;
163	}	163	}
164		164
165	static int serial_post_probe(struct udevice *dev)	165	static int serial_post_probe(struct udevice *dev)
166	{	166	{
167	struct stdio_dev sdev;	167	struct stdio_dev sdev;
168	struct dm_serial_ops *ops = serial_get_ops(dev);	168	struct dm_serial_ops *ops = serial_get_ops(dev);
169	struct serial_dev_priv *upriv = dev->uclass_priv;	169	struct serial_dev_priv *upriv = dev->uclass_priv;
170	int ret;	170	int ret;
171		171
172	/* Set the baud rate */	172	/* Set the baud rate */
173	if (ops->setbrg) {	173	if (ops->setbrg) {
174	ret = ops->setbrg(dev, gd->baudrate);	174	ret = ops->setbrg(dev, gd->baudrate);
175	if (ret)	175	if (ret)
176	return ret;	176	return ret;
177	}	177	}
178		178
179	if (!(gd->flags & GD_FLG_RELOC))	179	if (!(gd->flags & GD_FLG_RELOC))
180	return 0;	180	return 0;
181		181
182	memset(&sdev, '\0', sizeof(sdev));	182	memset(&sdev, '\0', sizeof(sdev));
183		183
184	strncpy(sdev.name, dev->name, sizeof(sdev.name));	184	strncpy(sdev.name, dev->name, sizeof(sdev.name));
185	sdev.flags = DEV_FLAGS_OUTPUT \| DEV_FLAGS_INPUT;	185	sdev.flags = DEV_FLAGS_OUTPUT \| DEV_FLAGS_INPUT;
186	sdev.priv = dev;	186	sdev.priv = dev;
187	sdev.putc = serial_stub_putc;	187	sdev.putc = serial_stub_putc;
188	sdev.puts = serial_stub_puts;	188	sdev.puts = serial_stub_puts;
189	sdev.getc = serial_stub_getc;	189	sdev.getc = serial_stub_getc;
190	sdev.tstc = serial_stub_tstc;	190	sdev.tstc = serial_stub_tstc;
191	stdio_register_dev(&sdev, &upriv->sdev);	191	stdio_register_dev(&sdev, &upriv->sdev);
192		192
193	return 0;	193	return 0;
194	}	194	}
195		195
196	static int serial_pre_remove(struct udevice *dev)	196	static int serial_pre_remove(struct udevice *dev)
197	{	197	{
198	#ifdef CONFIG_SYS_STDIO_DEREGISTER	198	#ifdef CONFIG_SYS_STDIO_DEREGISTER
199	struct serial_dev_priv *upriv = dev->uclass_priv;	199	struct serial_dev_priv *upriv = dev->uclass_priv;
200		200
201	if (stdio_deregister_dev(upriv->sdev))	201	if (stdio_deregister_dev(upriv->sdev), 0)
202	return -EPERM;	202	return -EPERM;
203	#endif	203	#endif
204		204
205	return 0;	205	return 0;
206	}	206	}
207		207
208	UCLASS_DRIVER(serial) = {	208	UCLASS_DRIVER(serial) = {
209	.id = UCLASS_SERIAL,	209	.id = UCLASS_SERIAL,
210	.name = "serial",	210	.name = "serial",
211	.post_probe = serial_post_probe,	211	.post_probe = serial_post_probe,
212	.pre_remove = serial_pre_remove,	212	.pre_remove = serial_pre_remove,
213	.per_device_auto_alloc_size = sizeof(struct serial_dev_priv),	213	.per_device_auto_alloc_size = sizeof(struct serial_dev_priv),
214	};	214	};
215		215

drivers/usb/gadget/ci_udc.c

Diff comments View file @ 8a6b088

 /*
  * Copyright 2011, Marvell Semiconductor Inc.
  * Lei Wen <leiwen@marvell.com>
  *
  * SPDX-License-Identifier:	GPL-2.0+
  *
  * Back ported to the 8xx platform (from the 8260 platform) by
  * Murray.Jensen@cmst.csiro.au, 27-Jan-01.
  */
 #include <common.h>
 #include <command.h>
 #include <config.h>
 #include <net.h>
 #include <malloc.h>
 #include <asm/byteorder.h>
 #include <asm/errno.h>
 #include <asm/io.h>
 #include <asm/unaligned.h>
 #include <linux/types.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 #include <usb/ci_udc.h>
 #include "../host/ehci.h"
 #include "ci_udc.h"
 /*
  * Check if the system has too long cachelines. If the cachelines are
  * longer then 128b, the driver will not be able flush/invalidate data
  * cache over separate QH entries. We use 128b because one QH entry is
  * 64b long and there are always two QH list entries for each endpoint.
  */
 #if ARCH_DMA_MINALIGN > 128
 #error This driver can not work on systems with caches longer than 128b
 #endif
 /*
  * Every QTD must be individually aligned, since we can program any
  * QTD's address into HW. Cache flushing requires ARCH_DMA_MINALIGN,
  * and the USB HW requires 32-byte alignment. Align to both:
  */
 #define ILIST_ALIGN		roundup(ARCH_DMA_MINALIGN, 32)
 /* Each QTD is this size */
 #define ILIST_ENT_RAW_SZ	sizeof(struct ept_queue_item)
 /*
  * Align the size of the QTD too, so we can add this value to each
  * QTD's address to get another aligned address.
  */
 #define ILIST_ENT_SZ		roundup(ILIST_ENT_RAW_SZ, ILIST_ALIGN)
 /* For each endpoint, we need 2 QTDs, one for each of IN and OUT */
 #define ILIST_SZ		(NUM_ENDPOINTS * 2 * ILIST_ENT_SZ)
 #ifndef DEBUG
 #define DBG(x...) do {} while (0)
 #else
 #define DBG(x...) printf(x)
 static const char *reqname(unsigned r)
 {
 	switch (r) {
 	case USB_REQ_GET_STATUS: return "GET_STATUS";
 	case USB_REQ_CLEAR_FEATURE: return "CLEAR_FEATURE";
 	case USB_REQ_SET_FEATURE: return "SET_FEATURE";
 	case USB_REQ_SET_ADDRESS: return "SET_ADDRESS";
 	case USB_REQ_GET_DESCRIPTOR: return "GET_DESCRIPTOR";
 	case USB_REQ_SET_DESCRIPTOR: return "SET_DESCRIPTOR";
 	case USB_REQ_GET_CONFIGURATION: return "GET_CONFIGURATION";
 	case USB_REQ_SET_CONFIGURATION: return "SET_CONFIGURATION";
 	case USB_REQ_GET_INTERFACE: return "GET_INTERFACE";
 	case USB_REQ_SET_INTERFACE: return "SET_INTERFACE";
 	default: return "*UNKNOWN*";
 	}
 }
 #endif
 static struct usb_endpoint_descriptor ep0_desc = {
 	.bLength = sizeof(struct usb_endpoint_descriptor),
 	.bDescriptorType = USB_DT_ENDPOINT,
 	.bEndpointAddress = USB_DIR_IN,
 	.bmAttributes =	USB_ENDPOINT_XFER_CONTROL,
 };
 static int ci_pullup(struct usb_gadget *gadget, int is_on);
 static int ci_ep_enable(struct usb_ep *ep,
 		const struct usb_endpoint_descriptor *desc);
 static int ci_ep_disable(struct usb_ep *ep);
 static int ci_ep_queue(struct usb_ep *ep,
 		struct usb_request *req, gfp_t gfp_flags);
 static struct usb_request *
 ci_ep_alloc_request(struct usb_ep *ep, unsigned int gfp_flags);
 static void ci_ep_free_request(struct usb_ep *ep, struct usb_request *_req);
 static struct usb_gadget_ops ci_udc_ops = {
 	.pullup = ci_pullup,
 };
 static struct usb_ep_ops ci_ep_ops = {
 	.enable         = ci_ep_enable,
 	.disable        = ci_ep_disable,
 	.queue          = ci_ep_queue,
 	.alloc_request  = ci_ep_alloc_request,
 	.free_request   = ci_ep_free_request,
 };
 /* Init values for USB endpoints. */
 static const struct usb_ep ci_ep_init[2] = {
 	[0] = {	/* EP 0 */
 		.maxpacket	= 64,
 		.name		= "ep0",
 		.ops		= &ci_ep_ops,
 	},
 	[1] = {	/* EP 1..n */
 		.maxpacket	= 512,
 		.name		= "ep-",
 		.ops		= &ci_ep_ops,
 	},
 };
 static struct ci_drv controller = {
 	.gadget	= {
 		.name	= "ci_udc",
 		.ops	= &ci_udc_ops,
 		.is_dualspeed = 1,
 	},
 };
 /**
  * ci_get_qh() - return queue head for endpoint
  * @ep_num:	Endpoint number
  * @dir_in:	Direction of the endpoint (IN = 1, OUT = 0)
  *
  * This function returns the QH associated with particular endpoint
  * and it's direction.
  */
 static struct ept_queue_head *ci_get_qh(int ep_num, int dir_in)
 {
 	return &controller.epts[(ep_num * 2) + dir_in];
 }
 /**
  * ci_get_qtd() - return queue item for endpoint
  * @ep_num:	Endpoint number
  * @dir_in:	Direction of the endpoint (IN = 1, OUT = 0)
  *
  * This function returns the QH associated with particular endpoint
  * and it's direction.
  */
 static struct ept_queue_item *ci_get_qtd(int ep_num, int dir_in)
 {
 	int index = (ep_num * 2) + dir_in;
 	uint8_t *imem = controller.items_mem + (index * ILIST_ENT_SZ);
 	return (struct ept_queue_item *)imem;
 }
 /**
  * ci_flush_qh - flush cache over queue head
  * @ep_num:	Endpoint number
  *
  * This function flushes cache over QH for particular endpoint.
  */
 static void ci_flush_qh(int ep_num)
 {
 	struct ept_queue_head *head = ci_get_qh(ep_num, 0);
 	const uint32_t start = (uint32_t)head;
 	const uint32_t end = start + 2 * sizeof(*head);
 	flush_dcache_range(start, end);
 }
 /**
  * ci_invalidate_qh - invalidate cache over queue head
  * @ep_num:	Endpoint number
  *
  * This function invalidates cache over QH for particular endpoint.
  */
 static void ci_invalidate_qh(int ep_num)
 {
 	struct ept_queue_head *head = ci_get_qh(ep_num, 0);
 	uint32_t start = (uint32_t)head;
 	uint32_t end = start + 2 * sizeof(*head);
 	invalidate_dcache_range(start, end);
 }
 /**
  * ci_flush_qtd - flush cache over queue item
  * @ep_num:	Endpoint number
  *
  * This function flushes cache over qTD pair for particular endpoint.
  */
 static void ci_flush_qtd(int ep_num)
 {
 	struct ept_queue_item *item = ci_get_qtd(ep_num, 0);
 	const uint32_t start = (uint32_t)item;
 	const uint32_t end = start + 2 * ILIST_ENT_SZ;
 	flush_dcache_range(start, end);
 }
 /**
  * ci_invalidate_qtd - invalidate cache over queue item
  * @ep_num:	Endpoint number
  *
  * This function invalidates cache over qTD pair for particular endpoint.
  */
 static void ci_invalidate_qtd(int ep_num)
 {
 	struct ept_queue_item *item = ci_get_qtd(ep_num, 0);
 	const uint32_t start = (uint32_t)item;
 	const uint32_t end = start + 2 * ILIST_ENT_SZ;
 	invalidate_dcache_range(start, end);
 }
 static struct usb_request *
 ci_ep_alloc_request(struct usb_ep *ep, unsigned int gfp_flags)
 {
 	struct ci_ep *ci_ep = container_of(ep, struct ci_ep, ep);
 	int num;
 	struct ci_req *ci_req;
 	num = ci_ep->desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	if (num == 0 && controller.ep0_req)
 		return &controller.ep0_req->req;
 	ci_req = calloc(1, sizeof(*ci_req));
 	if (!ci_req)
 		return NULL;
 	INIT_LIST_HEAD(&ci_req->queue);
 	if (num == 0)
 		controller.ep0_req = ci_req;
 	return &ci_req->req;
 }
 static void ci_ep_free_request(struct usb_ep *ep, struct usb_request *req)
 {
 	struct ci_ep *ci_ep = container_of(ep, struct ci_ep, ep);
 	struct ci_req *ci_req = container_of(req, struct ci_req, req);
 	int num;
 	num = ci_ep->desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	if (num == 0) {
 		if (!controller.ep0_req)
 			return;
 		controller.ep0_req = 0;
 	}
 	if (ci_req->b_buf)
 		free(ci_req->b_buf);
 	free(ci_req);
 }
 static void ep_enable(int num, int in, int maxpacket)
 {
 	struct ci_udc *udc = (struct ci_udc *)controller.ctrl->hcor;
 	unsigned n;
 	n = readl(&udc->epctrl[num]);
 	if (in)
 		n |= (CTRL_TXE | CTRL_TXR | CTRL_TXT_BULK);
 	else
 		n |= (CTRL_RXE | CTRL_RXR | CTRL_RXT_BULK);
 	if (num != 0) {
 		struct ept_queue_head *head = ci_get_qh(num, in);
 		head->config = CONFIG_MAX_PKT(maxpacket) | CONFIG_ZLT;
 		ci_flush_qh(num);
 	}
 	writel(n, &udc->epctrl[num]);
 }
 static int ci_ep_enable(struct usb_ep *ep,
 		const struct usb_endpoint_descriptor *desc)
 {
 	struct ci_ep *ci_ep = container_of(ep, struct ci_ep, ep);
 	int num, in;
 	num = desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	in = (desc->bEndpointAddress & USB_DIR_IN) != 0;
 	ci_ep->desc = desc;
 	if (num) {
 		int max = get_unaligned_le16(&desc->wMaxPacketSize);
 		if ((max > 64) && (controller.gadget.speed == USB_SPEED_FULL))
 			max = 64;
 		if (ep->maxpacket != max) {
 			DBG("%s: from %d to %d\n", __func__,
 			    ep->maxpacket, max);
 			ep->maxpacket = max;
 		}
 	}
 	ep_enable(num, in, ep->maxpacket);
 	DBG("%s: num=%d maxpacket=%d\n", __func__, num, ep->maxpacket);
 	return 0;
 }
 static int ci_ep_disable(struct usb_ep *ep)
 {
 	struct ci_ep *ci_ep = container_of(ep, struct ci_ep, ep);
 	ci_ep->desc = NULL;
 	return 0;
 }
 static int ci_bounce(struct ci_req *ci_req, int in)
 {
 	struct usb_request *req = &ci_req->req;
 	uint32_t addr = (uint32_t)req->buf;
 	uint32_t hwaddr;
 	uint32_t aligned_used_len;
 	/* Input buffer address is not aligned. */
 	if (addr & (ARCH_DMA_MINALIGN - 1))
 		goto align;
 	/* Input buffer length is not aligned. */
 	if (req->length & (ARCH_DMA_MINALIGN - 1))
 		goto align;
 	/* The buffer is well aligned, only flush cache. */
 	ci_req->hw_len = req->length;
 	ci_req->hw_buf = req->buf;
 	goto flush;
 align:
 	if (ci_req->b_buf && req->length > ci_req->b_len) {
 		free(ci_req->b_buf);
 		ci_req->b_buf = 0;
 	}
 	if (!ci_req->b_buf) {
 		ci_req->b_len = roundup(req->length, ARCH_DMA_MINALIGN);
 		ci_req->b_buf = memalign(ARCH_DMA_MINALIGN, ci_req->b_len);
 		if (!ci_req->b_buf)
 			return -ENOMEM;
 	}
 	ci_req->hw_len = ci_req->b_len;
 	ci_req->hw_buf = ci_req->b_buf;
 	if (in)
 		memcpy(ci_req->hw_buf, req->buf, req->length);
 flush:
 	hwaddr = (uint32_t)ci_req->hw_buf;
 	aligned_used_len = roundup(req->length, ARCH_DMA_MINALIGN);
 	flush_dcache_range(hwaddr, hwaddr + aligned_used_len);
 	return 0;
 }
 static void ci_debounce(struct ci_req *ci_req, int in)
 {
 	struct usb_request *req = &ci_req->req;
 	uint32_t addr = (uint32_t)req->buf;
 	uint32_t hwaddr = (uint32_t)ci_req->hw_buf;
 	uint32_t aligned_used_len;
 	if (in)
 		return;
 	aligned_used_len = roundup(req->actual, ARCH_DMA_MINALIGN);
 	invalidate_dcache_range(hwaddr, hwaddr + aligned_used_len);
 	if (addr == hwaddr)
 		return; /* not a bounce */
 	memcpy(req->buf, ci_req->hw_buf, req->actual);
 }
 static void ci_ep_submit_next_request(struct ci_ep *ci_ep)
 {
 	struct ci_udc *udc = (struct ci_udc *)controller.ctrl->hcor;
 	struct ept_queue_item *item;
 	struct ept_queue_head *head;
 	int bit, num, len, in;
 	struct ci_req *ci_req;
 	ci_ep->req_primed = true;
 	num = ci_ep->desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	in = (ci_ep->desc->bEndpointAddress & USB_DIR_IN) != 0;
 	item = ci_get_qtd(num, in);
 	head = ci_get_qh(num, in);
 	ci_req = list_first_entry(&ci_ep->queue, struct ci_req, queue);
 	len = ci_req->req.length;
 	item->info = INFO_BYTES(len) | INFO_ACTIVE;
 	item->page0 = (uint32_t)ci_req->hw_buf;
 	item->page1 = ((uint32_t)ci_req->hw_buf & 0xfffff000) + 0x1000;
 	item->page2 = ((uint32_t)ci_req->hw_buf & 0xfffff000) + 0x2000;
 	item->page3 = ((uint32_t)ci_req->hw_buf & 0xfffff000) + 0x3000;
 	item->page4 = ((uint32_t)ci_req->hw_buf & 0xfffff000) + 0x4000;
 	head->next = (unsigned) item;
 	head->info = 0;
 	/*
 	 * When sending the data for an IN transaction, the attached host
 	 * knows that all data for the IN is sent when one of the following
 	 * occurs:
 	 * a) A zero-length packet is transmitted.
 	 * b) A packet with length that isn't an exact multiple of the ep's
 	 *    maxpacket is transmitted.
 	 * c) Enough data is sent to exactly fill the host's maximum expected
 	 *    IN transaction size.
 	 *
 	 * One of these conditions MUST apply at the end of an IN transaction,
 	 * or the transaction will not be considered complete by the host. If
 	 * none of (a)..(c) already applies, then we must force (a) to apply
 	 * by explicitly sending an extra zero-length packet.
 	 */
 	/*  IN    !a     !b                              !c */
 	if (in && len && !(len % ci_ep->ep.maxpacket) && ci_req->req.zero) {
 		/*
 		 * Each endpoint has 2 items allocated, even though typically
 		 * only 1 is used at a time since either an IN or an OUT but
 		 * not both is queued. For an IN transaction, item currently
 		 * points at the second of these items, so we know that we
 		 * can use the other to transmit the extra zero-length packet.
 		 */
 		struct ept_queue_item *other_item = ci_get_qtd(num, 0);
 		item->next = (unsigned)other_item;
 		item = other_item;
 		item->info = INFO_ACTIVE;
 	}
 	item->next = TERMINATE;
 	item->info |= INFO_IOC;
 	ci_flush_qtd(num);
 	DBG("ept%d %s queue len %x, req %p, buffer %p\n",
 	    num, in ? "in" : "out", len, ci_req, ci_req->hw_buf);
 	ci_flush_qh(num);
 	if (in)
 		bit = EPT_TX(num);
 	else
 		bit = EPT_RX(num);
 	writel(bit, &udc->epprime);
 }
 static int ci_ep_queue(struct usb_ep *ep,
 		struct usb_request *req, gfp_t gfp_flags)
 {
 	struct ci_ep *ci_ep = container_of(ep, struct ci_ep, ep);
 	struct ci_req *ci_req = container_of(req, struct ci_req, req);
 	int in, ret;
 	int __maybe_unused num;
 	num = ci_ep->desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	in = (ci_ep->desc->bEndpointAddress & USB_DIR_IN) != 0;
 	if (!num && ci_ep->req_primed) {
 		/*
 		 * The flipping of ep0 between IN and OUT relies on
 		 * ci_ep_queue consuming the current IN/OUT setting
 		 * immediately. If this is deferred to a later point when the
 		 * req is pulled out of ci_req->queue, then the IN/OUT setting
 		 * may have been changed since the req was queued, and state
 		 * will get out of sync. This condition doesn't occur today,
 		 * but could if bugs were introduced later, and this error
 		 * check will save a lot of debugging time.
 		 */
 		printf("%s: ep0 transaction already in progress\n", __func__);
 		return -EPROTO;
 	}
 	ret = ci_bounce(ci_req, in);
 	if (ret)
 		return ret;
 	DBG("ept%d %s pre-queue req %p, buffer %p\n",
 	    num, in ? "in" : "out", ci_req, ci_req->hw_buf);
 	list_add_tail(&ci_req->queue, &ci_ep->queue);
 	if (!ci_ep->req_primed)
 		ci_ep_submit_next_request(ci_ep);
 	return 0;
 }
 static void flip_ep0_direction(void)
 {
 	if (ep0_desc.bEndpointAddress == USB_DIR_IN) {
 		DBG("%s: Flipping ep0 to OUT\n", __func__);
 		ep0_desc.bEndpointAddress = 0;
 	} else {
 		DBG("%s: Flipping ep0 to IN\n", __func__);
 		ep0_desc.bEndpointAddress = USB_DIR_IN;
 	}
 }
 static void handle_ep_complete(struct ci_ep *ci_ep)
 {
 	struct ept_queue_item *item;
 	int num, in, len;
 	struct ci_req *ci_req;
 	num = ci_ep->desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 	in = (ci_ep->desc->bEndpointAddress & USB_DIR_IN) != 0;
 	item = ci_get_qtd(num, in);
 	ci_invalidate_qtd(num);
 	len = (item->info >> 16) & 0x7fff;
 	if (item->info & 0xff)
 		printf("EP%d/%s FAIL info=%x pg0=%x\n",
 		       num, in ? "in" : "out", item->info, item->page0);
 	ci_req = list_first_entry(&ci_ep->queue, struct ci_req, queue);
 	list_del_init(&ci_req->queue);
 	ci_ep->req_primed = false;
 	if (!list_empty(&ci_ep->queue))
 		ci_ep_submit_next_request(ci_ep);
 	ci_req->req.actual = ci_req->req.length - len;
 	ci_debounce(ci_req, in);
 	DBG("ept%d %s req %p, complete %x\n",
 	    num, in ? "in" : "out", ci_req, len);
 	if (num != 0 || controller.ep0_data_phase)
 		ci_req->req.complete(&ci_ep->ep, &ci_req->req);
 	if (num == 0 && controller.ep0_data_phase) {
 		/*
 		 * Data Stage is complete, so flip ep0 dir for Status Stage,
 		 * which always transfers a packet in the opposite direction.
 		 */
 		DBG("%s: flip ep0 dir for Status Stage\n", __func__);
 		flip_ep0_direction();
 		controller.ep0_data_phase = false;
 		ci_req->req.length = 0;
 		usb_ep_queue(&ci_ep->ep, &ci_req->req, 0);
 	}
 }
 #define SETUP(type, request) (((type) << 8) | (request))
 static void handle_setup(void)
 {
 	struct ci_ep *ci_ep = &controller.ep[0];
 	struct ci_req *ci_req;
 	struct usb_request *req;
 	struct ci_udc *udc = (struct ci_udc *)controller.ctrl->hcor;
 	struct ept_queue_head *head;
 	struct usb_ctrlrequest r;
 	int status = 0;
 	int num, in, _num, _in, i;
 	char *buf;
 	ci_req = controller.ep0_req;
 	req = &ci_req->req;
 	head = ci_get_qh(0, 0);	/* EP0 OUT */
 	ci_invalidate_qh(0);
 	memcpy(&r, head->setup_data, sizeof(struct usb_ctrlrequest));
 #ifdef CONFIG_CI_UDC_HAS_HOSTPC
 	writel(EPT_RX(0), &udc->epsetupstat);
 #else
 	writel(EPT_RX(0), &udc->epstat);
 #endif
 	DBG("handle setup %s, %x, %x index %x value %x length %x\n",
 	    reqname(r.bRequest), r.bRequestType, r.bRequest, r.wIndex,
 	    r.wValue, r.wLength);
 	/* Set EP0 dir for Data Stage based on Setup Stage data */
 	if (r.bRequestType & USB_DIR_IN) {
 		DBG("%s: Set ep0 to IN for Data Stage\n", __func__);
 		ep0_desc.bEndpointAddress = USB_DIR_IN;
 	} else {
 		DBG("%s: Set ep0 to OUT for Data Stage\n", __func__);
 		ep0_desc.bEndpointAddress = 0;
 	}
 	if (r.wLength) {
 		controller.ep0_data_phase = true;
 	} else {
 		/* 0 length -> no Data Stage. Flip dir for Status Stage */
 		DBG("%s: 0 length: flip ep0 dir for Status Stage\n", __func__);
 		flip_ep0_direction();
 		controller.ep0_data_phase = false;
 	}
 	list_del_init(&ci_req->queue);
 	ci_ep->req_primed = false;
 	switch (SETUP(r.bRequestType, r.bRequest)) {
 	case SETUP(USB_RECIP_ENDPOINT, USB_REQ_CLEAR_FEATURE):
 		_num = r.wIndex & 15;
 		_in = !!(r.wIndex & 0x80);
 		if ((r.wValue == 0) && (r.wLength == 0)) {
 			req->length = 0;
 			for (i = 0; i < NUM_ENDPOINTS; i++) {
 				struct ci_ep *ep = &controller.ep[i];
 				if (!ep->desc)
 					continue;
 				num = ep->desc->bEndpointAddress
 						& USB_ENDPOINT_NUMBER_MASK;
 				in = (ep->desc->bEndpointAddress
 						& USB_DIR_IN) != 0;
 				if ((num == _num) && (in == _in)) {
 					ep_enable(num, in, ep->ep.maxpacket);
 					usb_ep_queue(controller.gadget.ep0,
 							req, 0);
 					break;
 				}
 			}
 		}
 		return;
 	case SETUP(USB_RECIP_DEVICE, USB_REQ_SET_ADDRESS):
 		/*
 		 * write address delayed (will take effect
 		 * after the next IN txn)
 		 */
 		writel((r.wValue << 25) | (1 << 24), &udc->devaddr);
 		req->length = 0;
 		usb_ep_queue(controller.gadget.ep0, req, 0);
 		return;
 	case SETUP(USB_DIR_IN | USB_RECIP_DEVICE, USB_REQ_GET_STATUS):
 		req->length = 2;
 		buf = (char *)req->buf;
 		buf[0] = 1 << USB_DEVICE_SELF_POWERED;
 		buf[1] = 0;
 		usb_ep_queue(controller.gadget.ep0, req, 0);
 		return;
 	}
 	/* pass request up to the gadget driver */
 	if (controller.driver)
 		status = controller.driver->setup(&controller.gadget, &r);
 	else
 		status = -ENODEV;
 	if (!status)
 		return;
 	DBG("STALL reqname %s type %x value %x, index %x\n",
 	    reqname(r.bRequest), r.bRequestType, r.wValue, r.wIndex);
 	writel((1<<16) | (1 << 0), &udc->epctrl[0]);
 }
 static void stop_activity(void)
 {
 	int i, num, in;
 	struct ept_queue_head *head;
 	struct ci_udc *udc = (struct ci_udc *)controller.ctrl->hcor;
 	writel(readl(&udc->epcomp), &udc->epcomp);
 #ifdef CONFIG_CI_UDC_HAS_HOSTPC
 	writel(readl(&udc->epsetupstat), &udc->epsetupstat);
 #endif
 	writel(readl(&udc->epstat), &udc->epstat);
 	writel(0xffffffff, &udc->epflush);
 	/* error out any pending reqs */
 	for (i = 0; i < NUM_ENDPOINTS; i++) {
 		if (i != 0)
 			writel(0, &udc->epctrl[i]);
 		if (controller.ep[i].desc) {
 			num = controller.ep[i].desc->bEndpointAddress
 				& USB_ENDPOINT_NUMBER_MASK;
 			in = (controller.ep[i].desc->bEndpointAddress
 				& USB_DIR_IN) != 0;
 			head = ci_get_qh(num, in);
 			head->info = INFO_ACTIVE;
 			ci_flush_qh(num);
 		}
 	}
 }
 void udc_irq(void)
 {
 	struct ci_udc *udc = (struct ci_udc *)controller.ctrl->hcor;
 	unsigned n = readl(&udc->usbsts);
 	writel(n, &udc->usbsts);
 	int bit, i, num, in;
 	n &= (STS_SLI | STS_URI | STS_PCI | STS_UI | STS_UEI);
 	if (n == 0)
 		return;
 	if (n & STS_URI) {
 		DBG("-- reset --\n");
 		stop_activity();
 	}
 	if (n & STS_SLI)
 		DBG("-- suspend --\n");
 	if (n & STS_PCI) {
 		int max = 64;
 		int speed = USB_SPEED_FULL;
 #ifdef CONFIG_CI_UDC_HAS_HOSTPC
 		bit = (readl(&udc->hostpc1_devlc) >> 25) & 3;
 #else
 		bit = (readl(&udc->portsc) >> 26) & 3;
 #endif
 		DBG("-- portchange %x %s\n", bit, (bit == 2) ? "High" : "Full");
 		if (bit == 2) {
 			speed = USB_SPEED_HIGH;
 			max = 512;
 		}
 		controller.gadget.speed = speed;
 		for (i = 1; i < NUM_ENDPOINTS; i++) {
 			if (controller.ep[i].ep.maxpacket > max)
 				controller.ep[i].ep.maxpacket = max;
 		}
 	}
 	if (n & STS_UEI)
 		printf("<UEI %x>\n", readl(&udc->epcomp));
 	if ((n & STS_UI) || (n & STS_UEI)) {
 #ifdef CONFIG_CI_UDC_HAS_HOSTPC
 		n = readl(&udc->epsetupstat);
 #else
 		n = readl(&udc->epstat);
 #endif
 		if (n & EPT_RX(0))
 			handle_setup();
 		n = readl(&udc->epcomp);
 		if (n != 0)
 			writel(n, &udc->epcomp);
 		for (i = 0; i < NUM_ENDPOINTS && n; i++) {
 			if (controller.ep[i].desc) {
 				num = controller.ep[i].desc->bEndpointAddress
 					& USB_ENDPOINT_NUMBER_MASK;
 				in = (controller.ep[i].desc->bEndpointAddress
 						& USB_DIR_IN) != 0;
 				bit = (in) ? EPT_TX(num) : EPT_RX(num);
 				if (n & bit)
 					handle_ep_complete(&controller.ep[i]);
 			}
 		}
 	}
 }
 int usb_gadget_handle_interrupts(void)
 {
 	u32 value;
 	struct ci_udc *udc = (struct ci_udc *)controller.ctrl->hcor;
 	value = readl(&udc->usbsts);
 	if (value)
 		udc_irq();
 	return value;
 }
 void udc_disconnect(void)
 {
 	struct ci_udc *udc = (struct ci_udc *)controller.ctrl->hcor;
 	/* disable pullup */
 	stop_activity();
 	writel(USBCMD_FS2, &udc->usbcmd);
 	udelay(800);
 	if (controller.driver)
 		controller.driver->disconnect(&controller.gadget);
 }
 static int ci_pullup(struct usb_gadget *gadget, int is_on)
 {
 	struct ci_udc *udc = (struct ci_udc *)controller.ctrl->hcor;
 	if (is_on) {
 		/* RESET */
 		writel(USBCMD_ITC(MICRO_8FRAME) | USBCMD_RST, &udc->usbcmd);
 		udelay(200);
 		writel((unsigned)controller.epts, &udc->epinitaddr);
 		/* select DEVICE mode */
 		writel(USBMODE_DEVICE, &udc->usbmode);
+#if !defined(CONFIG_USB_GADGET_DUALSPEED)
+		/* Port force Full-Speed Connect */
+		setbits_le32(&udc->portsc, PFSC);
+#endif
 		writel(0xffffffff, &udc->epflush);
 		/* Turn on the USB connection by enabling the pullup resistor */
 		writel(USBCMD_ITC(MICRO_8FRAME) | USBCMD_RUN, &udc->usbcmd);
 	} else {
 		udc_disconnect();
 	}
 	return 0;
 }
 static int ci_udc_probe(void)
 {
 	struct ept_queue_head *head;
 	int i;
 	const int num = 2 * NUM_ENDPOINTS;
 	const int eplist_min_align = 4096;
 	const int eplist_align = roundup(eplist_min_align, ARCH_DMA_MINALIGN);
 	const int eplist_raw_sz = num * sizeof(struct ept_queue_head);
 	const int eplist_sz = roundup(eplist_raw_sz, ARCH_DMA_MINALIGN);
 	/* The QH list must be aligned to 4096 bytes. */
 	controller.epts = memalign(eplist_align, eplist_sz);
 	if (!controller.epts)
 		return -ENOMEM;
 	memset(controller.epts, 0, eplist_sz);
 	controller.items_mem = memalign(ILIST_ALIGN, ILIST_SZ);
 	if (!controller.items_mem) {
 		free(controller.epts);
 		return -ENOMEM;
 	}
 	memset(controller.items_mem, 0, ILIST_SZ);
 	for (i = 0; i < 2 * NUM_ENDPOINTS; i++) {
 		/*
 		 * Configure QH for each endpoint. The structure of the QH list
 		 * is such that each two subsequent fields, N and N+1 where N is
 		 * even, in the QH list represent QH for one endpoint. The Nth
 		 * entry represents OUT configuration and the N+1th entry does
 		 * represent IN configuration of the endpoint.
 		 */
 		head = controller.epts + i;
 		if (i < 2)
 			head->config = CONFIG_MAX_PKT(EP0_MAX_PACKET_SIZE)
 				| CONFIG_ZLT | CONFIG_IOS;
 		else
 			head->config = CONFIG_MAX_PKT(EP_MAX_PACKET_SIZE)
 				| CONFIG_ZLT;
 		head->next = TERMINATE;
 		head->info = 0;
 		if (i & 1) {
 			ci_flush_qh(i / 2);
 			ci_flush_qtd(i / 2);
 		}
 	}
 	INIT_LIST_HEAD(&controller.gadget.ep_list);
 	/* Init EP 0 */
 	memcpy(&controller.ep[0].ep, &ci_ep_init[0], sizeof(*ci_ep_init));
 	controller.ep[0].desc = &ep0_desc;
 	INIT_LIST_HEAD(&controller.ep[0].queue);
 	controller.ep[0].req_primed = false;
 	controller.gadget.ep0 = &controller.ep[0].ep;
 	INIT_LIST_HEAD(&controller.gadget.ep0->ep_list);
 	/* Init EP 1..n */
 	for (i = 1; i < NUM_ENDPOINTS; i++) {
 		memcpy(&controller.ep[i].ep, &ci_ep_init[1],
 		       sizeof(*ci_ep_init));
 		INIT_LIST_HEAD(&controller.ep[i].queue);
 		controller.ep[i].req_primed = false;
 		list_add_tail(&controller.ep[i].ep.ep_list,
 			      &controller.gadget.ep_list);
 	}
 	ci_ep_alloc_request(&controller.ep[0].ep, 0);
 	if (!controller.ep0_req) {
 		free(controller.items_mem);
 		free(controller.epts);
 		return -ENOMEM;
 	}
 	return 0;
 }
 int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 {
 	int ret;
 	if (!driver)
 		return -EINVAL;
 	if (!driver->bind || !driver->setup || !driver->disconnect)
 		return -EINVAL;
 	if (driver->speed != USB_SPEED_FULL && driver->speed != USB_SPEED_HIGH)
 		return -EINVAL;
 	ret = usb_lowlevel_init(0, USB_INIT_DEVICE, (void **)&controller.ctrl);
 	if (ret)
 		return ret;
 	ret = ci_udc_probe();
 #if defined(CONFIG_USB_EHCI_MX6) || defined(CONFIG_USB_EHCI_MXS)
 	/*
 	 * FIXME: usb_lowlevel_init()->ehci_hcd_init() should be doing all
 	 * HW-specific initialization, e.g. ULPI-vs-UTMI PHY selection
 	 */
 	if (!ret) {
 		struct ci_udc *udc = (struct ci_udc *)controller.ctrl->hcor;
 		/* select ULPI phy */
 		writel(PTS(PTS_ENABLE) | PFSC, &udc->portsc);
 	}
 #endif
 	ret = driver->bind(&controller.gadget);
 	if (ret) {
 		DBG("driver->bind() returned %d\n", ret);
 		return ret;
 	}
 	controller.driver = driver;
 	return 0;
 }
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
 	udc_disconnect();
 	driver->unbind(&controller.gadget);
 	controller.driver = NULL;
 	ci_ep_free_request(&controller.ep[0].ep, &controller.ep0_req->req);
 	free(controller.items_mem);
 	free(controller.epts);
 	return 0;
 }
 bool dfu_usb_get_reset(void)
 {
 	struct ci_udc *udc = (struct ci_udc *)controller.ctrl->hcor;
 	return !!(readl(&udc->usbsts) & STS_URI);
 }

drivers/usb/gadget/f_dfu.c

Diff comments View file @ 8a6b088

 /*
  * f_dfu.c -- Device Firmware Update USB function
  *
  * Copyright (C) 2012 Samsung Electronics
  * authors: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
  *          Lukasz Majewski <l.majewski@samsung.com>
  *
  * Based on OpenMoko u-boot: drivers/usb/usbdfu.c
  * (C) 2007 by OpenMoko, Inc.
  * Author: Harald Welte <laforge@openmoko.org>
  *
  * based on existing SAM7DFU code from OpenPCD:
  * (C) Copyright 2006 by Harald Welte <hwelte at hmw-consulting.de>
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <errno.h>
 #include <common.h>
 #include <malloc.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/composite.h>
 #include <dfu.h>
 #include <g_dnl.h>
 #include "f_dfu.h"
 struct f_dfu {
 	struct usb_function		usb_function;
 	struct usb_descriptor_header	**function;
 	struct usb_string		*strings;
 	/* when configured, we have one config */
 	u8				config;
 	u8				altsetting;
 	enum dfu_state			dfu_state;
 	unsigned int			dfu_status;
 	/* Send/received block number is handy for data integrity check */
 	int                             blk_seq_num;
 	unsigned int                    poll_timeout;
 };
 typedef int (*dfu_state_fn) (struct f_dfu *,
 			     const struct usb_ctrlrequest *,
 			     struct usb_gadget *,
 			     struct usb_request *);
 static inline struct f_dfu *func_to_dfu(struct usb_function *f)
 {
 	return container_of(f, struct f_dfu, usb_function);
 }
 static const struct dfu_function_descriptor dfu_func = {
 	.bLength =		sizeof dfu_func,
 	.bDescriptorType =	DFU_DT_FUNC,
 	.bmAttributes =		DFU_BIT_WILL_DETACH |
 				DFU_BIT_MANIFESTATION_TOLERANT |
 				DFU_BIT_CAN_UPLOAD |
 				DFU_BIT_CAN_DNLOAD,
 	.wDetachTimeOut =	0,
 	.wTransferSize =	DFU_USB_BUFSIZ,
 	.bcdDFUVersion =	__constant_cpu_to_le16(0x0110),
 };
 static struct usb_interface_descriptor dfu_intf_runtime = {
 	.bLength =		sizeof dfu_intf_runtime,
 	.bDescriptorType =	USB_DT_INTERFACE,
 	.bNumEndpoints =	0,
 	.bInterfaceClass =	USB_CLASS_APP_SPEC,
 	.bInterfaceSubClass =	1,
 	.bInterfaceProtocol =	1,
 	/* .iInterface = DYNAMIC */
 };
 static struct usb_descriptor_header *dfu_runtime_descs[] = {
 	(struct usb_descriptor_header *) &dfu_intf_runtime,
 	NULL,
 };
-static const struct usb_qualifier_descriptor dev_qualifier = {
-	.bLength =		sizeof dev_qualifier,
-	.bDescriptorType =	USB_DT_DEVICE_QUALIFIER,
-	.bcdUSB =		__constant_cpu_to_le16(0x0200),
-	.bDeviceClass =		USB_CLASS_VENDOR_SPEC,
-	.bNumConfigurations =	1,
-};
 static const char dfu_name[] = "Device Firmware Upgrade";
 /*
  * static strings, in UTF-8
  *
  * dfu_generic configuration
  */
 static struct usb_string strings_dfu_generic[] = {
 	[0].s = dfu_name,
 	{  }			/* end of list */
 };
 static struct usb_gadget_strings stringtab_dfu_generic = {
 	.language	= 0x0409,	/* en-us */
 	.strings	= strings_dfu_generic,
 };
 static struct usb_gadget_strings *dfu_generic_strings[] = {
 	&stringtab_dfu_generic,
 	NULL,
 };
 /*
  * usb_function specific
  */
 static struct usb_gadget_strings stringtab_dfu = {
 	.language	= 0x0409,	/* en-us */
 	/*
 	 * .strings
 	 *
 	 * assigned during initialization,
 	 * depends on number of flash entities
 	 *
 	 */
 };
 static struct usb_gadget_strings *dfu_strings[] = {
 	&stringtab_dfu,
 	NULL,
 };
 static void dfu_set_poll_timeout(struct dfu_status *dstat, unsigned int ms)
 {
 	/*
 	 * The bwPollTimeout DFU_GETSTATUS request payload provides information
 	 * about minimum time, in milliseconds, that the host should wait before
 	 * sending a subsequent DFU_GETSTATUS request
 	 *
 	 * This permits the device to vary the delay depending on its need to
 	 * erase or program the memory
 	 *
 	 */
 	unsigned char *p = (unsigned char *)&ms;
 	if (!ms || (ms & ~DFU_POLL_TIMEOUT_MASK)) {
 		dstat->bwPollTimeout[0] = 0;
 		dstat->bwPollTimeout[1] = 0;
 		dstat->bwPollTimeout[2] = 0;
 		return;
 	}
 	dstat->bwPollTimeout[0] = *p++;
 	dstat->bwPollTimeout[1] = *p++;
 	dstat->bwPollTimeout[2] = *p;
 }
 /*-------------------------------------------------------------------------*/
 static void dnload_request_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	struct f_dfu *f_dfu = req->context;
 	int ret;
 	ret = dfu_write(dfu_get_entity(f_dfu->altsetting), req->buf,
 			req->length, f_dfu->blk_seq_num);
 	if (ret) {
 		f_dfu->dfu_status = DFU_STATUS_errUNKNOWN;
 		f_dfu->dfu_state = DFU_STATE_dfuERROR;
 	}
 }
 static void dnload_request_flush(struct usb_ep *ep, struct usb_request *req)
 {
 	struct f_dfu *f_dfu = req->context;
 	int ret;
 	ret = dfu_flush(dfu_get_entity(f_dfu->altsetting), req->buf,
 			req->length, f_dfu->blk_seq_num);
 	if (ret) {
 		f_dfu->dfu_status = DFU_STATUS_errUNKNOWN;
 		f_dfu->dfu_state = DFU_STATE_dfuERROR;
 	}
 }
 static inline int dfu_get_manifest_timeout(struct dfu_entity *dfu)
 {
 	return dfu->poll_timeout ? dfu->poll_timeout(dfu) :
 		DFU_MANIFEST_POLL_TIMEOUT;
 }
 static void handle_getstatus(struct usb_request *req)
 {
 	struct dfu_status *dstat = (struct dfu_status *)req->buf;
 	struct f_dfu *f_dfu = req->context;
 	struct dfu_entity *dfu = dfu_get_entity(f_dfu->altsetting);
 	dfu_set_poll_timeout(dstat, 0);
 	switch (f_dfu->dfu_state) {
 	case DFU_STATE_dfuDNLOAD_SYNC:
 	case DFU_STATE_dfuDNBUSY:
 		f_dfu->dfu_state = DFU_STATE_dfuDNLOAD_IDLE;
 		break;
 	case DFU_STATE_dfuMANIFEST_SYNC:
 		f_dfu->dfu_state = DFU_STATE_dfuMANIFEST;
 		break;
 	case DFU_STATE_dfuMANIFEST:
 		dfu_set_poll_timeout(dstat, dfu_get_manifest_timeout(dfu));
 		break;
 	default:
 		break;
 	}
 	if (f_dfu->poll_timeout)
 		if (!(f_dfu->blk_seq_num %
 		      (dfu_get_buf_size() / DFU_USB_BUFSIZ)))
 			dfu_set_poll_timeout(dstat, f_dfu->poll_timeout);
 	/* send status response */
 	dstat->bStatus = f_dfu->dfu_status;
 	dstat->bState = f_dfu->dfu_state;
 	dstat->iString = 0;
 }
 static void handle_getstate(struct usb_request *req)
 {
 	struct f_dfu *f_dfu = req->context;
 	((u8 *)req->buf)[0] = f_dfu->dfu_state;
 	req->actual = sizeof(u8);
 }
 static inline void to_dfu_mode(struct f_dfu *f_dfu)
 {
 	f_dfu->usb_function.strings = dfu_strings;
 	f_dfu->usb_function.hs_descriptors = f_dfu->function;
+	f_dfu->usb_function.descriptors = f_dfu->function;
 	f_dfu->dfu_state = DFU_STATE_dfuIDLE;
 }
 static inline void to_runtime_mode(struct f_dfu *f_dfu)
 {
 	f_dfu->usb_function.strings = NULL;
 	f_dfu->usb_function.hs_descriptors = dfu_runtime_descs;
+	f_dfu->usb_function.descriptors = dfu_runtime_descs;
 }
 static int handle_upload(struct usb_request *req, u16 len)
 {
 	struct f_dfu *f_dfu = req->context;
 	return dfu_read(dfu_get_entity(f_dfu->altsetting), req->buf,
 			req->length, f_dfu->blk_seq_num);
 }
 static int handle_dnload(struct usb_gadget *gadget, u16 len)
 {
 	struct usb_composite_dev *cdev = get_gadget_data(gadget);
 	struct usb_request *req = cdev->req;
 	struct f_dfu *f_dfu = req->context;
 	if (len == 0)
 		f_dfu->dfu_state = DFU_STATE_dfuMANIFEST_SYNC;
 	req->complete = dnload_request_complete;
 	return len;
 }
 /*-------------------------------------------------------------------------*/
 /* DFU state machine  */
 static int state_app_idle(struct f_dfu *f_dfu,
 			  const struct usb_ctrlrequest *ctrl,
 			  struct usb_gadget *gadget,
 			  struct usb_request *req)
 {
 	int value = 0;
 	switch (ctrl->bRequest) {
 	case USB_REQ_DFU_GETSTATUS:
 		handle_getstatus(req);
 		value = RET_STAT_LEN;
 		break;
 	case USB_REQ_DFU_GETSTATE:
 		handle_getstate(req);
 		break;
 	case USB_REQ_DFU_DETACH:
 		f_dfu->dfu_state = DFU_STATE_appDETACH;
 		to_dfu_mode(f_dfu);
 		value = RET_ZLP;
 		break;
 	default:
 		value = RET_STALL;
 		break;
 	}
 	return value;
 }
 static int state_app_detach(struct f_dfu *f_dfu,
 			    const struct usb_ctrlrequest *ctrl,
 			    struct usb_gadget *gadget,
 			    struct usb_request *req)
 {
 	int value = 0;
 	switch (ctrl->bRequest) {
 	case USB_REQ_DFU_GETSTATUS:
 		handle_getstatus(req);
 		value = RET_STAT_LEN;
 		break;
 	case USB_REQ_DFU_GETSTATE:
 		handle_getstate(req);
 		break;
 	default:
 		f_dfu->dfu_state = DFU_STATE_appIDLE;
 		value = RET_STALL;
 		break;
 	}
 	return value;
 }
 static int state_dfu_idle(struct f_dfu *f_dfu,
 			  const struct usb_ctrlrequest *ctrl,
 			  struct usb_gadget *gadget,
 			  struct usb_request *req)
 {
 	u16 w_value = le16_to_cpu(ctrl->wValue);
 	u16 len = le16_to_cpu(ctrl->wLength);
 	int value = 0;
 	switch (ctrl->bRequest) {
 	case USB_REQ_DFU_DNLOAD:
 		if (len == 0) {
 			f_dfu->dfu_state = DFU_STATE_dfuERROR;
 			value = RET_STALL;
 			break;
 		}
 		f_dfu->dfu_state = DFU_STATE_dfuDNLOAD_SYNC;
 		f_dfu->blk_seq_num = w_value;
 		value = handle_dnload(gadget, len);
 		break;
 	case USB_REQ_DFU_UPLOAD:
 		f_dfu->dfu_state = DFU_STATE_dfuUPLOAD_IDLE;
 		f_dfu->blk_seq_num = 0;
 		value = handle_upload(req, len);
 		break;
 	case USB_REQ_DFU_ABORT:
 		/* no zlp? */
 		value = RET_ZLP;
 		break;
 	case USB_REQ_DFU_GETSTATUS:
 		handle_getstatus(req);
 		value = RET_STAT_LEN;
 		break;
 	case USB_REQ_DFU_GETSTATE:
 		handle_getstate(req);
 		break;
 	case USB_REQ_DFU_DETACH:
 		/*
 		 * Proprietary extension: 'detach' from idle mode and
 		 * get back to runtime mode in case of USB Reset.  As
 		 * much as I dislike this, we just can't use every USB
 		 * bus reset to switch back to runtime mode, since at
 		 * least the Linux USB stack likes to send a number of
 		 * resets in a row :(
 		 */
 		f_dfu->dfu_state =
 			DFU_STATE_dfuMANIFEST_WAIT_RST;
 		to_runtime_mode(f_dfu);
 		f_dfu->dfu_state = DFU_STATE_appIDLE;
 		dfu_trigger_detach();
 		break;
 	default:
 		f_dfu->dfu_state = DFU_STATE_dfuERROR;
 		value = RET_STALL;
 		break;
 	}
 	return value;
 }
 static int state_dfu_dnload_sync(struct f_dfu *f_dfu,
 				 const struct usb_ctrlrequest *ctrl,
 				 struct usb_gadget *gadget,
 				 struct usb_request *req)
 {
 	int value = 0;
 	switch (ctrl->bRequest) {
 	case USB_REQ_DFU_GETSTATUS:
 		handle_getstatus(req);
 		value = RET_STAT_LEN;
 		break;
 	case USB_REQ_DFU_GETSTATE:
 		handle_getstate(req);
 		break;
 	default:
 		f_dfu->dfu_state = DFU_STATE_dfuERROR;
 		value = RET_STALL;
 		break;
 	}
 	return value;
 }
 static int state_dfu_dnbusy(struct f_dfu *f_dfu,
 			    const struct usb_ctrlrequest *ctrl,
 			    struct usb_gadget *gadget,
 			    struct usb_request *req)
 {
 	int value = 0;
 	switch (ctrl->bRequest) {
 	case USB_REQ_DFU_GETSTATUS:
 		handle_getstatus(req);
 		value = RET_STAT_LEN;
 		break;
 	default:
 		f_dfu->dfu_state = DFU_STATE_dfuERROR;
 		value = RET_STALL;
 		break;
 	}
 	return value;
 }
 static int state_dfu_dnload_idle(struct f_dfu *f_dfu,
 				 const struct usb_ctrlrequest *ctrl,
 				 struct usb_gadget *gadget,
 				 struct usb_request *req)
 {
 	u16 w_value = le16_to_cpu(ctrl->wValue);
 	u16 len = le16_to_cpu(ctrl->wLength);
 	int value = 0;
 	switch (ctrl->bRequest) {
 	case USB_REQ_DFU_DNLOAD:
 		f_dfu->dfu_state = DFU_STATE_dfuDNLOAD_SYNC;
 		f_dfu->blk_seq_num = w_value;
 		value = handle_dnload(gadget, len);
 		break;
 	case USB_REQ_DFU_ABORT:
 		f_dfu->dfu_state = DFU_STATE_dfuIDLE;
 		value = RET_ZLP;
 		break;
 	case USB_REQ_DFU_GETSTATUS:
 		handle_getstatus(req);
 		value = RET_STAT_LEN;
 		break;
 	case USB_REQ_DFU_GETSTATE:
 		handle_getstate(req);
 		break;
 	default:
 		f_dfu->dfu_state = DFU_STATE_dfuERROR;
 		value = RET_STALL;
 		break;
 	}
 	return value;
 }
 static int state_dfu_manifest_sync(struct f_dfu *f_dfu,
 				   const struct usb_ctrlrequest *ctrl,
 				   struct usb_gadget *gadget,
 				   struct usb_request *req)
 {
 	int value = 0;
 	switch (ctrl->bRequest) {
 	case USB_REQ_DFU_GETSTATUS:
 		/* We're MainfestationTolerant */
 		f_dfu->dfu_state = DFU_STATE_dfuMANIFEST;
 		handle_getstatus(req);
 		f_dfu->blk_seq_num = 0;
 		value = RET_STAT_LEN;
 		req->complete = dnload_request_flush;
 		break;
 	case USB_REQ_DFU_GETSTATE:
 		handle_getstate(req);
 		break;
 	default:
 		f_dfu->dfu_state = DFU_STATE_dfuERROR;
 		value = RET_STALL;
 		break;
 	}
 	return value;
 }
 static int state_dfu_manifest(struct f_dfu *f_dfu,
 			      const struct usb_ctrlrequest *ctrl,
 			      struct usb_gadget *gadget,
 			      struct usb_request *req)
 {
 	int value = 0;
 	switch (ctrl->bRequest) {
 	case USB_REQ_DFU_GETSTATUS:
 		/* We're MainfestationTolerant */
 		f_dfu->dfu_state = DFU_STATE_dfuIDLE;
 		handle_getstatus(req);
 		f_dfu->blk_seq_num = 0;
 		value = RET_STAT_LEN;
 		puts("DOWNLOAD ... OK\nCtrl+C to exit ...\n");
 		break;
 	case USB_REQ_DFU_GETSTATE:
 		handle_getstate(req);
 		break;
 	default:
 		f_dfu->dfu_state = DFU_STATE_dfuERROR;
 		value = RET_STALL;
 		break;
 	}
 	return value;
 }
 static int state_dfu_upload_idle(struct f_dfu *f_dfu,
 				 const struct usb_ctrlrequest *ctrl,
 				 struct usb_gadget *gadget,
 				 struct usb_request *req)
 {
 	u16 w_value = le16_to_cpu(ctrl->wValue);
 	u16 len = le16_to_cpu(ctrl->wLength);
 	int value = 0;
 	switch (ctrl->bRequest) {
 	case USB_REQ_DFU_UPLOAD:
 		/* state transition if less data then requested */
 		f_dfu->blk_seq_num = w_value;
 		value = handle_upload(req, len);
 		if (value >= 0 && value < len)
 			f_dfu->dfu_state = DFU_STATE_dfuIDLE;
 		break;
 	case USB_REQ_DFU_ABORT:
 		f_dfu->dfu_state = DFU_STATE_dfuIDLE;
 		/* no zlp? */
 		value = RET_ZLP;
 		break;
 	case USB_REQ_DFU_GETSTATUS:
 		handle_getstatus(req);
 		value = RET_STAT_LEN;
 		break;
 	case USB_REQ_DFU_GETSTATE:
 		handle_getstate(req);
 		break;
 	default:
 		f_dfu->dfu_state = DFU_STATE_dfuERROR;
 		value = RET_STALL;
 		break;
 	}
 	return value;
 }
 static int state_dfu_error(struct f_dfu *f_dfu,
 				 const struct usb_ctrlrequest *ctrl,
 				 struct usb_gadget *gadget,
 				 struct usb_request *req)
 {
 	int value = 0;
 	switch (ctrl->bRequest) {
 	case USB_REQ_DFU_GETSTATUS:
 		handle_getstatus(req);
 		value = RET_STAT_LEN;
 		break;
 	case USB_REQ_DFU_GETSTATE:
 		handle_getstate(req);
 		break;
 	case USB_REQ_DFU_CLRSTATUS:
 		f_dfu->dfu_state = DFU_STATE_dfuIDLE;
 		f_dfu->dfu_status = DFU_STATUS_OK;
 		/* no zlp? */
 		value = RET_ZLP;
 		break;
 	default:
 		f_dfu->dfu_state = DFU_STATE_dfuERROR;
 		value = RET_STALL;
 		break;
 	}
 	return value;
 }
 static dfu_state_fn dfu_state[] = {
 	state_app_idle,          /* DFU_STATE_appIDLE */
 	state_app_detach,        /* DFU_STATE_appDETACH */
 	state_dfu_idle,          /* DFU_STATE_dfuIDLE */
 	state_dfu_dnload_sync,   /* DFU_STATE_dfuDNLOAD_SYNC */
 	state_dfu_dnbusy,        /* DFU_STATE_dfuDNBUSY */
 	state_dfu_dnload_idle,   /* DFU_STATE_dfuDNLOAD_IDLE */
 	state_dfu_manifest_sync, /* DFU_STATE_dfuMANIFEST_SYNC */
 	state_dfu_manifest,	 /* DFU_STATE_dfuMANIFEST */
 	NULL,                    /* DFU_STATE_dfuMANIFEST_WAIT_RST */
 	state_dfu_upload_idle,   /* DFU_STATE_dfuUPLOAD_IDLE */
 	state_dfu_error          /* DFU_STATE_dfuERROR */
 };
 static int
 dfu_handle(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 {
 	struct usb_gadget *gadget = f->config->cdev->gadget;
 	struct usb_request *req = f->config->cdev->req;
 	struct f_dfu *f_dfu = f->config->cdev->req->context;
 	u16 len = le16_to_cpu(ctrl->wLength);
 	u16 w_value = le16_to_cpu(ctrl->wValue);
 	int value = 0;
 	u8 req_type = ctrl->bRequestType & USB_TYPE_MASK;
 	debug("w_value: 0x%x len: 0x%x\n", w_value, len);
 	debug("req_type: 0x%x ctrl->bRequest: 0x%x f_dfu->dfu_state: 0x%x\n",
 	       req_type, ctrl->bRequest, f_dfu->dfu_state);
 	if (req_type == USB_TYPE_STANDARD) {
 		if (ctrl->bRequest == USB_REQ_GET_DESCRIPTOR &&
 		    (w_value >> 8) == DFU_DT_FUNC) {
 			value = min(len, (u16) sizeof(dfu_func));
 			memcpy(req->buf, &dfu_func, value);
 		}
 	} else /* DFU specific request */
 		value = dfu_state[f_dfu->dfu_state] (f_dfu, ctrl, gadget, req);
 	if (value >= 0) {
 		req->length = value;
 		req->zero = value < len;
 		value = usb_ep_queue(gadget->ep0, req, 0);
 		if (value < 0) {
 			debug("ep_queue --> %d\n", value);
 			req->status = 0;
 		}
 	}
 	return value;
 }
 /*-------------------------------------------------------------------------*/
 static int
 dfu_prepare_strings(struct f_dfu *f_dfu, int n)
 {
 	struct dfu_entity *de = NULL;
 	int i = 0;
 	f_dfu->strings = calloc(sizeof(struct usb_string), n + 1);
 	if (!f_dfu->strings)
 		goto enomem;
 	for (i = 0; i < n; ++i) {
 		de = dfu_get_entity(i);
 		f_dfu->strings[i].s = de->name;
 	}
 	f_dfu->strings[i].id = 0;
 	f_dfu->strings[i].s = NULL;
 	return 0;
 enomem:
 	while (i)
 		f_dfu->strings[--i].s = NULL;
 	free(f_dfu->strings);
 	return -ENOMEM;
 }
 static int dfu_prepare_function(struct f_dfu *f_dfu, int n)
 {
 	struct usb_interface_descriptor *d;
 	int i = 0;
 	f_dfu->function = calloc(sizeof(struct usb_descriptor_header *), n + 1);
 	if (!f_dfu->function)
 		goto enomem;
 	for (i = 0; i < n; ++i) {
 		d = calloc(sizeof(*d), 1);
 		if (!d)
 			goto enomem;
 		d->bLength =		sizeof(*d);
 		d->bDescriptorType =	USB_DT_INTERFACE;
 		d->bAlternateSetting =	i;
 		d->bNumEndpoints =	0;
 		d->bInterfaceClass =	USB_CLASS_APP_SPEC;
 		d->bInterfaceSubClass =	1;
 		d->bInterfaceProtocol =	2;
 		f_dfu->function[i] = (struct usb_descriptor_header *)d;
 	}
 	f_dfu->function[i] = NULL;
 	return 0;
 enomem:
 	while (i) {
 		free(f_dfu->function[--i]);
 		f_dfu->function[i] = NULL;
 	}
 	free(f_dfu->function);
 	return -ENOMEM;
 }
 static int dfu_bind(struct usb_configuration *c, struct usb_function *f)
 {
 	struct usb_composite_dev *cdev = c->cdev;
 	struct f_dfu *f_dfu = func_to_dfu(f);
 	int alt_num = dfu_get_alt_number();
 	int rv, id, i;
 	id = usb_interface_id(c, f);
 	if (id < 0)
 		return id;
 	dfu_intf_runtime.bInterfaceNumber = id;
 	f_dfu->dfu_state = DFU_STATE_appIDLE;
 	f_dfu->dfu_status = DFU_STATUS_OK;
 	rv = dfu_prepare_function(f_dfu, alt_num);
 	if (rv)
 		goto error;
 	rv = dfu_prepare_strings(f_dfu, alt_num);
 	if (rv)
 		goto error;
 	for (i = 0; i < alt_num; i++) {
 		id = usb_string_id(cdev);
 		if (id < 0)
 			return id;
 		f_dfu->strings[i].id = id;
 		((struct usb_interface_descriptor *)f_dfu->function[i])
 			->iInterface = id;
 	}
 	to_dfu_mode(f_dfu);
 	stringtab_dfu.strings = f_dfu->strings;
 	cdev->req->context = f_dfu;
 error:
 	return rv;
 }
 static void dfu_unbind(struct usb_configuration *c, struct usb_function *f)
 {
 	struct f_dfu *f_dfu = func_to_dfu(f);
 	int alt_num = dfu_get_alt_number();
 	int i;
 	if (f_dfu->strings) {
 		i = alt_num;
 		while (i)
 			f_dfu->strings[--i].s = NULL;
 		free(f_dfu->strings);
 	}
 	if (f_dfu->function) {
 		i = alt_num;
 		while (i) {
 			free(f_dfu->function[--i]);
 			f_dfu->function[i] = NULL;
 		}
 		free(f_dfu->function);
 	}
 	free(f_dfu);
 }
 static int dfu_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 {
 	struct f_dfu *f_dfu = func_to_dfu(f);
 	debug("%s: intf:%d alt:%d\n", __func__, intf, alt);
 	f_dfu->altsetting = alt;
 	f_dfu->dfu_state = DFU_STATE_dfuIDLE;
 	f_dfu->dfu_status = DFU_STATUS_OK;
 	return 0;
 }
 /* TODO: is this really what we need here? */
 static void dfu_disable(struct usb_function *f)
 {
 	struct f_dfu *f_dfu = func_to_dfu(f);
 	if (f_dfu->config == 0)
 		return;
 	debug("%s: reset config\n", __func__);
 	f_dfu->config = 0;
 }
 static int dfu_bind_config(struct usb_configuration *c)
 {
 	struct f_dfu *f_dfu;
 	int status;
 	f_dfu = calloc(sizeof(*f_dfu), 1);
 	if (!f_dfu)
 		return -ENOMEM;
 	f_dfu->usb_function.name = "dfu";
 	f_dfu->usb_function.hs_descriptors = dfu_runtime_descs;
+	f_dfu->usb_function.descriptors = dfu_runtime_descs;
 	f_dfu->usb_function.bind = dfu_bind;
 	f_dfu->usb_function.unbind = dfu_unbind;
 	f_dfu->usb_function.set_alt = dfu_set_alt;
 	f_dfu->usb_function.disable = dfu_disable;
 	f_dfu->usb_function.strings = dfu_generic_strings;
 	f_dfu->usb_function.setup = dfu_handle;
 	f_dfu->poll_timeout = DFU_DEFAULT_POLL_TIMEOUT;
 	status = usb_add_function(c, &f_dfu->usb_function);
 	if (status)
 		free(f_dfu);
 	return status;
 }
 int dfu_add(struct usb_configuration *c)
 {
 	int id;
 	id = usb_string_id(c->cdev);
 	if (id < 0)
 		return id;
 	strings_dfu_generic[0].id = id;
 	dfu_intf_runtime.iInterface = id;
 	debug("%s: cdev: 0x%p gadget:0x%p gadget->ep0: 0x%p\n", __func__,
 	       c->cdev, c->cdev->gadget, c->cdev->gadget->ep0);
 	return dfu_bind_config(c);
 }

drivers/usb/gadget/f_fastboot.c

Diff comments View file @ 8a6b088

 /*
  * (C) Copyright 2008 - 2009
  * Windriver, <www.windriver.com>
  * Tom Rix <Tom.Rix@windriver.com>
  *
  * Copyright 2011 Sebastian Andrzej Siewior <bigeasy@linutronix.de>
  *
  * Copyright 2014 Linaro, Ltd.
  * Rob Herring <robh@kernel.org>
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <config.h>
 #include <common.h>
 #include <errno.h>
 #include <malloc.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/composite.h>
 #include <linux/compiler.h>
 #include <version.h>
 #include <g_dnl.h>
 #ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
 #include <fb_mmc.h>
 #endif
 #define FASTBOOT_VERSION		"0.4"
 #define FASTBOOT_INTERFACE_CLASS	0xff
 #define FASTBOOT_INTERFACE_SUB_CLASS	0x42
 #define FASTBOOT_INTERFACE_PROTOCOL	0x03
 #define RX_ENDPOINT_MAXIMUM_PACKET_SIZE_2_0  (0x0200)
 #define RX_ENDPOINT_MAXIMUM_PACKET_SIZE_1_1  (0x0040)
 #define TX_ENDPOINT_MAXIMUM_PACKET_SIZE      (0x0040)
 /* The 64 defined bytes plus \0 */
 #define RESPONSE_LEN	(64 + 1)
 #define EP_BUFFER_SIZE			4096
 struct f_fastboot {
 	struct usb_function usb_function;
 	/* IN/OUT EP's and corresponding requests */
 	struct usb_ep *in_ep, *out_ep;
 	struct usb_request *in_req, *out_req;
 };
 static inline struct f_fastboot *func_to_fastboot(struct usb_function *f)
 {
 	return container_of(f, struct f_fastboot, usb_function);
 }
 static struct f_fastboot *fastboot_func;
 static unsigned int download_size;
 static unsigned int download_bytes;
 static struct usb_endpoint_descriptor fs_ep_in = {
 	.bLength            = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType    = USB_DT_ENDPOINT,
 	.bEndpointAddress   = USB_DIR_IN,
 	.bmAttributes       = USB_ENDPOINT_XFER_BULK,
 	.wMaxPacketSize     = TX_ENDPOINT_MAXIMUM_PACKET_SIZE,
 	.bInterval          = 0x00,
 };
 static struct usb_endpoint_descriptor fs_ep_out = {
 	.bLength		= USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType	= USB_DT_ENDPOINT,
 	.bEndpointAddress	= USB_DIR_OUT,
 	.bmAttributes		= USB_ENDPOINT_XFER_BULK,
 	.wMaxPacketSize		= RX_ENDPOINT_MAXIMUM_PACKET_SIZE_1_1,
 	.bInterval		= 0x00,
 };
 static struct usb_endpoint_descriptor hs_ep_out = {
 	.bLength		= USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType	= USB_DT_ENDPOINT,
 	.bEndpointAddress	= USB_DIR_OUT,
 	.bmAttributes		= USB_ENDPOINT_XFER_BULK,
 	.wMaxPacketSize		= RX_ENDPOINT_MAXIMUM_PACKET_SIZE_2_0,
 	.bInterval		= 0x00,
 };
 static struct usb_interface_descriptor interface_desc = {
 	.bLength		= USB_DT_INTERFACE_SIZE,
 	.bDescriptorType	= USB_DT_INTERFACE,
 	.bInterfaceNumber	= 0x00,
 	.bAlternateSetting	= 0x00,
 	.bNumEndpoints		= 0x02,
 	.bInterfaceClass	= FASTBOOT_INTERFACE_CLASS,
 	.bInterfaceSubClass	= FASTBOOT_INTERFACE_SUB_CLASS,
 	.bInterfaceProtocol	= FASTBOOT_INTERFACE_PROTOCOL,
 };
 static struct usb_descriptor_header *fb_runtime_descs[] = {
 	(struct usb_descriptor_header *)&interface_desc,
 	(struct usb_descriptor_header *)&fs_ep_in,
 	(struct usb_descriptor_header *)&hs_ep_out,
 	NULL,
 };
 /*
  * static strings, in UTF-8
  */
 static const char fastboot_name[] = "Android Fastboot";
 static struct usb_string fastboot_string_defs[] = {
 	[0].s = fastboot_name,
 	{  }			/* end of list */
 };
 static struct usb_gadget_strings stringtab_fastboot = {
 	.language	= 0x0409,	/* en-us */
 	.strings	= fastboot_string_defs,
 };
 static struct usb_gadget_strings *fastboot_strings[] = {
 	&stringtab_fastboot,
 	NULL,
 };
 static void rx_handler_command(struct usb_ep *ep, struct usb_request *req);
 static void fastboot_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	int status = req->status;
 	if (!status)
 		return;
 	printf("status: %d ep '%s' trans: %d\n", status, ep->name, req->actual);
 }
 static int fastboot_bind(struct usb_configuration *c, struct usb_function *f)
 {
 	int id;
 	struct usb_gadget *gadget = c->cdev->gadget;
 	struct f_fastboot *f_fb = func_to_fastboot(f);
 	/* DYNAMIC interface numbers assignments */
 	id = usb_interface_id(c, f);
 	if (id < 0)
 		return id;
 	interface_desc.bInterfaceNumber = id;
 	id = usb_string_id(c->cdev);
 	if (id < 0)
 		return id;
 	fastboot_string_defs[0].id = id;
 	interface_desc.iInterface = id;
 	f_fb->in_ep = usb_ep_autoconfig(gadget, &fs_ep_in);
 	if (!f_fb->in_ep)
 		return -ENODEV;
 	f_fb->in_ep->driver_data = c->cdev;
 	f_fb->out_ep = usb_ep_autoconfig(gadget, &fs_ep_out);
 	if (!f_fb->out_ep)
 		return -ENODEV;
 	f_fb->out_ep->driver_data = c->cdev;
 	hs_ep_out.bEndpointAddress = fs_ep_out.bEndpointAddress;
 	return 0;
 }
 static void fastboot_unbind(struct usb_configuration *c, struct usb_function *f)
 {
 	memset(fastboot_func, 0, sizeof(*fastboot_func));
 }
 static void fastboot_disable(struct usb_function *f)
 {
 	struct f_fastboot *f_fb = func_to_fastboot(f);
 	usb_ep_disable(f_fb->out_ep);
 	usb_ep_disable(f_fb->in_ep);
 	if (f_fb->out_req) {
 		free(f_fb->out_req->buf);
 		usb_ep_free_request(f_fb->out_ep, f_fb->out_req);
 		f_fb->out_req = NULL;
 	}
 	if (f_fb->in_req) {
 		free(f_fb->in_req->buf);
 		usb_ep_free_request(f_fb->in_ep, f_fb->in_req);
 		f_fb->in_req = NULL;
 	}
 }
 static struct usb_request *fastboot_start_ep(struct usb_ep *ep)
 {
 	struct usb_request *req;
 	req = usb_ep_alloc_request(ep, 0);
 	if (!req)
 		return NULL;
 	req->length = EP_BUFFER_SIZE;
 	req->buf = memalign(CONFIG_SYS_CACHELINE_SIZE, EP_BUFFER_SIZE);
 	if (!req->buf) {
 		usb_ep_free_request(ep, req);
 		return NULL;
 	}
 	memset(req->buf, 0, req->length);
 	return req;
 }
 static int fastboot_set_alt(struct usb_function *f,
 			    unsigned interface, unsigned alt)
 {
 	int ret;
 	struct usb_composite_dev *cdev = f->config->cdev;
 	struct usb_gadget *gadget = cdev->gadget;
 	struct f_fastboot *f_fb = func_to_fastboot(f);
 	debug("%s: func: %s intf: %d alt: %d\n",
 	      __func__, f->name, interface, alt);
 	/* make sure we don't enable the ep twice */
 	if (gadget->speed == USB_SPEED_HIGH)
 		ret = usb_ep_enable(f_fb->out_ep, &hs_ep_out);
 	else
 		ret = usb_ep_enable(f_fb->out_ep, &fs_ep_out);
 	if (ret) {
 		puts("failed to enable out ep\n");
 		return ret;
 	}
 	f_fb->out_req = fastboot_start_ep(f_fb->out_ep);
 	if (!f_fb->out_req) {
 		puts("failed to alloc out req\n");
 		ret = -EINVAL;
 		goto err;
 	}
 	f_fb->out_req->complete = rx_handler_command;
 	ret = usb_ep_enable(f_fb->in_ep, &fs_ep_in);
 	if (ret) {
 		puts("failed to enable in ep\n");
 		goto err;
 	}
 	f_fb->in_req = fastboot_start_ep(f_fb->in_ep);
 	if (!f_fb->in_req) {
 		puts("failed alloc req in\n");
 		ret = -EINVAL;
 		goto err;
 	}
 	f_fb->in_req->complete = fastboot_complete;
 	ret = usb_ep_queue(f_fb->out_ep, f_fb->out_req, 0);
 	if (ret)
 		goto err;
 	return 0;
 err:
 	fastboot_disable(f);
 	return ret;
 }
 static int fastboot_add(struct usb_configuration *c)
 {
 	struct f_fastboot *f_fb = fastboot_func;
 	int status;
 	debug("%s: cdev: 0x%p\n", __func__, c->cdev);
 	if (!f_fb) {
 		f_fb = memalign(CONFIG_SYS_CACHELINE_SIZE, sizeof(*f_fb));
 		if (!f_fb)
 			return -ENOMEM;
 		fastboot_func = f_fb;
 		memset(f_fb, 0, sizeof(*f_fb));
 	}
 	f_fb->usb_function.name = "f_fastboot";
 	f_fb->usb_function.hs_descriptors = fb_runtime_descs;
 	f_fb->usb_function.bind = fastboot_bind;
 	f_fb->usb_function.unbind = fastboot_unbind;
 	f_fb->usb_function.set_alt = fastboot_set_alt;
 	f_fb->usb_function.disable = fastboot_disable;
 	f_fb->usb_function.strings = fastboot_strings;
 	status = usb_add_function(c, &f_fb->usb_function);
 	if (status) {
 		free(f_fb);
 		fastboot_func = f_fb;
 	}
 	return status;
 }
 DECLARE_GADGET_BIND_CALLBACK(usb_dnl_fastboot, fastboot_add);
 static int fastboot_tx_write(const char *buffer, unsigned int buffer_size)
 {
 	struct usb_request *in_req = fastboot_func->in_req;
 	int ret;
 	memcpy(in_req->buf, buffer, buffer_size);
 	in_req->length = buffer_size;
 	ret = usb_ep_queue(fastboot_func->in_ep, in_req, 0);
 	if (ret)
 		printf("Error %d on queue\n", ret);
 	return 0;
 }
 static int fastboot_tx_write_str(const char *buffer)
 {
 	return fastboot_tx_write(buffer, strlen(buffer));
 }
 static void compl_do_reset(struct usb_ep *ep, struct usb_request *req)
 {
 	do_reset(NULL, 0, 0, NULL);
 }
 static void cb_reboot(struct usb_ep *ep, struct usb_request *req)
 {
 	fastboot_func->in_req->complete = compl_do_reset;
 	fastboot_tx_write_str("OKAY");
 }
 static int strcmp_l1(const char *s1, const char *s2)
 {
 	if (!s1 || !s2)
 		return -1;
 	return strncmp(s1, s2, strlen(s1));
 }
 static void cb_getvar(struct usb_ep *ep, struct usb_request *req)
 {
 	char *cmd = req->buf;
 	char response[RESPONSE_LEN];
 	const char *s;
 	size_t chars_left;
 	strcpy(response, "OKAY");
 	chars_left = sizeof(response) - strlen(response) - 1;
 	strsep(&cmd, ":");
 	if (!cmd) {
 		error("missing variable\n");
 		fastboot_tx_write_str("FAILmissing var");
 		return;
 	}
 	if (!strcmp_l1("version", cmd)) {
 		strncat(response, FASTBOOT_VERSION, chars_left);
 	} else if (!strcmp_l1("bootloader-version", cmd)) {
 		strncat(response, U_BOOT_VERSION, chars_left);
-	} else if (!strcmp_l1("downloadsize", cmd)) {
+	} else if (!strcmp_l1("downloadsize", cmd) ||
+		!strcmp_l1("max-download-size", cmd)) {
 		char str_num[12];
-		sprintf(str_num, "%08x", CONFIG_USB_FASTBOOT_BUF_SIZE);
+		sprintf(str_num, "0x%08x", CONFIG_USB_FASTBOOT_BUF_SIZE);
 		strncat(response, str_num, chars_left);
 	} else if (!strcmp_l1("serialno", cmd)) {
 		s = getenv("serial#");
 		if (s)
 			strncat(response, s, chars_left);
 		else
 			strcpy(response, "FAILValue not set");
 	} else {
 		error("unknown variable: %s\n", cmd);
 		strcpy(response, "FAILVariable not implemented");
 	}
 	fastboot_tx_write_str(response);
 }
 static unsigned int rx_bytes_expected(void)
 {
 	int rx_remain = download_size - download_bytes;
 	if (rx_remain < 0)
 		return 0;
 	if (rx_remain > EP_BUFFER_SIZE)
 		return EP_BUFFER_SIZE;
 	return rx_remain;
 }
 #define BYTES_PER_DOT	0x20000
 static void rx_handler_dl_image(struct usb_ep *ep, struct usb_request *req)
 {
 	char response[RESPONSE_LEN];
 	unsigned int transfer_size = download_size - download_bytes;
 	const unsigned char *buffer = req->buf;
 	unsigned int buffer_size = req->actual;
+	unsigned int pre_dot_num, now_dot_num;
 	if (req->status != 0) {
 		printf("Bad status: %d\n", req->status);
 		return;
 	}
 	if (buffer_size < transfer_size)
 		transfer_size = buffer_size;
 	memcpy((void *)CONFIG_USB_FASTBOOT_BUF_ADDR + download_bytes,
 	       buffer, transfer_size);
+	pre_dot_num = download_bytes / BYTES_PER_DOT;
 	download_bytes += transfer_size;
+	now_dot_num = download_bytes / BYTES_PER_DOT;
+	if (pre_dot_num != now_dot_num) {
+		putc('.');
+		if (!(now_dot_num % 74))
+			putc('\n');
+	}
 	/* Check if transfer is done */
 	if (download_bytes >= download_size) {
 		/*
 		 * Reset global transfer variable, keep download_bytes because
 		 * it will be used in the next possible flashing command
 		 */
 		download_size = 0;
 		req->complete = rx_handler_command;
 		req->length = EP_BUFFER_SIZE;
 		sprintf(response, "OKAY");
 		fastboot_tx_write_str(response);
 		printf("\ndownloading of %d bytes finished\n", download_bytes);
 	} else {
 		req->length = rx_bytes_expected();
 		if (req->length < ep->maxpacket)
 			req->length = ep->maxpacket;
 	}
-	if (download_bytes && !(download_bytes % BYTES_PER_DOT)) {
-		putc('.');
-		if (!(download_bytes % (74 * BYTES_PER_DOT)))
-			putc('\n');
-	}
 	req->actual = 0;
 	usb_ep_queue(ep, req, 0);
 }
 static void cb_download(struct usb_ep *ep, struct usb_request *req)
 {
 	char *cmd = req->buf;
 	char response[RESPONSE_LEN];
 	strsep(&cmd, ":");
 	download_size = simple_strtoul(cmd, NULL, 16);
 	download_bytes = 0;
 	printf("Starting download of %d bytes\n", download_size);
 	if (0 == download_size) {
 		sprintf(response, "FAILdata invalid size");
 	} else if (download_size > CONFIG_USB_FASTBOOT_BUF_SIZE) {
 		download_size = 0;
 		sprintf(response, "FAILdata too large");
 	} else {
 		sprintf(response, "DATA%08x", download_size);
 		req->complete = rx_handler_dl_image;
 		req->length = rx_bytes_expected();
 		if (req->length < ep->maxpacket)
 			req->length = ep->maxpacket;
 	}
 	fastboot_tx_write_str(response);
 }
 static void do_bootm_on_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	char boot_addr_start[12];
 	char *bootm_args[] = { "bootm", boot_addr_start, NULL };
 	puts("Booting kernel..\n");
 	sprintf(boot_addr_start, "0x%lx", load_addr);
 	do_bootm(NULL, 0, 2, bootm_args);
 	/* This only happens if image is somehow faulty so we start over */
 	do_reset(NULL, 0, 0, NULL);
 }
 static void cb_boot(struct usb_ep *ep, struct usb_request *req)
 {
 	fastboot_func->in_req->complete = do_bootm_on_complete;
 	fastboot_tx_write_str("OKAY");
 }
 #ifdef CONFIG_FASTBOOT_FLASH
 static void cb_flash(struct usb_ep *ep, struct usb_request *req)
 {
 	char *cmd = req->buf;
 	char response[RESPONSE_LEN];
 	strsep(&cmd, ":");
 	if (!cmd) {
 		error("missing partition name\n");
 		fastboot_tx_write_str("FAILmissing partition name");
 		return;
 	}
 	strcpy(response, "FAILno flash device defined");
 #ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
 	fb_mmc_flash_write(cmd, (void *)CONFIG_USB_FASTBOOT_BUF_ADDR,
 			   download_bytes, response);
 #endif
 	fastboot_tx_write_str(response);
 }
 #endif
 struct cmd_dispatch_info {
 	char *cmd;
 	void (*cb)(struct usb_ep *ep, struct usb_request *req);
 };
 static const struct cmd_dispatch_info cmd_dispatch_info[] = {
 	{
 		.cmd = "reboot",
 		.cb = cb_reboot,
 	}, {
 		.cmd = "getvar:",
 		.cb = cb_getvar,
 	}, {
 		.cmd = "download:",
 		.cb = cb_download,
 	}, {
 		.cmd = "boot",
 		.cb = cb_boot,
 	},
 #ifdef CONFIG_FASTBOOT_FLASH
 	{
 		.cmd = "flash",
 		.cb = cb_flash,
 	},
 #endif
 };
 static void rx_handler_command(struct usb_ep *ep, struct usb_request *req)
 {
 	char *cmdbuf = req->buf;
 	void (*func_cb)(struct usb_ep *ep, struct usb_request *req) = NULL;
 	int i;
 	for (i = 0; i < ARRAY_SIZE(cmd_dispatch_info); i++) {
 		if (!strcmp_l1(cmd_dispatch_info[i].cmd, cmdbuf)) {
 			func_cb = cmd_dispatch_info[i].cb;
 			break;
 		}
 	}
 	if (!func_cb) {
 		error("unknown command: %s\n", cmdbuf);
 		fastboot_tx_write_str("FAILunknown command");
 	} else {
-		func_cb(ep, req);
+		if (req->actual < req->length) {
+			u8 *buf = (u8 *)req->buf;
+			buf[req->actual] = 0;
+			func_cb(ep, req);
+		} else {
+			error("buffer overflow\n");
+			fastboot_tx_write_str("FAILbuffer overflow");
+		}
 	}
 	if (req->status == 0) {
 		*cmdbuf = '\0';

drivers/usb/gadget/f_mass_storage.c

Diff comments View file @ 8a6b088

 /*
  * f_mass_storage.c -- Mass Storage USB Composite Function
  *
  * Copyright (C) 2003-2008 Alan Stern
  * Copyright (C) 2009 Samsung Electronics
  *                    Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
  * All rights reserved.
  *
  * SPDX-License-Identifier: GPL-2.0+	BSD-3-Clause
  */
 /*
  * The Mass Storage Function acts as a USB Mass Storage device,
  * appearing to the host as a disk drive or as a CD-ROM drive.  In
  * addition to providing an example of a genuinely useful composite
  * function for a USB device, it also illustrates a technique of
  * double-buffering for increased throughput.
  *
  * Function supports multiple logical units (LUNs).  Backing storage
  * for each LUN is provided by a regular file or a block device.
  * Access for each LUN can be limited to read-only.  Moreover, the
  * function can indicate that LUN is removable and/or CD-ROM.  (The
  * later implies read-only access.)
  *
  * MSF is configured by specifying a fsg_config structure.  It has the
  * following fields:
  *
  *	nluns		Number of LUNs function have (anywhere from 1
  *				to FSG_MAX_LUNS which is 8).
  *	luns		An array of LUN configuration values.  This
  *				should be filled for each LUN that
  *				function will include (ie. for "nluns"
  *				LUNs).  Each element of the array has
  *				the following fields:
  *	->filename	The path to the backing file for the LUN.
  *				Required if LUN is not marked as
  *				removable.
  *	->ro		Flag specifying access to the LUN shall be
  *				read-only.  This is implied if CD-ROM
  *				emulation is enabled as well as when
  *				it was impossible to open "filename"
  *				in R/W mode.
  *	->removable	Flag specifying that LUN shall be indicated as
  *				being removable.
  *	->cdrom		Flag specifying that LUN shall be reported as
  *				being a CD-ROM.
  *
  *	lun_name_format	A printf-like format for names of the LUN
  *				devices.  This determines how the
  *				directory in sysfs will be named.
  *				Unless you are using several MSFs in
  *				a single gadget (as opposed to single
  *				MSF in many configurations) you may
  *				leave it as NULL (in which case
  *				"lun%d" will be used).  In the format
  *				you can use "%d" to index LUNs for
  *				MSF's with more than one LUN.  (Beware
  *				that there is only one integer given
  *				as an argument for the format and
  *				specifying invalid format may cause
  *				unspecified behaviour.)
  *	thread_name	Name of the kernel thread process used by the
  *				MSF.  You can safely set it to NULL
  *				(in which case default "file-storage"
  *				will be used).
  *
  *	vendor_name
  *	product_name
  *	release		Information used as a reply to INQUIRY
  *				request.  To use default set to NULL,
  *				NULL, 0xffff respectively.  The first
  *				field should be 8 and the second 16
  *				characters or less.
  *
  *	can_stall	Set to permit function to halt bulk endpoints.
  *				Disabled on some USB devices known not
  *				to work correctly.  You should set it
  *				to true.
  *
  * If "removable" is not set for a LUN then a backing file must be
  * specified.  If it is set, then NULL filename means the LUN's medium
  * is not loaded (an empty string as "filename" in the fsg_config
  * structure causes error).  The CD-ROM emulation includes a single
  * data track and no audio tracks; hence there need be only one
  * backing file per LUN.  Note also that the CD-ROM block length is
  * set to 512 rather than the more common value 2048.
  *
  *
  * MSF includes support for module parameters.  If gadget using it
  * decides to use it, the following module parameters will be
  * available:
  *
  *	file=filename[,filename...]
  *			Names of the files or block devices used for
  *				backing storage.
  *	ro=b[,b...]	Default false, boolean for read-only access.
  *	removable=b[,b...]
  *			Default true, boolean for removable media.
  *	cdrom=b[,b...]	Default false, boolean for whether to emulate
  *				a CD-ROM drive.
  *	luns=N		Default N = number of filenames, number of
  *				LUNs to support.
  *	stall		Default determined according to the type of
  *				USB device controller (usually true),
  *				boolean to permit the driver to halt
  *				bulk endpoints.
  *
  * The module parameters may be prefixed with some string.  You need
  * to consult gadget's documentation or source to verify whether it is
  * using those module parameters and if it does what are the prefixes
  * (look for FSG_MODULE_PARAMETERS() macro usage, what's inside it is
  * the prefix).
  *
  *
  * Requirements are modest; only a bulk-in and a bulk-out endpoint are
  * needed.  The memory requirement amounts to two 16K buffers, size
  * configurable by a parameter.  Support is included for both
  * full-speed and high-speed operation.
  *
  * Note that the driver is slightly non-portable in that it assumes a
  * single memory/DMA buffer will be useable for bulk-in, bulk-out, and
  * interrupt-in endpoints.  With most device controllers this isn't an
  * issue, but there may be some with hardware restrictions that prevent
  * a buffer from being used by more than one endpoint.
  *
  *
  * The pathnames of the backing files and the ro settings are
  * available in the attribute files "file" and "ro" in the lun<n> (or
  * to be more precise in a directory which name comes from
  * "lun_name_format" option!) subdirectory of the gadget's sysfs
  * directory.  If the "removable" option is set, writing to these
  * files will simulate ejecting/loading the medium (writing an empty
  * line means eject) and adjusting a write-enable tab.  Changes to the
  * ro setting are not allowed when the medium is loaded or if CD-ROM
  * emulation is being used.
  *
  * When a LUN receive an "eject" SCSI request (Start/Stop Unit),
  * if the LUN is removable, the backing file is released to simulate
  * ejection.
  *
  *
  * This function is heavily based on "File-backed Storage Gadget" by
  * Alan Stern which in turn is heavily based on "Gadget Zero" by David
  * Brownell.  The driver's SCSI command interface was based on the
  * "Information technology - Small Computer System Interface - 2"
  * document from X3T9.2 Project 375D, Revision 10L, 7-SEP-93,
  * available at <http://www.t10.org/ftp/t10/drafts/s2/s2-r10l.pdf>.
  * The single exception is opcode 0x23 (READ FORMAT CAPACITIES), which
  * was based on the "Universal Serial Bus Mass Storage Class UFI
  * Command Specification" document, Revision 1.0, December 14, 1998,
  * available at
  * <http://www.usb.org/developers/devclass_docs/usbmass-ufi10.pdf>.
  */
 /*
  *				Driver Design
  *
  * The MSF is fairly straightforward.  There is a main kernel
  * thread that handles most of the work.  Interrupt routines field
  * callbacks from the controller driver: bulk- and interrupt-request
  * completion notifications, endpoint-0 events, and disconnect events.
  * Completion events are passed to the main thread by wakeup calls.  Many
  * ep0 requests are handled at interrupt time, but SetInterface,
  * SetConfiguration, and device reset requests are forwarded to the
  * thread in the form of "exceptions" using SIGUSR1 signals (since they
  * should interrupt any ongoing file I/O operations).
  *
  * The thread's main routine implements the standard command/data/status
  * parts of a SCSI interaction.  It and its subroutines are full of tests
  * for pending signals/exceptions -- all this polling is necessary since
  * the kernel has no setjmp/longjmp equivalents.  (Maybe this is an
  * indication that the driver really wants to be running in userspace.)
  * An important point is that so long as the thread is alive it keeps an
  * open reference to the backing file.  This will prevent unmounting
  * the backing file's underlying filesystem and could cause problems
  * during system shutdown, for example.  To prevent such problems, the
  * thread catches INT, TERM, and KILL signals and converts them into
  * an EXIT exception.
  *
  * In normal operation the main thread is started during the gadget's
  * fsg_bind() callback and stopped during fsg_unbind().  But it can
  * also exit when it receives a signal, and there's no point leaving
  * the gadget running when the thread is dead.  At of this moment, MSF
  * provides no way to deregister the gadget when thread dies -- maybe
  * a callback functions is needed.
  *
  * To provide maximum throughput, the driver uses a circular pipeline of
  * buffer heads (struct fsg_buffhd).  In principle the pipeline can be
  * arbitrarily long; in practice the benefits don't justify having more
  * than 2 stages (i.e., double buffering).  But it helps to think of the
  * pipeline as being a long one.  Each buffer head contains a bulk-in and
  * a bulk-out request pointer (since the buffer can be used for both
  * output and input -- directions always are given from the host's
  * point of view) as well as a pointer to the buffer and various state
  * variables.
  *
  * Use of the pipeline follows a simple protocol.  There is a variable
  * (fsg->next_buffhd_to_fill) that points to the next buffer head to use.
  * At any time that buffer head may still be in use from an earlier
  * request, so each buffer head has a state variable indicating whether
  * it is EMPTY, FULL, or BUSY.  Typical use involves waiting for the
  * buffer head to be EMPTY, filling the buffer either by file I/O or by
  * USB I/O (during which the buffer head is BUSY), and marking the buffer
  * head FULL when the I/O is complete.  Then the buffer will be emptied
  * (again possibly by USB I/O, during which it is marked BUSY) and
  * finally marked EMPTY again (possibly by a completion routine).
  *
  * A module parameter tells the driver to avoid stalling the bulk
  * endpoints wherever the transport specification allows.  This is
  * necessary for some UDCs like the SuperH, which cannot reliably clear a
  * halt on a bulk endpoint.  However, under certain circumstances the
  * Bulk-only specification requires a stall.  In such cases the driver
  * will halt the endpoint and set a flag indicating that it should clear
  * the halt in software during the next device reset.  Hopefully this
  * will permit everything to work correctly.  Furthermore, although the
  * specification allows the bulk-out endpoint to halt when the host sends
  * too much data, implementing this would cause an unavoidable race.
  * The driver will always use the "no-stall" approach for OUT transfers.
  *
  * One subtle point concerns sending status-stage responses for ep0
  * requests.  Some of these requests, such as device reset, can involve
  * interrupting an ongoing file I/O operation, which might take an
  * arbitrarily long time.  During that delay the host might give up on
  * the original ep0 request and issue a new one.  When that happens the
  * driver should not notify the host about completion of the original
  * request, as the host will no longer be waiting for it.  So the driver
  * assigns to each ep0 request a unique tag, and it keeps track of the
  * tag value of the request associated with a long-running exception
  * (device-reset, interface-change, or configuration-change).  When the
  * exception handler is finished, the status-stage response is submitted
  * only if the current ep0 request tag is equal to the exception request
  * tag.  Thus only the most recently received ep0 request will get a
  * status-stage response.
  *
  * Warning: This driver source file is too long.  It ought to be split up
  * into a header file plus about 3 separate .c files, to handle the details
  * of the Gadget, USB Mass Storage, and SCSI protocols.
  */
 /* #define VERBOSE_DEBUG */
 /* #define DUMP_MSGS */
 #include <config.h>
 #include <malloc.h>
 #include <common.h>
 #include <g_dnl.h>
 #include <linux/err.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 #include <usb_mass_storage.h>
 #include <asm/unaligned.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/composite.h>
 #include <usb/lin_gadget_compat.h>
 #include <g_dnl.h>
 /*------------------------------------------------------------------------*/
 #define FSG_DRIVER_DESC	"Mass Storage Function"
 #define FSG_DRIVER_VERSION	"2012/06/5"
 static const char fsg_string_interface[] = "Mass Storage";
 #define FSG_NO_INTR_EP 1
 #define FSG_NO_DEVICE_STRINGS    1
 #define FSG_NO_OTG               1
 #define FSG_NO_INTR_EP           1
 #include "storage_common.c"
 /*-------------------------------------------------------------------------*/
 #define GFP_ATOMIC ((gfp_t) 0)
 #define PAGE_CACHE_SHIFT	12
 #define PAGE_CACHE_SIZE		(1 << PAGE_CACHE_SHIFT)
 #define kthread_create(...)	__builtin_return_address(0)
 #define wait_for_completion(...) do {} while (0)
 struct kref {int x; };
 struct completion {int x; };
 inline void set_bit(int nr, volatile void *addr)
 {
 	int	mask;
 	unsigned int *a = (unsigned int *) addr;
 	a += nr >> 5;
 	mask = 1 << (nr & 0x1f);
 	*a |= mask;
 }
 inline void clear_bit(int nr, volatile void *addr)
 {
 	int	mask;
 	unsigned int *a = (unsigned int *) addr;
 	a += nr >> 5;
 	mask = 1 << (nr & 0x1f);
 	*a &= ~mask;
 }
 struct fsg_dev;
 struct fsg_common;
 /* Data shared by all the FSG instances. */
 struct fsg_common {
 	struct usb_gadget	*gadget;
 	struct fsg_dev		*fsg, *new_fsg;
 	struct usb_ep		*ep0;		/* Copy of gadget->ep0 */
 	struct usb_request	*ep0req;	/* Copy of cdev->req */
 	unsigned int		ep0_req_tag;
 	struct fsg_buffhd	*next_buffhd_to_fill;
 	struct fsg_buffhd	*next_buffhd_to_drain;
 	struct fsg_buffhd	buffhds[FSG_NUM_BUFFERS];
 	int			cmnd_size;
 	u8			cmnd[MAX_COMMAND_SIZE];
 	unsigned int		nluns;
 	unsigned int		lun;
 	struct fsg_lun          luns[FSG_MAX_LUNS];
 	unsigned int		bulk_out_maxpacket;
 	enum fsg_state		state;		/* For exception handling */
 	unsigned int		exception_req_tag;
 	enum data_direction	data_dir;
 	u32			data_size;
 	u32			data_size_from_cmnd;
 	u32			tag;
 	u32			residue;
 	u32			usb_amount_left;
 	unsigned int		can_stall:1;
 	unsigned int		free_storage_on_release:1;
 	unsigned int		phase_error:1;
 	unsigned int		short_packet_received:1;
 	unsigned int		bad_lun_okay:1;
 	unsigned int		running:1;
 	int			thread_wakeup_needed;
 	struct completion	thread_notifier;
 	struct task_struct	*thread_task;
 	/* Callback functions. */
 	const struct fsg_operations	*ops;
 	/* Gadget's private data. */
 	void			*private_data;
 	const char *vendor_name;		/*  8 characters or less */
 	const char *product_name;		/* 16 characters or less */
 	u16 release;
 	/* Vendor (8 chars), product (16 chars), release (4
 	 * hexadecimal digits) and NUL byte */
 	char inquiry_string[8 + 16 + 4 + 1];
 	struct kref		ref;
 };
 struct fsg_config {
 	unsigned nluns;
 	struct fsg_lun_config {
 		const char *filename;
 		char ro;
 		char removable;
 		char cdrom;
 		char nofua;
 	} luns[FSG_MAX_LUNS];
 	/* Callback functions. */
 	const struct fsg_operations     *ops;
 	/* Gadget's private data. */
 	void			*private_data;
 	const char *vendor_name;		/*  8 characters or less */
 	const char *product_name;		/* 16 characters or less */
 	char			can_stall;
 };
 struct fsg_dev {
 	struct usb_function	function;
 	struct usb_gadget	*gadget;	/* Copy of cdev->gadget */
 	struct fsg_common	*common;
 	u16			interface_number;
 	unsigned int		bulk_in_enabled:1;
 	unsigned int		bulk_out_enabled:1;
 	unsigned long		atomic_bitflags;
 #define IGNORE_BULK_OUT		0
 	struct usb_ep		*bulk_in;
 	struct usb_ep		*bulk_out;
 };
 static inline int __fsg_is_set(struct fsg_common *common,
 			       const char *func, unsigned line)
 {
 	if (common->fsg)
 		return 1;
 	ERROR(common, "common->fsg is NULL in %s at %u\n", func, line);
 	WARN_ON(1);
 	return 0;
 }
 #define fsg_is_set(common) likely(__fsg_is_set(common, __func__, __LINE__))
 static inline struct fsg_dev *fsg_from_func(struct usb_function *f)
 {
 	return container_of(f, struct fsg_dev, function);
 }
 typedef void (*fsg_routine_t)(struct fsg_dev *);
 static int exception_in_progress(struct fsg_common *common)
 {
 	return common->state > FSG_STATE_IDLE;
 }
 /* Make bulk-out requests be divisible by the maxpacket size */
 static void set_bulk_out_req_length(struct fsg_common *common,
 		struct fsg_buffhd *bh, unsigned int length)
 {
 	unsigned int	rem;
 	bh->bulk_out_intended_length = length;
 	rem = length % common->bulk_out_maxpacket;
 	if (rem > 0)
 		length += common->bulk_out_maxpacket - rem;
 	bh->outreq->length = length;
 }
 /*-------------------------------------------------------------------------*/
 struct ums *ums;
 struct fsg_common *the_fsg_common;
 static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
 {
 	const char	*name;
 	if (ep == fsg->bulk_in)
 		name = "bulk-in";
 	else if (ep == fsg->bulk_out)
 		name = "bulk-out";
 	else
 		name = ep->name;
 	DBG(fsg, "%s set halt\n", name);
 	return usb_ep_set_halt(ep);
 }
 /*-------------------------------------------------------------------------*/
 /* These routines may be called in process context or in_irq */
 /* Caller must hold fsg->lock */
 static void wakeup_thread(struct fsg_common *common)
 {
 	common->thread_wakeup_needed = 1;
 }
 static void raise_exception(struct fsg_common *common, enum fsg_state new_state)
 {
 	/* Do nothing if a higher-priority exception is already in progress.
 	 * If a lower-or-equal priority exception is in progress, preempt it
 	 * and notify the main thread by sending it a signal. */
 	if (common->state <= new_state) {
 		common->exception_req_tag = common->ep0_req_tag;
 		common->state = new_state;
 		common->thread_wakeup_needed = 1;
 	}
 }
 /*-------------------------------------------------------------------------*/
 static int ep0_queue(struct fsg_common *common)
 {
 	int	rc;
 	rc = usb_ep_queue(common->ep0, common->ep0req, GFP_ATOMIC);
 	common->ep0->driver_data = common;
 	if (rc != 0 && rc != -ESHUTDOWN) {
 		/* We can't do much more than wait for a reset */
 		WARNING(common, "error in submission: %s --> %d\n",
 			common->ep0->name, rc);
 	}
 	return rc;
 }
 /*-------------------------------------------------------------------------*/
 /* Bulk and interrupt endpoint completion handlers.
  * These always run in_irq. */
 static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	struct fsg_common	*common = ep->driver_data;
 	struct fsg_buffhd	*bh = req->context;
 	if (req->status || req->actual != req->length)
 		DBG(common, "%s --> %d, %u/%u\n", __func__,
 				req->status, req->actual, req->length);
 	if (req->status == -ECONNRESET)		/* Request was cancelled */
 		usb_ep_fifo_flush(ep);
 	/* Hold the lock while we update the request and buffer states */
 	bh->inreq_busy = 0;
 	bh->state = BUF_STATE_EMPTY;
 	wakeup_thread(common);
 }
 static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	struct fsg_common	*common = ep->driver_data;
 	struct fsg_buffhd	*bh = req->context;
 	dump_msg(common, "bulk-out", req->buf, req->actual);
 	if (req->status || req->actual != bh->bulk_out_intended_length)
 		DBG(common, "%s --> %d, %u/%u\n", __func__,
 				req->status, req->actual,
 				bh->bulk_out_intended_length);
 	if (req->status == -ECONNRESET)		/* Request was cancelled */
 		usb_ep_fifo_flush(ep);
 	/* Hold the lock while we update the request and buffer states */
 	bh->outreq_busy = 0;
 	bh->state = BUF_STATE_FULL;
 	wakeup_thread(common);
 }
 /*-------------------------------------------------------------------------*/
 /* Ep0 class-specific handlers.  These always run in_irq. */
 static int fsg_setup(struct usb_function *f,
 		const struct usb_ctrlrequest *ctrl)
 {
 	struct fsg_dev		*fsg = fsg_from_func(f);
 	struct usb_request	*req = fsg->common->ep0req;
 	u16			w_index = get_unaligned_le16(&ctrl->wIndex);
 	u16			w_value = get_unaligned_le16(&ctrl->wValue);
 	u16			w_length = get_unaligned_le16(&ctrl->wLength);
 	if (!fsg_is_set(fsg->common))
 		return -EOPNOTSUPP;
 	switch (ctrl->bRequest) {
 	case USB_BULK_RESET_REQUEST:
 		if (ctrl->bRequestType !=
 		    (USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
 			break;
 		if (w_index != fsg->interface_number || w_value != 0)
 			return -EDOM;
 		/* Raise an exception to stop the current operation
 		 * and reinitialize our state. */
 		DBG(fsg, "bulk reset request\n");
 		raise_exception(fsg->common, FSG_STATE_RESET);
 		return DELAYED_STATUS;
 	case USB_BULK_GET_MAX_LUN_REQUEST:
 		if (ctrl->bRequestType !=
 		    (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
 			break;
 		if (w_index != fsg->interface_number || w_value != 0)
 			return -EDOM;
 		VDBG(fsg, "get max LUN\n");
 		*(u8 *) req->buf = fsg->common->nluns - 1;
 		/* Respond with data/status */
 		req->length = min((u16)1, w_length);
 		return ep0_queue(fsg->common);
 	}
 	VDBG(fsg,
 	     "unknown class-specific control req "
 	     "%02x.%02x v%04x i%04x l%u\n",
 	     ctrl->bRequestType, ctrl->bRequest,
 	     get_unaligned_le16(&ctrl->wValue), w_index, w_length);
 	return -EOPNOTSUPP;
 }
 /*-------------------------------------------------------------------------*/
 /* All the following routines run in process context */
 /* Use this for bulk or interrupt transfers, not ep0 */
 static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
 		struct usb_request *req, int *pbusy,
 		enum fsg_buffer_state *state)
 {
 	int	rc;
 	if (ep == fsg->bulk_in)
 		dump_msg(fsg, "bulk-in", req->buf, req->length);
 	*pbusy = 1;
 	*state = BUF_STATE_BUSY;
 	rc = usb_ep_queue(ep, req, GFP_KERNEL);
 	if (rc != 0) {
 		*pbusy = 0;
 		*state = BUF_STATE_EMPTY;
 		/* We can't do much more than wait for a reset */
 		/* Note: currently the net2280 driver fails zero-length
 		 * submissions if DMA is enabled. */
 		if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP &&
 						req->length == 0))
 			WARNING(fsg, "error in submission: %s --> %d\n",
 					ep->name, rc);
 	}
 }
 #define START_TRANSFER_OR(common, ep_name, req, pbusy, state)		\
 	if (fsg_is_set(common))						\
 		start_transfer((common)->fsg, (common)->fsg->ep_name,	\
 			       req, pbusy, state);			\
 	else
 #define START_TRANSFER(common, ep_name, req, pbusy, state)		\
 	START_TRANSFER_OR(common, ep_name, req, pbusy, state) (void)0
 static void busy_indicator(void)
 {
 	static int state;
 	switch (state) {
 	case 0:
 		puts("\r|"); break;
 	case 1:
 		puts("\r/"); break;
 	case 2:
 		puts("\r-"); break;
 	case 3:
 		puts("\r\\"); break;
 	case 4:
 		puts("\r|"); break;
 	case 5:
 		puts("\r/"); break;
 	case 6:
 		puts("\r-"); break;
 	case 7:
 		puts("\r\\"); break;
 	default:
 		state = 0;
 	}
 	if (state++ == 8)
 		state = 0;
 }
 static int sleep_thread(struct fsg_common *common)
 {
 	int	rc = 0;
 	int i = 0, k = 0;
 	/* Wait until a signal arrives or we are woken up */
 	for (;;) {
 		if (common->thread_wakeup_needed)
 			break;
 		if (++i == 50000) {
 			busy_indicator();
 			i = 0;
 			k++;
 		}
 		if (k == 10) {
 			/* Handle CTRL+C */
 			if (ctrlc())
 				return -EPIPE;
 			/* Check cable connection */
 			if (!g_dnl_board_usb_cable_connected())
 				return -EIO;
 			k = 0;
 		}
 		usb_gadget_handle_interrupts();
 	}
 	common->thread_wakeup_needed = 0;
 	return rc;
 }
 /*-------------------------------------------------------------------------*/
 static int do_read(struct fsg_common *common)
 {
 	struct fsg_lun		*curlun = &common->luns[common->lun];
 	u32			lba;
 	struct fsg_buffhd	*bh;
 	int			rc;
 	u32			amount_left;
 	loff_t			file_offset;
 	unsigned int		amount;
 	unsigned int		partial_page;
 	ssize_t			nread;
 	/* Get the starting Logical Block Address and check that it's
 	 * not too big */
 	if (common->cmnd[0] == SC_READ_6)
 		lba = get_unaligned_be24(&common->cmnd[1]);
 	else {
 		lba = get_unaligned_be32(&common->cmnd[2]);
 		/* We allow DPO (Disable Page Out = don't save data in the
 		 * cache) and FUA (Force Unit Access = don't read from the
 		 * cache), but we don't implement them. */
 		if ((common->cmnd[1] & ~0x18) != 0) {
 			curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
 			return -EINVAL;
 		}
 	}
 	if (lba >= curlun->num_sectors) {
 		curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
 		return -EINVAL;
 	}
 	file_offset = ((loff_t) lba) << 9;
 	/* Carry out the file reads */
 	amount_left = common->data_size_from_cmnd;
 	if (unlikely(amount_left == 0))
 		return -EIO;		/* No default reply */
 	for (;;) {
 		/* Figure out how much we need to read:
 		 * Try to read the remaining amount.
 		 * But don't read more than the buffer size.
 		 * And don't try to read past the end of the file.
 		 * Finally, if we're not at a page boundary, don't read past
 		 *	the next page.
 		 * If this means reading 0 then we were asked to read past
 		 *	the end of file. */
 		amount = min(amount_left, FSG_BUFLEN);
 		partial_page = file_offset & (PAGE_CACHE_SIZE - 1);
 		if (partial_page > 0)
 			amount = min(amount, (unsigned int) PAGE_CACHE_SIZE -
 					partial_page);
 		/* Wait for the next buffer to become available */
 		bh = common->next_buffhd_to_fill;
 		while (bh->state != BUF_STATE_EMPTY) {
 			rc = sleep_thread(common);
 			if (rc)
 				return rc;
 		}
 		/* If we were asked to read past the end of file,
 		 * end with an empty buffer. */
 		if (amount == 0) {
 			curlun->sense_data =
 					SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
 			curlun->info_valid = 1;
 			bh->inreq->length = 0;
 			bh->state = BUF_STATE_FULL;
 			break;
 		}
 		/* Perform the read */
 		rc = ums->read_sector(ums,
 				      file_offset / SECTOR_SIZE,
 				      amount / SECTOR_SIZE,
 				      (char __user *)bh->buf);
 		if (!rc)
 			return -EIO;
 		nread = rc * SECTOR_SIZE;
 		VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
 				(unsigned long long) file_offset,
 				(int) nread);
 		if (nread < 0) {
 			LDBG(curlun, "error in file read: %d\n",
 					(int) nread);
 			nread = 0;
 		} else if (nread < amount) {
 			LDBG(curlun, "partial file read: %d/%u\n",
 					(int) nread, amount);
 			nread -= (nread & 511);	/* Round down to a block */
 		}
 		file_offset  += nread;
 		amount_left  -= nread;
 		common->residue -= nread;
 		bh->inreq->length = nread;
 		bh->state = BUF_STATE_FULL;
 		/* If an error occurred, report it and its position */
 		if (nread < amount) {
 			curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
 			curlun->info_valid = 1;
 			break;
 		}
 		if (amount_left == 0)
 			break;		/* No more left to read */
 		/* Send this buffer and go read some more */
 		bh->inreq->zero = 0;
 		START_TRANSFER_OR(common, bulk_in, bh->inreq,
 			       &bh->inreq_busy, &bh->state)
 			/* Don't know what to do if
 			 * common->fsg is NULL */
 			return -EIO;
 		common->next_buffhd_to_fill = bh->next;
 	}
 	return -EIO;		/* No default reply */
 }
 /*-------------------------------------------------------------------------*/
 static int do_write(struct fsg_common *common)
 {
 	struct fsg_lun		*curlun = &common->luns[common->lun];
 	u32			lba;
 	struct fsg_buffhd	*bh;
 	int			get_some_more;
 	u32			amount_left_to_req, amount_left_to_write;
 	loff_t			usb_offset, file_offset;
 	unsigned int		amount;
 	unsigned int		partial_page;
 	ssize_t			nwritten;
 	int			rc;
 	if (curlun->ro) {
 		curlun->sense_data = SS_WRITE_PROTECTED;
 		return -EINVAL;
 	}
 	/* Get the starting Logical Block Address and check that it's
 	 * not too big */
 	if (common->cmnd[0] == SC_WRITE_6)
 		lba = get_unaligned_be24(&common->cmnd[1]);
 	else {
 		lba = get_unaligned_be32(&common->cmnd[2]);
 		/* We allow DPO (Disable Page Out = don't save data in the
 		 * cache) and FUA (Force Unit Access = write directly to the
 		 * medium).  We don't implement DPO; we implement FUA by
 		 * performing synchronous output. */
 		if (common->cmnd[1] & ~0x18) {
 			curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
 			return -EINVAL;
 		}
 	}
 	if (lba >= curlun->num_sectors) {
 		curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
 		return -EINVAL;
 	}
 	/* Carry out the file writes */
 	get_some_more = 1;
 	file_offset = usb_offset = ((loff_t) lba) << 9;
 	amount_left_to_req = common->data_size_from_cmnd;
 	amount_left_to_write = common->data_size_from_cmnd;
 	while (amount_left_to_write > 0) {
 		/* Queue a request for more data from the host */
 		bh = common->next_buffhd_to_fill;
 		if (bh->state == BUF_STATE_EMPTY && get_some_more) {
 			/* Figure out how much we want to get:
 			 * Try to get the remaining amount.
 			 * But don't get more than the buffer size.
 			 * And don't try to go past the end of the file.
 			 * If we're not at a page boundary,
 			 *	don't go past the next page.
 			 * If this means getting 0, then we were asked
 			 *	to write past the end of file.
 			 * Finally, round down to a block boundary. */
 			amount = min(amount_left_to_req, FSG_BUFLEN);
 			partial_page = usb_offset & (PAGE_CACHE_SIZE - 1);
 			if (partial_page > 0)
 				amount = min(amount,
 	(unsigned int) PAGE_CACHE_SIZE - partial_page);
 			if (amount == 0) {
 				get_some_more = 0;
 				curlun->sense_data =
 					SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
 				curlun->info_valid = 1;
 				continue;
 			}
 			amount -= (amount & 511);
 			if (amount == 0) {
 				/* Why were we were asked to transfer a
 				 * partial block? */
 				get_some_more = 0;
 				continue;
 			}
 			/* Get the next buffer */
 			usb_offset += amount;
 			common->usb_amount_left -= amount;
 			amount_left_to_req -= amount;
 			if (amount_left_to_req == 0)
 				get_some_more = 0;
 			/* amount is always divisible by 512, hence by
 			 * the bulk-out maxpacket size */
 			bh->outreq->length = amount;
 			bh->bulk_out_intended_length = amount;
 			bh->outreq->short_not_ok = 1;
 			START_TRANSFER_OR(common, bulk_out, bh->outreq,
 					  &bh->outreq_busy, &bh->state)
 				/* Don't know what to do if
 				 * common->fsg is NULL */
 				return -EIO;
 			common->next_buffhd_to_fill = bh->next;
 			continue;
 		}
 		/* Write the received data to the backing file */
 		bh = common->next_buffhd_to_drain;
 		if (bh->state == BUF_STATE_EMPTY && !get_some_more)
 			break;			/* We stopped early */
 		if (bh->state == BUF_STATE_FULL) {
 			common->next_buffhd_to_drain = bh->next;
 			bh->state = BUF_STATE_EMPTY;
 			/* Did something go wrong with the transfer? */
 			if (bh->outreq->status != 0) {
 				curlun->sense_data = SS_COMMUNICATION_FAILURE;
 				curlun->info_valid = 1;
 				break;
 			}
 			amount = bh->outreq->actual;
 			/* Perform the write */
 			rc = ums->write_sector(ums,
 					       file_offset / SECTOR_SIZE,
 					       amount / SECTOR_SIZE,
 					       (char __user *)bh->buf);
 			if (!rc)
 				return -EIO;
 			nwritten = rc * SECTOR_SIZE;
 			VLDBG(curlun, "file write %u @ %llu -> %d\n", amount,
 					(unsigned long long) file_offset,
 					(int) nwritten);
 			if (nwritten < 0) {
 				LDBG(curlun, "error in file write: %d\n",
 						(int) nwritten);
 				nwritten = 0;
 			} else if (nwritten < amount) {
 				LDBG(curlun, "partial file write: %d/%u\n",
 						(int) nwritten, amount);
 				nwritten -= (nwritten & 511);
 				/* Round down to a block */
 			}
 			file_offset += nwritten;
 			amount_left_to_write -= nwritten;
 			common->residue -= nwritten;
 			/* If an error occurred, report it and its position */
 			if (nwritten < amount) {
 				printf("nwritten:%d amount:%d\n", nwritten,
 				       amount);
 				curlun->sense_data = SS_WRITE_ERROR;
 				curlun->info_valid = 1;
 				break;
 			}
 			/* Did the host decide to stop early? */
 			if (bh->outreq->actual != bh->outreq->length) {
 				common->short_packet_received = 1;
 				break;
 			}
 			continue;
 		}
 		/* Wait for something to happen */
 		rc = sleep_thread(common);
 		if (rc)
 			return rc;
 	}
 	return -EIO;		/* No default reply */
 }
 /*-------------------------------------------------------------------------*/
 static int do_synchronize_cache(struct fsg_common *common)
 {
 	return 0;
 }
 /*-------------------------------------------------------------------------*/
 static int do_verify(struct fsg_common *common)
 {
 	struct fsg_lun		*curlun = &common->luns[common->lun];
 	u32			lba;
 	u32			verification_length;
 	struct fsg_buffhd	*bh = common->next_buffhd_to_fill;
 	loff_t			file_offset;
 	u32			amount_left;
 	unsigned int		amount;
 	ssize_t			nread;
 	int			rc;
 	/* Get the starting Logical Block Address and check that it's
 	 * not too big */
 	lba = get_unaligned_be32(&common->cmnd[2]);
 	if (lba >= curlun->num_sectors) {
 		curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
 		return -EINVAL;
 	}
 	/* We allow DPO (Disable Page Out = don't save data in the
 	 * cache) but we don't implement it. */
 	if (common->cmnd[1] & ~0x10) {
 		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
 		return -EINVAL;
 	}
 	verification_length = get_unaligned_be16(&common->cmnd[7]);
 	if (unlikely(verification_length == 0))
 		return -EIO;		/* No default reply */
 	/* Prepare to carry out the file verify */
 	amount_left = verification_length << 9;
 	file_offset = ((loff_t) lba) << 9;
 	/* Write out all the dirty buffers before invalidating them */
 	/* Just try to read the requested blocks */
 	while (amount_left > 0) {
 		/* Figure out how much we need to read:
 		 * Try to read the remaining amount, but not more than
 		 * the buffer size.
 		 * And don't try to read past the end of the file.
 		 * If this means reading 0 then we were asked to read
 		 * past the end of file. */
 		amount = min(amount_left, FSG_BUFLEN);
 		if (amount == 0) {
 			curlun->sense_data =
 					SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
 			curlun->info_valid = 1;
 			break;
 		}
 		/* Perform the read */
 		rc = ums->read_sector(ums,
 				      file_offset / SECTOR_SIZE,
 				      amount / SECTOR_SIZE,
 				      (char __user *)bh->buf);
 		if (!rc)
 			return -EIO;
 		nread = rc * SECTOR_SIZE;
 		VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
 				(unsigned long long) file_offset,
 				(int) nread);
 		if (nread < 0) {
 			LDBG(curlun, "error in file verify: %d\n",
 					(int) nread);
 			nread = 0;
 		} else if (nread < amount) {
 			LDBG(curlun, "partial file verify: %d/%u\n",
 					(int) nread, amount);
 			nread -= (nread & 511);	/* Round down to a sector */
 		}
 		if (nread == 0) {
 			curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
 			curlun->info_valid = 1;
 			break;
 		}
 		file_offset += nread;
 		amount_left -= nread;
 	}
 	return 0;
 }
 /*-------------------------------------------------------------------------*/
 static int do_inquiry(struct fsg_common *common, struct fsg_buffhd *bh)
 {
 	struct fsg_lun *curlun = &common->luns[common->lun];
 	static const char vendor_id[] = "Linux   ";
 	u8	*buf = (u8 *) bh->buf;
 	if (!curlun) {		/* Unsupported LUNs are okay */
 		common->bad_lun_okay = 1;
 		memset(buf, 0, 36);
 		buf[0] = 0x7f;		/* Unsupported, no device-type */
 		buf[4] = 31;		/* Additional length */
 		return 36;
 	}
 	memset(buf, 0, 8);
 	buf[0] = TYPE_DISK;
+	buf[1] = curlun->removable ? 0x80 : 0;
 	buf[2] = 2;		/* ANSI SCSI level 2 */
 	buf[3] = 2;		/* SCSI-2 INQUIRY data format */
 	buf[4] = 31;		/* Additional length */
 				/* No special options */
 	sprintf((char *) (buf + 8), "%-8s%-16s%04x", (char*) vendor_id ,
 			ums->name, (u16) 0xffff);
 	return 36;
 }
 static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
 {
 	struct fsg_lun	*curlun = &common->luns[common->lun];
 	u8		*buf = (u8 *) bh->buf;
 	u32		sd, sdinfo;
 	int		valid;
 	/*
 	 * From the SCSI-2 spec., section 7.9 (Unit attention condition):
 	 *
 	 * If a REQUEST SENSE command is received from an initiator
 	 * with a pending unit attention condition (before the target
 	 * generates the contingent allegiance condition), then the
 	 * target shall either:
 	 *   a) report any pending sense data and preserve the unit
 	 *	attention condition on the logical unit, or,
 	 *   b) report the unit attention condition, may discard any
 	 *	pending sense data, and clear the unit attention
 	 *	condition on the logical unit for that initiator.
 	 *
 	 * FSG normally uses option a); enable this code to use option b).
 	 */
 #if 0
 	if (curlun && curlun->unit_attention_data != SS_NO_SENSE) {
 		curlun->sense_data = curlun->unit_attention_data;
 		curlun->unit_attention_data = SS_NO_SENSE;
 	}
 #endif
 	if (!curlun) {		/* Unsupported LUNs are okay */
 		common->bad_lun_okay = 1;
 		sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
 		sdinfo = 0;
 		valid = 0;
 	} else {
 		sd = curlun->sense_data;
 		valid = curlun->info_valid << 7;
 		curlun->sense_data = SS_NO_SENSE;
 		curlun->info_valid = 0;
 	}
 	memset(buf, 0, 18);
 	buf[0] = valid | 0x70;			/* Valid, current error */
 	buf[2] = SK(sd);
 	put_unaligned_be32(sdinfo, &buf[3]);	/* Sense information */
 	buf[7] = 18 - 8;			/* Additional sense length */
 	buf[12] = ASC(sd);
 	buf[13] = ASCQ(sd);
 	return 18;
 }
 static int do_read_capacity(struct fsg_common *common, struct fsg_buffhd *bh)
 {
 	struct fsg_lun	*curlun = &common->luns[common->lun];
 	u32		lba = get_unaligned_be32(&common->cmnd[2]);
 	int		pmi = common->cmnd[8];
 	u8		*buf = (u8 *) bh->buf;
 	/* Check the PMI and LBA fields */
 	if (pmi > 1 || (pmi == 0 && lba != 0)) {
 		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
 		return -EINVAL;
 	}
 	put_unaligned_be32(curlun->num_sectors - 1, &buf[0]);
 						/* Max logical block */
 	put_unaligned_be32(512, &buf[4]);	/* Block length */
 	return 8;
 }
 static int do_read_header(struct fsg_common *common, struct fsg_buffhd *bh)
 {
 	struct fsg_lun	*curlun = &common->luns[common->lun];
 	int		msf = common->cmnd[1] & 0x02;
 	u32		lba = get_unaligned_be32(&common->cmnd[2]);
 	u8		*buf = (u8 *) bh->buf;
 	if (common->cmnd[1] & ~0x02) {		/* Mask away MSF */
 		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
 		return -EINVAL;
 	}
 	if (lba >= curlun->num_sectors) {
 		curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
 		return -EINVAL;
 	}
 	memset(buf, 0, 8);
 	buf[0] = 0x01;		/* 2048 bytes of user data, rest is EC */
 	store_cdrom_address(&buf[4], msf, lba);
 	return 8;
 }
 static int do_read_toc(struct fsg_common *common, struct fsg_buffhd *bh)
 {
 	struct fsg_lun	*curlun = &common->luns[common->lun];
 	int		msf = common->cmnd[1] & 0x02;
 	int		start_track = common->cmnd[6];
 	u8		*buf = (u8 *) bh->buf;
 	if ((common->cmnd[1] & ~0x02) != 0 ||	/* Mask away MSF */
 			start_track > 1) {
 		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
 		return -EINVAL;
 	}
 	memset(buf, 0, 20);
 	buf[1] = (20-2);		/* TOC data length */
 	buf[2] = 1;			/* First track number */
 	buf[3] = 1;			/* Last track number */
 	buf[5] = 0x16;			/* Data track, copying allowed */
 	buf[6] = 0x01;			/* Only track is number 1 */
 	store_cdrom_address(&buf[8], msf, 0);
 	buf[13] = 0x16;			/* Lead-out track is data */
 	buf[14] = 0xAA;			/* Lead-out track number */
 	store_cdrom_address(&buf[16], msf, curlun->num_sectors);
 	return 20;
 }
 static int do_mode_sense(struct fsg_common *common, struct fsg_buffhd *bh)
 {
 	struct fsg_lun	*curlun = &common->luns[common->lun];
 	int		mscmnd = common->cmnd[0];
 	u8		*buf = (u8 *) bh->buf;
 	u8		*buf0 = buf;
 	int		pc, page_code;
 	int		changeable_values, all_pages;
 	int		valid_page = 0;
 	int		len, limit;
 	if ((common->cmnd[1] & ~0x08) != 0) {	/* Mask away DBD */
 		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
 		return -EINVAL;
 	}
 	pc = common->cmnd[2] >> 6;
 	page_code = common->cmnd[2] & 0x3f;
 	if (pc == 3) {
 		curlun->sense_data = SS_SAVING_PARAMETERS_NOT_SUPPORTED;
 		return -EINVAL;
 	}
 	changeable_values = (pc == 1);
 	all_pages = (page_code == 0x3f);
 	/* Write the mode parameter header.  Fixed values are: default
 	 * medium type, no cache control (DPOFUA), and no block descriptors.
 	 * The only variable value is the WriteProtect bit.  We will fill in
 	 * the mode data length later. */
 	memset(buf, 0, 8);
 	if (mscmnd == SC_MODE_SENSE_6) {
 		buf[2] = (curlun->ro ? 0x80 : 0x00);		/* WP, DPOFUA */
 		buf += 4;
 		limit = 255;
 	} else {			/* SC_MODE_SENSE_10 */
 		buf[3] = (curlun->ro ? 0x80 : 0x00);		/* WP, DPOFUA */
 		buf += 8;
 		limit = 65535;		/* Should really be FSG_BUFLEN */
 	}
 	/* No block descriptors */
 	/* The mode pages, in numerical order.  The only page we support
 	 * is the Caching page. */
 	if (page_code == 0x08 || all_pages) {
 		valid_page = 1;
 		buf[0] = 0x08;		/* Page code */
 		buf[1] = 10;		/* Page length */
 		memset(buf+2, 0, 10);	/* None of the fields are changeable */
 		if (!changeable_values) {
 			buf[2] = 0x04;	/* Write cache enable, */
 					/* Read cache not disabled */
 					/* No cache retention priorities */
 			put_unaligned_be16(0xffff, &buf[4]);
 					/* Don't disable prefetch */
 					/* Minimum prefetch = 0 */
 			put_unaligned_be16(0xffff, &buf[8]);
 					/* Maximum prefetch */
 			put_unaligned_be16(0xffff, &buf[10]);
 					/* Maximum prefetch ceiling */
 		}
 		buf += 12;
 	}
 	/* Check that a valid page was requested and the mode data length
 	 * isn't too long. */
 	len = buf - buf0;
 	if (!valid_page || len > limit) {
 		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
 		return -EINVAL;
 	}
 	/*  Store the mode data length */
 	if (mscmnd == SC_MODE_SENSE_6)
 		buf0[0] = len - 1;
 	else
 		put_unaligned_be16(len - 2, buf0);
 	return len;
 }
 static int do_start_stop(struct fsg_common *common)
 {
 	struct fsg_lun	*curlun = &common->luns[common->lun];
 	if (!curlun) {
 		return -EINVAL;
 	} else if (!curlun->removable) {
 		curlun->sense_data = SS_INVALID_COMMAND;
 		return -EINVAL;
 	}
 	return 0;
 }
 static int do_prevent_allow(struct fsg_common *common)
 {
 	struct fsg_lun	*curlun = &common->luns[common->lun];
 	int		prevent;
 	if (!curlun->removable) {
 		curlun->sense_data = SS_INVALID_COMMAND;
 		return -EINVAL;
 	}
 	prevent = common->cmnd[4] & 0x01;
 	if ((common->cmnd[4] & ~0x01) != 0) {	/* Mask away Prevent */
 		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
 		return -EINVAL;
 	}
 	if (curlun->prevent_medium_removal && !prevent)
 		fsg_lun_fsync_sub(curlun);
 	curlun->prevent_medium_removal = prevent;
 	return 0;
 }
 static int do_read_format_capacities(struct fsg_common *common,
 			struct fsg_buffhd *bh)
 {
 	struct fsg_lun	*curlun = &common->luns[common->lun];
 	u8		*buf = (u8 *) bh->buf;
 	buf[0] = buf[1] = buf[2] = 0;
 	buf[3] = 8;	/* Only the Current/Maximum Capacity Descriptor */
 	buf += 4;
 	put_unaligned_be32(curlun->num_sectors, &buf[0]);
 						/* Number of blocks */
 	put_unaligned_be32(512, &buf[4]);	/* Block length */
 	buf[4] = 0x02;				/* Current capacity */
 	return 12;
 }
 static int do_mode_select(struct fsg_common *common, struct fsg_buffhd *bh)
 {
 	struct fsg_lun	*curlun = &common->luns[common->lun];
 	/* We don't support MODE SELECT */
 	if (curlun)
 		curlun->sense_data = SS_INVALID_COMMAND;
 	return -EINVAL;
 }
 /*-------------------------------------------------------------------------*/
 static int halt_bulk_in_endpoint(struct fsg_dev *fsg)
 {
 	int	rc;
 	rc = fsg_set_halt(fsg, fsg->bulk_in);
 	if (rc == -EAGAIN)
 		VDBG(fsg, "delayed bulk-in endpoint halt\n");
 	while (rc != 0) {
 		if (rc != -EAGAIN) {
 			WARNING(fsg, "usb_ep_set_halt -> %d\n", rc);
 			rc = 0;
 			break;
 		}
 		rc = usb_ep_set_halt(fsg->bulk_in);
 	}
 	return rc;
 }
 static int wedge_bulk_in_endpoint(struct fsg_dev *fsg)
 {
 	int	rc;
 	DBG(fsg, "bulk-in set wedge\n");
 	rc = 0; /* usb_ep_set_wedge(fsg->bulk_in); */
 	if (rc == -EAGAIN)
 		VDBG(fsg, "delayed bulk-in endpoint wedge\n");
 	while (rc != 0) {
 		if (rc != -EAGAIN) {
 			WARNING(fsg, "usb_ep_set_wedge -> %d\n", rc);
 			rc = 0;
 			break;
 		}
 	}
 	return rc;
 }
 static int pad_with_zeros(struct fsg_dev *fsg)
 {
 	struct fsg_buffhd	*bh = fsg->common->next_buffhd_to_fill;
 	u32			nkeep = bh->inreq->length;
 	u32			nsend;
 	int			rc;
 	bh->state = BUF_STATE_EMPTY;		/* For the first iteration */
 	fsg->common->usb_amount_left = nkeep + fsg->common->residue;
 	while (fsg->common->usb_amount_left > 0) {
 		/* Wait for the next buffer to be free */
 		while (bh->state != BUF_STATE_EMPTY) {
 			rc = sleep_thread(fsg->common);
 			if (rc)
 				return rc;
 		}
 		nsend = min(fsg->common->usb_amount_left, FSG_BUFLEN);
 		memset(bh->buf + nkeep, 0, nsend - nkeep);
 		bh->inreq->length = nsend;
 		bh->inreq->zero = 0;
 		start_transfer(fsg, fsg->bulk_in, bh->inreq,
 				&bh->inreq_busy, &bh->state);
 		bh = fsg->common->next_buffhd_to_fill = bh->next;
 		fsg->common->usb_amount_left -= nsend;
 		nkeep = 0;
 	}
 	return 0;
 }
 static int throw_away_data(struct fsg_common *common)
 {
 	struct fsg_buffhd	*bh;
 	u32			amount;
 	int			rc;
 	for (bh = common->next_buffhd_to_drain;
 	     bh->state != BUF_STATE_EMPTY || common->usb_amount_left > 0;
 	     bh = common->next_buffhd_to_drain) {
 		/* Throw away the data in a filled buffer */
 		if (bh->state == BUF_STATE_FULL) {
 			bh->state = BUF_STATE_EMPTY;
 			common->next_buffhd_to_drain = bh->next;
 			/* A short packet or an error ends everything */
 			if (bh->outreq->actual != bh->outreq->length ||
 					bh->outreq->status != 0) {
 				raise_exception(common,
 						FSG_STATE_ABORT_BULK_OUT);
 				return -EINTR;
 			}
 			continue;
 		}
 		/* Try to submit another request if we need one */
 		bh = common->next_buffhd_to_fill;
 		if (bh->state == BUF_STATE_EMPTY
 		 && common->usb_amount_left > 0) {
 			amount = min(common->usb_amount_left, FSG_BUFLEN);
 			/* amount is always divisible by 512, hence by
 			 * the bulk-out maxpacket size */
 			bh->outreq->length = amount;
 			bh->bulk_out_intended_length = amount;
 			bh->outreq->short_not_ok = 1;
 			START_TRANSFER_OR(common, bulk_out, bh->outreq,
 					  &bh->outreq_busy, &bh->state)
 				/* Don't know what to do if
 				 * common->fsg is NULL */
 				return -EIO;
 			common->next_buffhd_to_fill = bh->next;
 			common->usb_amount_left -= amount;
 			continue;
 		}
 		/* Otherwise wait for something to happen */
 		rc = sleep_thread(common);
 		if (rc)
 			return rc;
 	}
 	return 0;
 }
 static int finish_reply(struct fsg_common *common)
 {
 	struct fsg_buffhd	*bh = common->next_buffhd_to_fill;
 	int			rc = 0;
 	switch (common->data_dir) {
 	case DATA_DIR_NONE:
 		break;			/* Nothing to send */
 	/* If we don't know whether the host wants to read or write,
 	 * this must be CB or CBI with an unknown command.  We mustn't
 	 * try to send or receive any data.  So stall both bulk pipes
 	 * if we can and wait for a reset. */
 	case DATA_DIR_UNKNOWN:
 		if (!common->can_stall) {
 			/* Nothing */
 		} else if (fsg_is_set(common)) {
 			fsg_set_halt(common->fsg, common->fsg->bulk_out);
 			rc = halt_bulk_in_endpoint(common->fsg);
 		} else {
 			/* Don't know what to do if common->fsg is NULL */
 			rc = -EIO;
 		}
 		break;
 	/* All but the last buffer of data must have already been sent */
 	case DATA_DIR_TO_HOST:
 		if (common->data_size == 0) {
 			/* Nothing to send */
 		/* If there's no residue, simply send the last buffer */
 		} else if (common->residue == 0) {
 			bh->inreq->zero = 0;
 			START_TRANSFER_OR(common, bulk_in, bh->inreq,
 					  &bh->inreq_busy, &bh->state)
 				return -EIO;
 			common->next_buffhd_to_fill = bh->next;
 		/* For Bulk-only, if we're allowed to stall then send the
 		 * short packet and halt the bulk-in endpoint.  If we can't
 		 * stall, pad out the remaining data with 0's. */
 		} else if (common->can_stall) {
 			bh->inreq->zero = 1;
 			START_TRANSFER_OR(common, bulk_in, bh->inreq,
 					  &bh->inreq_busy, &bh->state)
 				/* Don't know what to do if
 				 * common->fsg is NULL */
 				rc = -EIO;
 			common->next_buffhd_to_fill = bh->next;
 			if (common->fsg)
 				rc = halt_bulk_in_endpoint(common->fsg);
 		} else if (fsg_is_set(common)) {
 			rc = pad_with_zeros(common->fsg);
 		} else {
 			/* Don't know what to do if common->fsg is NULL */
 			rc = -EIO;
 		}
 		break;
 	/* We have processed all we want from the data the host has sent.
 	 * There may still be outstanding bulk-out requests. */
 	case DATA_DIR_FROM_HOST:
 		if (common->residue == 0) {
 			/* Nothing to receive */
 		/* Did the host stop sending unexpectedly early? */
 		} else if (common->short_packet_received) {
 			raise_exception(common, FSG_STATE_ABORT_BULK_OUT);
 			rc = -EINTR;
 		/* We haven't processed all the incoming data.  Even though
 		 * we may be allowed to stall, doing so would cause a race.
 		 * The controller may already have ACK'ed all the remaining
 		 * bulk-out packets, in which case the host wouldn't see a
 		 * STALL.  Not realizing the endpoint was halted, it wouldn't
 		 * clear the halt -- leading to problems later on. */
 #if 0
 		} else if (common->can_stall) {
 			if (fsg_is_set(common))
 				fsg_set_halt(common->fsg,
 					     common->fsg->bulk_out);
 			raise_exception(common, FSG_STATE_ABORT_BULK_OUT);
 			rc = -EINTR;
 #endif
 		/* We can't stall.  Read in the excess data and throw it
 		 * all away. */
 		} else {
 			rc = throw_away_data(common);
 		}
 		break;
 	}
 	return rc;
 }
 static int send_status(struct fsg_common *common)
 {
 	struct fsg_lun		*curlun = &common->luns[common->lun];
 	struct fsg_buffhd	*bh;
 	struct bulk_cs_wrap	*csw;
 	int			rc;
 	u8			status = USB_STATUS_PASS;
 	u32			sd, sdinfo = 0;
 	/* Wait for the next buffer to become available */
 	bh = common->next_buffhd_to_fill;
 	while (bh->state != BUF_STATE_EMPTY) {
 		rc = sleep_thread(common);
 		if (rc)
 			return rc;
 	}
 	if (curlun)
 		sd = curlun->sense_data;
 	else if (common->bad_lun_okay)
 		sd = SS_NO_SENSE;
 	else
 		sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
 	if (common->phase_error) {
 		DBG(common, "sending phase-error status\n");
 		status = USB_STATUS_PHASE_ERROR;
 		sd = SS_INVALID_COMMAND;
 	} else if (sd != SS_NO_SENSE) {
 		DBG(common, "sending command-failure status\n");
 		status = USB_STATUS_FAIL;
 		VDBG(common, "  sense data: SK x%02x, ASC x%02x, ASCQ x%02x;"
 			"  info x%x\n",
 			SK(sd), ASC(sd), ASCQ(sd), sdinfo);
 	}
 	/* Store and send the Bulk-only CSW */
 	csw = (void *)bh->buf;
 	csw->Signature = cpu_to_le32(USB_BULK_CS_SIG);
 	csw->Tag = common->tag;
 	csw->Residue = cpu_to_le32(common->residue);
 	csw->Status = status;
 	bh->inreq->length = USB_BULK_CS_WRAP_LEN;
 	bh->inreq->zero = 0;
 	START_TRANSFER_OR(common, bulk_in, bh->inreq,
 			  &bh->inreq_busy, &bh->state)
 		/* Don't know what to do if common->fsg is NULL */
 		return -EIO;
 	common->next_buffhd_to_fill = bh->next;
 	return 0;
 }
 /*-------------------------------------------------------------------------*/
 /* Check whether the command is properly formed and whether its data size
  * and direction agree with the values we already have. */
 static int check_command(struct fsg_common *common, int cmnd_size,
 		enum data_direction data_dir, unsigned int mask,
 		int needs_medium, const char *name)
 {
 	int			i;
 	int			lun = common->cmnd[1] >> 5;
 	static const char	dirletter[4] = {'u', 'o', 'i', 'n'};
 	char			hdlen[20];
 	struct fsg_lun		*curlun;
 	hdlen[0] = 0;
 	if (common->data_dir != DATA_DIR_UNKNOWN)
 		sprintf(hdlen, ", H%c=%u", dirletter[(int) common->data_dir],
 				common->data_size);
 	VDBG(common, "SCSI command: %s;  Dc=%d, D%c=%u;  Hc=%d%s\n",
 	     name, cmnd_size, dirletter[(int) data_dir],
 	     common->data_size_from_cmnd, common->cmnd_size, hdlen);
 	/* We can't reply at all until we know the correct data direction
 	 * and size. */
 	if (common->data_size_from_cmnd == 0)
 		data_dir = DATA_DIR_NONE;
 	if (common->data_size < common->data_size_from_cmnd) {
 		/* Host data size < Device data size is a phase error.
 		 * Carry out the command, but only transfer as much as
 		 * we are allowed. */
 		common->data_size_from_cmnd = common->data_size;
 		common->phase_error = 1;
 	}
 	common->residue = common->data_size;
 	common->usb_amount_left = common->data_size;
 	/* Conflicting data directions is a phase error */
 	if (common->data_dir != data_dir
 	 && common->data_size_from_cmnd > 0) {
 		common->phase_error = 1;
 		return -EINVAL;
 	}
 	/* Verify the length of the command itself */
 	if (cmnd_size != common->cmnd_size) {
 		/* Special case workaround: There are plenty of buggy SCSI
 		 * implementations. Many have issues with cbw->Length
 		 * field passing a wrong command size. For those cases we
 		 * always try to work around the problem by using the length
 		 * sent by the host side provided it is at least as large
 		 * as the correct command length.
 		 * Examples of such cases would be MS-Windows, which issues
 		 * REQUEST SENSE with cbw->Length == 12 where it should
 		 * be 6, and xbox360 issuing INQUIRY, TEST UNIT READY and
 		 * REQUEST SENSE with cbw->Length == 10 where it should
 		 * be 6 as well.
 		 */
 		if (cmnd_size <= common->cmnd_size) {
 			DBG(common, "%s is buggy! Expected length %d "
 			    "but we got %d\n", name,
 			    cmnd_size, common->cmnd_size);
 			cmnd_size = common->cmnd_size;
 		} else {
 			common->phase_error = 1;
 			return -EINVAL;
 		}
 	}
 	/* Check that the LUN values are consistent */
 	if (common->lun != lun)
 		DBG(common, "using LUN %d from CBW, not LUN %d from CDB\n",
 		    common->lun, lun);
 	/* Check the LUN */
 	if (common->lun >= 0 && common->lun < common->nluns) {
 		curlun = &common->luns[common->lun];
 		if (common->cmnd[0] != SC_REQUEST_SENSE) {
 			curlun->sense_data = SS_NO_SENSE;
 			curlun->info_valid = 0;
 		}
 	} else {
 		curlun = NULL;
 		common->bad_lun_okay = 0;
 		/* INQUIRY and REQUEST SENSE commands are explicitly allowed
 		 * to use unsupported LUNs; all others may not. */
 		if (common->cmnd[0] != SC_INQUIRY &&
 		    common->cmnd[0] != SC_REQUEST_SENSE) {
 			DBG(common, "unsupported LUN %d\n", common->lun);
 			return -EINVAL;
 		}
 	}
 #if 0
 	/* If a unit attention condition exists, only INQUIRY and
 	 * REQUEST SENSE commands are allowed; anything else must fail. */
 	if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
 			common->cmnd[0] != SC_INQUIRY &&
 			common->cmnd[0] != SC_REQUEST_SENSE) {
 		curlun->sense_data = curlun->unit_attention_data;
 		curlun->unit_attention_data = SS_NO_SENSE;
 		return -EINVAL;
 	}
 #endif
 	/* Check that only command bytes listed in the mask are non-zero */
 	common->cmnd[1] &= 0x1f;			/* Mask away the LUN */
 	for (i = 1; i < cmnd_size; ++i) {
 		if (common->cmnd[i] && !(mask & (1 << i))) {
 			if (curlun)
 				curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
 			return -EINVAL;
 		}
 	}
 	return 0;
 }
 static int do_scsi_command(struct fsg_common *common)
 {
 	struct fsg_buffhd	*bh;
 	int			rc;
 	int			reply = -EINVAL;
 	int			i;
 	static char		unknown[16];
 	struct fsg_lun		*curlun = &common->luns[common->lun];
 	dump_cdb(common);
 	/* Wait for the next buffer to become available for data or status */
 	bh = common->next_buffhd_to_fill;
 	common->next_buffhd_to_drain = bh;
 	while (bh->state != BUF_STATE_EMPTY) {
 		rc = sleep_thread(common);
 		if (rc)
 			return rc;
 	}
 	common->phase_error = 0;
 	common->short_packet_received = 0;
 	down_read(&common->filesem);	/* We're using the backing file */
 	switch (common->cmnd[0]) {
 	case SC_INQUIRY:
 		common->data_size_from_cmnd = common->cmnd[4];
 		reply = check_command(common, 6, DATA_DIR_TO_HOST,
 				      (1<<4), 0,
 				      "INQUIRY");
 		if (reply == 0)
 			reply = do_inquiry(common, bh);
 		break;
 	case SC_MODE_SELECT_6:
 		common->data_size_from_cmnd = common->cmnd[4];
 		reply = check_command(common, 6, DATA_DIR_FROM_HOST,
 				      (1<<1) | (1<<4), 0,
 				      "MODE SELECT(6)");
 		if (reply == 0)
 			reply = do_mode_select(common, bh);
 		break;
 	case SC_MODE_SELECT_10:
 		common->data_size_from_cmnd =
 			get_unaligned_be16(&common->cmnd[7]);
 		reply = check_command(common, 10, DATA_DIR_FROM_HOST,
 				      (1<<1) | (3<<7), 0,
 				      "MODE SELECT(10)");
 		if (reply == 0)
 			reply = do_mode_select(common, bh);
 		break;
 	case SC_MODE_SENSE_6:
 		common->data_size_from_cmnd = common->cmnd[4];
 		reply = check_command(common, 6, DATA_DIR_TO_HOST,
 				      (1<<1) | (1<<2) | (1<<4), 0,
 				      "MODE SENSE(6)");
 		if (reply == 0)
 			reply = do_mode_sense(common, bh);
 		break;
 	case SC_MODE_SENSE_10:
 		common->data_size_from_cmnd =
 			get_unaligned_be16(&common->cmnd[7]);
 		reply = check_command(common, 10, DATA_DIR_TO_HOST,
 				      (1<<1) | (1<<2) | (3<<7), 0,
 				      "MODE SENSE(10)");
 		if (reply == 0)
 			reply = do_mode_sense(common, bh);
 		break;
 	case SC_PREVENT_ALLOW_MEDIUM_REMOVAL:
 		common->data_size_from_cmnd = 0;
 		reply = check_command(common, 6, DATA_DIR_NONE,
 				      (1<<4), 0,
 				      "PREVENT-ALLOW MEDIUM REMOVAL");
 		if (reply == 0)
 			reply = do_prevent_allow(common);
 		break;
 	case SC_READ_6:
 		i = common->cmnd[4];
 		common->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
 		reply = check_command(common, 6, DATA_DIR_TO_HOST,
 				      (7<<1) | (1<<4), 1,
 				      "READ(6)");
 		if (reply == 0)
 			reply = do_read(common);
 		break;
 	case SC_READ_10:
 		common->data_size_from_cmnd =
 				get_unaligned_be16(&common->cmnd[7]) << 9;
 		reply = check_command(common, 10, DATA_DIR_TO_HOST,
 				      (1<<1) | (0xf<<2) | (3<<7), 1,
 				      "READ(10)");
 		if (reply == 0)
 			reply = do_read(common);
 		break;
 	case SC_READ_12:
 		common->data_size_from_cmnd =
 				get_unaligned_be32(&common->cmnd[6]) << 9;
 		reply = check_command(common, 12, DATA_DIR_TO_HOST,
 				      (1<<1) | (0xf<<2) | (0xf<<6), 1,
 				      "READ(12)");
 		if (reply == 0)
 			reply = do_read(common);
 		break;
 	case SC_READ_CAPACITY:
 		common->data_size_from_cmnd = 8;
 		reply = check_command(common, 10, DATA_DIR_TO_HOST,
 				      (0xf<<2) | (1<<8), 1,
 				      "READ CAPACITY");
 		if (reply == 0)
 			reply = do_read_capacity(common, bh);
 		break;
 	case SC_READ_HEADER:
 		if (!common->luns[common->lun].cdrom)
 			goto unknown_cmnd;
 		common->data_size_from_cmnd =
 			get_unaligned_be16(&common->cmnd[7]);
 		reply = check_command(common, 10, DATA_DIR_TO_HOST,
 				      (3<<7) | (0x1f<<1), 1,
 				      "READ HEADER");
 		if (reply == 0)
 			reply = do_read_header(common, bh);
 		break;
 	case SC_READ_TOC:
 		if (!common->luns[common->lun].cdrom)
 			goto unknown_cmnd;
 		common->data_size_from_cmnd =
 			get_unaligned_be16(&common->cmnd[7]);
 		reply = check_command(common, 10, DATA_DIR_TO_HOST,
 				      (7<<6) | (1<<1), 1,
 				      "READ TOC");
 		if (reply == 0)
 			reply = do_read_toc(common, bh);
 		break;
 	case SC_READ_FORMAT_CAPACITIES:
 		common->data_size_from_cmnd =
 			get_unaligned_be16(&common->cmnd[7]);
 		reply = check_command(common, 10, DATA_DIR_TO_HOST,
 				      (3<<7), 1,
 				      "READ FORMAT CAPACITIES");
 		if (reply == 0)
 			reply = do_read_format_capacities(common, bh);
 		break;
 	case SC_REQUEST_SENSE:
 		common->data_size_from_cmnd = common->cmnd[4];
 		reply = check_command(common, 6, DATA_DIR_TO_HOST,
 				      (1<<4), 0,
 				      "REQUEST SENSE");
 		if (reply == 0)
 			reply = do_request_sense(common, bh);
 		break;
 	case SC_START_STOP_UNIT:
 		common->data_size_from_cmnd = 0;
 		reply = check_command(common, 6, DATA_DIR_NONE,
 				      (1<<1) | (1<<4), 0,
 				      "START-STOP UNIT");
 		if (reply == 0)
 			reply = do_start_stop(common);
 		break;
 	case SC_SYNCHRONIZE_CACHE:
 		common->data_size_from_cmnd = 0;
 		reply = check_command(common, 10, DATA_DIR_NONE,
 				      (0xf<<2) | (3<<7), 1,
 				      "SYNCHRONIZE CACHE");
 		if (reply == 0)
 			reply = do_synchronize_cache(common);
 		break;
 	case SC_TEST_UNIT_READY:
 		common->data_size_from_cmnd = 0;
 		reply = check_command(common, 6, DATA_DIR_NONE,
 				0, 1,
 				"TEST UNIT READY");
 		break;
 	/* Although optional, this command is used by MS-Windows.  We
 	 * support a minimal version: BytChk must be 0. */
 	case SC_VERIFY:
 		common->data_size_from_cmnd = 0;
 		reply = check_command(common, 10, DATA_DIR_NONE,
 				      (1<<1) | (0xf<<2) | (3<<7), 1,
 				      "VERIFY");
 		if (reply == 0)
 			reply = do_verify(common);
 		break;
 	case SC_WRITE_6:
 		i = common->cmnd[4];
 		common->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
 		reply = check_command(common, 6, DATA_DIR_FROM_HOST,
 				      (7<<1) | (1<<4), 1,
 				      "WRITE(6)");
 		if (reply == 0)
 			reply = do_write(common);
 		break;
 	case SC_WRITE_10:
 		common->data_size_from_cmnd =
 				get_unaligned_be16(&common->cmnd[7]) << 9;
 		reply = check_command(common, 10, DATA_DIR_FROM_HOST,
 				      (1<<1) | (0xf<<2) | (3<<7), 1,
 				      "WRITE(10)");
 		if (reply == 0)
 			reply = do_write(common);
 		break;
 	case SC_WRITE_12:
 		common->data_size_from_cmnd =
 				get_unaligned_be32(&common->cmnd[6]) << 9;
 		reply = check_command(common, 12, DATA_DIR_FROM_HOST,
 				      (1<<1) | (0xf<<2) | (0xf<<6), 1,
 				      "WRITE(12)");
 		if (reply == 0)
 			reply = do_write(common);
 		break;
 	/* Some mandatory commands that we recognize but don't implement.
 	 * They don't mean much in this setting.  It's left as an exercise
 	 * for anyone interested to implement RESERVE and RELEASE in terms
 	 * of Posix locks. */
 	case SC_FORMAT_UNIT:
 	case SC_RELEASE:
 	case SC_RESERVE:
 	case SC_SEND_DIAGNOSTIC:
 		/* Fall through */
 	default:
 unknown_cmnd:
 		common->data_size_from_cmnd = 0;
 		sprintf(unknown, "Unknown x%02x", common->cmnd[0]);
 		reply = check_command(common, common->cmnd_size,
 				      DATA_DIR_UNKNOWN, 0xff, 0, unknown);
 		if (reply == 0) {
 			curlun->sense_data = SS_INVALID_COMMAND;
 			reply = -EINVAL;
 		}
 		break;
 	}
 	up_read(&common->filesem);
 	if (reply == -EINTR)
 		return -EINTR;
 	/* Set up the single reply buffer for finish_reply() */
 	if (reply == -EINVAL)
 		reply = 0;		/* Error reply length */
 	if (reply >= 0 && common->data_dir == DATA_DIR_TO_HOST) {
 		reply = min((u32) reply, common->data_size_from_cmnd);
 		bh->inreq->length = reply;
 		bh->state = BUF_STATE_FULL;
 		common->residue -= reply;
 	}				/* Otherwise it's already set */
 	return 0;
 }
 /*-------------------------------------------------------------------------*/
 static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
 	struct usb_request	*req = bh->outreq;
 	struct fsg_bulk_cb_wrap	*cbw = req->buf;
 	struct fsg_common	*common = fsg->common;
 	/* Was this a real packet?  Should it be ignored? */
 	if (req->status || test_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags))
 		return -EINVAL;
 	/* Is the CBW valid? */
 	if (req->actual != USB_BULK_CB_WRAP_LEN ||
 			cbw->Signature != cpu_to_le32(
 				USB_BULK_CB_SIG)) {
 		DBG(fsg, "invalid CBW: len %u sig 0x%x\n",
 				req->actual,
 				le32_to_cpu(cbw->Signature));
 		/* The Bulk-only spec says we MUST stall the IN endpoint
 		 * (6.6.1), so it's unavoidable.  It also says we must
 		 * retain this state until the next reset, but there's
 		 * no way to tell the controller driver it should ignore
 		 * Clear-Feature(HALT) requests.
 		 *
 		 * We aren't required to halt the OUT endpoint; instead
 		 * we can simply accept and discard any data received
 		 * until the next reset. */
 		wedge_bulk_in_endpoint(fsg);
 		set_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
 		return -EINVAL;
 	}
 	/* Is the CBW meaningful? */
 	if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG ||
 			cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) {
 		DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
 				"cmdlen %u\n",
 				cbw->Lun, cbw->Flags, cbw->Length);
 		/* We can do anything we want here, so let's stall the
 		 * bulk pipes if we are allowed to. */
 		if (common->can_stall) {
 			fsg_set_halt(fsg, fsg->bulk_out);
 			halt_bulk_in_endpoint(fsg);
 		}
 		return -EINVAL;
 	}
 	/* Save the command for later */
 	common->cmnd_size = cbw->Length;
 	memcpy(common->cmnd, cbw->CDB, common->cmnd_size);
 	if (cbw->Flags & USB_BULK_IN_FLAG)
 		common->data_dir = DATA_DIR_TO_HOST;
 	else
 		common->data_dir = DATA_DIR_FROM_HOST;
 	common->data_size = le32_to_cpu(cbw->DataTransferLength);
 	if (common->data_size == 0)
 		common->data_dir = DATA_DIR_NONE;
 	common->lun = cbw->Lun;
 	common->tag = cbw->Tag;
 	return 0;
 }
 static int get_next_command(struct fsg_common *common)
 {
 	struct fsg_buffhd	*bh;
 	int			rc = 0;
 	/* Wait for the next buffer to become available */
 	bh = common->next_buffhd_to_fill;
 	while (bh->state != BUF_STATE_EMPTY) {
 		rc = sleep_thread(common);
 		if (rc)
 			return rc;
 	}
 	/* Queue a request to read a Bulk-only CBW */
 	set_bulk_out_req_length(common, bh, USB_BULK_CB_WRAP_LEN);
 	bh->outreq->short_not_ok = 1;
 	START_TRANSFER_OR(common, bulk_out, bh->outreq,
 			  &bh->outreq_busy, &bh->state)
 		/* Don't know what to do if common->fsg is NULL */
 		return -EIO;
 	/* We will drain the buffer in software, which means we
 	 * can reuse it for the next filling.  No need to advance
 	 * next_buffhd_to_fill. */
 	/* Wait for the CBW to arrive */
 	while (bh->state != BUF_STATE_FULL) {
 		rc = sleep_thread(common);
 		if (rc)
 			return rc;
 	}
 	rc = fsg_is_set(common) ? received_cbw(common->fsg, bh) : -EIO;
 	bh->state = BUF_STATE_EMPTY;
 	return rc;
 }
 /*-------------------------------------------------------------------------*/
 static int enable_endpoint(struct fsg_common *common, struct usb_ep *ep,
 		const struct usb_endpoint_descriptor *d)
 {
 	int	rc;
 	ep->driver_data = common;
 	rc = usb_ep_enable(ep, d);
 	if (rc)
 		ERROR(common, "can't enable %s, result %d\n", ep->name, rc);
 	return rc;
 }
 static int alloc_request(struct fsg_common *common, struct usb_ep *ep,
 		struct usb_request **preq)
 {
 	*preq = usb_ep_alloc_request(ep, GFP_ATOMIC);
 	if (*preq)
 		return 0;
 	ERROR(common, "can't allocate request for %s\n", ep->name);
 	return -ENOMEM;
 }
 /* Reset interface setting and re-init endpoint state (toggle etc). */
 static int do_set_interface(struct fsg_common *common, struct fsg_dev *new_fsg)
 {
 	const struct usb_endpoint_descriptor *d;
 	struct fsg_dev *fsg;
 	int i, rc = 0;
 	if (common->running)
 		DBG(common, "reset interface\n");
 reset:
 	/* Deallocate the requests */
 	if (common->fsg) {
 		fsg = common->fsg;
 		for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
 			struct fsg_buffhd *bh = &common->buffhds[i];
 			if (bh->inreq) {
 				usb_ep_free_request(fsg->bulk_in, bh->inreq);
 				bh->inreq = NULL;
 			}
 			if (bh->outreq) {
 				usb_ep_free_request(fsg->bulk_out, bh->outreq);
 				bh->outreq = NULL;
 			}
 		}
 		/* Disable the endpoints */
 		if (fsg->bulk_in_enabled) {
 			usb_ep_disable(fsg->bulk_in);
 			fsg->bulk_in_enabled = 0;
 		}
 		if (fsg->bulk_out_enabled) {
 			usb_ep_disable(fsg->bulk_out);
 			fsg->bulk_out_enabled = 0;
 		}
 		common->fsg = NULL;
 		/* wake_up(&common->fsg_wait); */
 	}
 	common->running = 0;
 	if (!new_fsg || rc)
 		return rc;
 	common->fsg = new_fsg;
 	fsg = common->fsg;
 	/* Enable the endpoints */
 	d = fsg_ep_desc(common->gadget,
 			&fsg_fs_bulk_in_desc, &fsg_hs_bulk_in_desc);
 	rc = enable_endpoint(common, fsg->bulk_in, d);
 	if (rc)
 		goto reset;
 	fsg->bulk_in_enabled = 1;
 	d = fsg_ep_desc(common->gadget,
 			&fsg_fs_bulk_out_desc, &fsg_hs_bulk_out_desc);
 	rc = enable_endpoint(common, fsg->bulk_out, d);
 	if (rc)
 		goto reset;
 	fsg->bulk_out_enabled = 1;
 	common->bulk_out_maxpacket =
 				le16_to_cpu(get_unaligned(&d->wMaxPacketSize));
 	clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
 	/* Allocate the requests */
 	for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
 		struct fsg_buffhd	*bh = &common->buffhds[i];
 		rc = alloc_request(common, fsg->bulk_in, &bh->inreq);
 		if (rc)
 			goto reset;
 		rc = alloc_request(common, fsg->bulk_out, &bh->outreq);
 		if (rc)
 			goto reset;
 		bh->inreq->buf = bh->outreq->buf = bh->buf;
 		bh->inreq->context = bh->outreq->context = bh;
 		bh->inreq->complete = bulk_in_complete;
 		bh->outreq->complete = bulk_out_complete;
 	}
 	common->running = 1;
 	return rc;
 }
 /****************************** ALT CONFIGS ******************************/
 static int fsg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 {
 	struct fsg_dev *fsg = fsg_from_func(f);
 	fsg->common->new_fsg = fsg;
 	raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
 	return 0;
 }
 static void fsg_disable(struct usb_function *f)
 {
 	struct fsg_dev *fsg = fsg_from_func(f);
 	fsg->common->new_fsg = NULL;
 	raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
 }
 /*-------------------------------------------------------------------------*/
 static void handle_exception(struct fsg_common *common)
 {
 	int			i;
 	struct fsg_buffhd	*bh;
 	enum fsg_state		old_state;
 	struct fsg_lun		*curlun;
 	unsigned int		exception_req_tag;
 	/* Cancel all the pending transfers */
 	if (common->fsg) {
 		for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
 			bh = &common->buffhds[i];
 			if (bh->inreq_busy)
 				usb_ep_dequeue(common->fsg->bulk_in, bh->inreq);
 			if (bh->outreq_busy)
 				usb_ep_dequeue(common->fsg->bulk_out,
 					       bh->outreq);
 		}
 		/* Wait until everything is idle */
 		for (;;) {
 			int num_active = 0;
 			for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
 				bh = &common->buffhds[i];
 				num_active += bh->inreq_busy + bh->outreq_busy;
 			}
 			if (num_active == 0)
 				break;
 			if (sleep_thread(common))
 				return;
 		}
 		/* Clear out the controller's fifos */
 		if (common->fsg->bulk_in_enabled)
 			usb_ep_fifo_flush(common->fsg->bulk_in);
 		if (common->fsg->bulk_out_enabled)
 			usb_ep_fifo_flush(common->fsg->bulk_out);
 	}
 	/* Reset the I/O buffer states and pointers, the SCSI
 	 * state, and the exception.  Then invoke the handler. */
 	for (i = 0; i < FSG_NUM_BUFFERS; ++i) {
 		bh = &common->buffhds[i];
 		bh->state = BUF_STATE_EMPTY;
 	}
 	common->next_buffhd_to_fill = &common->buffhds[0];
 	common->next_buffhd_to_drain = &common->buffhds[0];
 	exception_req_tag = common->exception_req_tag;
 	old_state = common->state;
 	if (old_state == FSG_STATE_ABORT_BULK_OUT)
 		common->state = FSG_STATE_STATUS_PHASE;
 	else {
 		for (i = 0; i < common->nluns; ++i) {
 			curlun = &common->luns[i];
 			curlun->sense_data = SS_NO_SENSE;
 			curlun->info_valid = 0;
 		}
 		common->state = FSG_STATE_IDLE;
 	}
 	/* Carry out any extra actions required for the exception */
 	switch (old_state) {
 	case FSG_STATE_ABORT_BULK_OUT:
 		send_status(common);
 		if (common->state == FSG_STATE_STATUS_PHASE)
 			common->state = FSG_STATE_IDLE;
 		break;
 	case FSG_STATE_RESET:
 		/* In case we were forced against our will to halt a
 		 * bulk endpoint, clear the halt now.  (The SuperH UDC
 		 * requires this.) */
 		if (!fsg_is_set(common))
 			break;
 		if (test_and_clear_bit(IGNORE_BULK_OUT,
 				       &common->fsg->atomic_bitflags))
 			usb_ep_clear_halt(common->fsg->bulk_in);
 		if (common->ep0_req_tag == exception_req_tag)
 			ep0_queue(common);	/* Complete the status stage */
 		break;
 	case FSG_STATE_CONFIG_CHANGE:
 		do_set_interface(common, common->new_fsg);
 		break;
 	case FSG_STATE_EXIT:
 	case FSG_STATE_TERMINATED:
 		do_set_interface(common, NULL);		/* Free resources */
 		common->state = FSG_STATE_TERMINATED;	/* Stop the thread */
 		break;
 	case FSG_STATE_INTERFACE_CHANGE:
 	case FSG_STATE_DISCONNECT:
 	case FSG_STATE_COMMAND_PHASE:
 	case FSG_STATE_DATA_PHASE:
 	case FSG_STATE_STATUS_PHASE:
 	case FSG_STATE_IDLE:
 		break;
 	}
 }
 /*-------------------------------------------------------------------------*/
 int fsg_main_thread(void *common_)
 {
 	int ret;
 	struct fsg_common	*common = the_fsg_common;
 	/* The main loop */
 	do {
 		if (exception_in_progress(common)) {
 			handle_exception(common);
 			continue;
 		}
 		if (!common->running) {
 			ret = sleep_thread(common);
 			if (ret)
 				return ret;
 			continue;
 		}
 		ret = get_next_command(common);
 		if (ret)
 			return ret;
 		if (!exception_in_progress(common))
 			common->state = FSG_STATE_DATA_PHASE;
 		if (do_scsi_command(common) || finish_reply(common))
 			continue;
 		if (!exception_in_progress(common))
 			common->state = FSG_STATE_STATUS_PHASE;
 		if (send_status(common))
 			continue;
 		if (!exception_in_progress(common))
 			common->state = FSG_STATE_IDLE;
 	} while (0);
 	common->thread_task = NULL;
 	return 0;
 }
 static void fsg_common_release(struct kref *ref);
 static struct fsg_common *fsg_common_init(struct fsg_common *common,
 					  struct usb_composite_dev *cdev)
 {
 	struct usb_gadget *gadget = cdev->gadget;
 	struct fsg_buffhd *bh;
 	struct fsg_lun *curlun;
 	int nluns, i, rc;
 	/* Find out how many LUNs there should be */
 	nluns = 1;
 	if (nluns < 1 || nluns > FSG_MAX_LUNS) {
 		printf("invalid number of LUNs: %u\n", nluns);
 		return ERR_PTR(-EINVAL);
 	}
 	/* Allocate? */
 	if (!common) {
 		common = calloc(sizeof(*common), 1);
 		if (!common)
 			return ERR_PTR(-ENOMEM);
 		common->free_storage_on_release = 1;
 	} else {
 		memset(common, 0, sizeof(*common));
 		common->free_storage_on_release = 0;
 	}
 	common->ops = NULL;
 	common->private_data = NULL;
 	common->gadget = gadget;
 	common->ep0 = gadget->ep0;
 	common->ep0req = cdev->req;
 	/* Maybe allocate device-global string IDs, and patch descriptors */
 	if (fsg_strings[FSG_STRING_INTERFACE].id == 0) {
 		rc = usb_string_id(cdev);
 		if (unlikely(rc < 0))
 			goto error_release;
 		fsg_strings[FSG_STRING_INTERFACE].id = rc;
 		fsg_intf_desc.iInterface = rc;
 	}
 	/* Create the LUNs, open their backing files, and register the
 	 * LUN devices in sysfs. */
 	curlun = calloc(nluns, sizeof *curlun);
 	if (!curlun) {
 		rc = -ENOMEM;
 		goto error_release;
 	}
 	common->nluns = nluns;
 	for (i = 0; i < nluns; i++) {
 		common->luns[i].removable = 1;
 		rc = fsg_lun_open(&common->luns[i], "");
 		if (rc)
 			goto error_luns;
 	}
 	common->lun = 0;
 	/* Data buffers cyclic list */
 	bh = common->buffhds;
 	i = FSG_NUM_BUFFERS;
 	goto buffhds_first_it;
 	do {
 		bh->next = bh + 1;
 		++bh;
 buffhds_first_it:
 		bh->inreq_busy = 0;
 		bh->outreq_busy = 0;
 		bh->buf = memalign(CONFIG_SYS_CACHELINE_SIZE, FSG_BUFLEN);
 		if (unlikely(!bh->buf)) {
 			rc = -ENOMEM;
 			goto error_release;
 		}
 	} while (--i);
 	bh->next = common->buffhds;
 	snprintf(common->inquiry_string, sizeof common->inquiry_string,
 		 "%-8s%-16s%04x",
 		 "Linux   ",
 		 "File-Store Gadget",
 		 0xffff);
 	/* Some peripheral controllers are known not to be able to
 	 * halt bulk endpoints correctly.  If one of them is present,
 	 * disable stalls.
 	 */
 	/* Tell the thread to start working */
 	common->thread_task =
 		kthread_create(fsg_main_thread, common,
 			       OR(cfg->thread_name, "file-storage"));
 	if (IS_ERR(common->thread_task)) {
 		rc = PTR_ERR(common->thread_task);
 		goto error_release;
 	}
 #undef OR
 	/* Information */
 	INFO(common, FSG_DRIVER_DESC ", version: " FSG_DRIVER_VERSION "\n");
 	INFO(common, "Number of LUNs=%d\n", common->nluns);
 	return common;
 error_luns:
 	common->nluns = i + 1;
 error_release:
 	common->state = FSG_STATE_TERMINATED;	/* The thread is dead */
 	/* Call fsg_common_release() directly, ref might be not
 	 * initialised */
 	fsg_common_release(&common->ref);
 	return ERR_PTR(rc);
 }
 static void fsg_common_release(struct kref *ref)
 {
 	struct fsg_common *common = container_of(ref, struct fsg_common, ref);
 	/* If the thread isn't already dead, tell it to exit now */
 	if (common->state != FSG_STATE_TERMINATED) {
 		raise_exception(common, FSG_STATE_EXIT);
 		wait_for_completion(&common->thread_notifier);
 	}
 	if (likely(common->luns)) {
 		struct fsg_lun *lun = common->luns;
 		unsigned i = common->nluns;
 		/* In error recovery common->nluns may be zero. */
 		for (; i; --i, ++lun)
 			fsg_lun_close(lun);
 		kfree(common->luns);
 	}
 	{
 		struct fsg_buffhd *bh = common->buffhds;
 		unsigned i = FSG_NUM_BUFFERS;
 		do {
 			kfree(bh->buf);
 		} while (++bh, --i);
 	}
 	if (common->free_storage_on_release)
 		kfree(common);
 }
 /*-------------------------------------------------------------------------*/
 /**
  * usb_copy_descriptors - copy a vector of USB descriptors
  * @src: null-terminated vector to copy
  * Context: initialization code, which may sleep
  *
  * This makes a copy of a vector of USB descriptors.  Its primary use
  * is to support usb_function objects which can have multiple copies,
  * each needing different descriptors.  Functions may have static
  * tables of descriptors, which are used as templates and customized
  * with identifiers (for interfaces, strings, endpoints, and more)
  * as needed by a given function instance.
  */
 struct usb_descriptor_header **
 usb_copy_descriptors(struct usb_descriptor_header **src)
 {
 	struct usb_descriptor_header **tmp;
 	unsigned bytes;
 	unsigned n_desc;
 	void *mem;
 	struct usb_descriptor_header **ret;
 	/* count descriptors and their sizes; then add vector size */
 	for (bytes = 0, n_desc = 0, tmp = src; *tmp; tmp++, n_desc++)
 		bytes += (*tmp)->bLength;
 	bytes += (n_desc + 1) * sizeof(*tmp);
 	mem = memalign(CONFIG_SYS_CACHELINE_SIZE, bytes);
 	if (!mem)
 		return NULL;
 	/* fill in pointers starting at "tmp",
 	 * to descriptors copied starting at "mem";
 	 * and return "ret"
 	 */
 	tmp = mem;
 	ret = mem;
 	mem += (n_desc + 1) * sizeof(*tmp);
 	while (*src) {
 		memcpy(mem, *src, (*src)->bLength);
 		*tmp = mem;
 		tmp++;
 		mem += (*src)->bLength;
 		src++;
 	}
 	*tmp = NULL;
 	return ret;
 }
 static void fsg_unbind(struct usb_configuration *c, struct usb_function *f)
 {
 	struct fsg_dev		*fsg = fsg_from_func(f);
 	DBG(fsg, "unbind\n");
 	if (fsg->common->fsg == fsg) {
 		fsg->common->new_fsg = NULL;
 		raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
 	}
 	free(fsg->function.descriptors);
 	free(fsg->function.hs_descriptors);
 	kfree(fsg);
 }
 static int fsg_bind(struct usb_configuration *c, struct usb_function *f)
 {
 	struct fsg_dev		*fsg = fsg_from_func(f);
 	struct usb_gadget	*gadget = c->cdev->gadget;
 	int			i;
 	struct usb_ep		*ep;
 	fsg->gadget = gadget;
 	/* New interface */
 	i = usb_interface_id(c, f);
 	if (i < 0)
 		return i;
 	fsg_intf_desc.bInterfaceNumber = i;
 	fsg->interface_number = i;
 	/* Find all the endpoints we will use */
 	ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_in_desc);
 	if (!ep)
 		goto autoconf_fail;
 	ep->driver_data = fsg->common;	/* claim the endpoint */
 	fsg->bulk_in = ep;
 	ep = usb_ep_autoconfig(gadget, &fsg_fs_bulk_out_desc);
 	if (!ep)
 		goto autoconf_fail;
 	ep->driver_data = fsg->common;	/* claim the endpoint */
 	fsg->bulk_out = ep;
 	/* Copy descriptors */
 	f->descriptors = usb_copy_descriptors(fsg_fs_function);
 	if (unlikely(!f->descriptors))
 		return -ENOMEM;
 	if (gadget_is_dualspeed(gadget)) {
 		/* Assume endpoint addresses are the same for both speeds */
 		fsg_hs_bulk_in_desc.bEndpointAddress =
 			fsg_fs_bulk_in_desc.bEndpointAddress;
 		fsg_hs_bulk_out_desc.bEndpointAddress =
 			fsg_fs_bulk_out_desc.bEndpointAddress;
 		f->hs_descriptors = usb_copy_descriptors(fsg_hs_function);
 		if (unlikely(!f->hs_descriptors)) {
 			free(f->descriptors);
 			return -ENOMEM;
 		}
 	}
 	return 0;
 autoconf_fail:
 	ERROR(fsg, "unable to autoconfigure all endpoints\n");
 	return -ENOTSUPP;
 }
 /****************************** ADD FUNCTION ******************************/
 static struct usb_gadget_strings *fsg_strings_array[] = {
 	&fsg_stringtab,
 	NULL,
 };
 static int fsg_bind_config(struct usb_composite_dev *cdev,
 			   struct usb_configuration *c,
 			   struct fsg_common *common)
 {
 	struct fsg_dev *fsg;
 	int rc;
 	fsg = calloc(1, sizeof *fsg);
 	if (!fsg)
 		return -ENOMEM;
 	fsg->function.name        = FSG_DRIVER_DESC;
 	fsg->function.strings     = fsg_strings_array;
 	fsg->function.bind        = fsg_bind;
 	fsg->function.unbind      = fsg_unbind;
 	fsg->function.setup       = fsg_setup;
 	fsg->function.set_alt     = fsg_set_alt;
 	fsg->function.disable     = fsg_disable;
 	fsg->common               = common;
 	common->fsg               = fsg;
 	/* Our caller holds a reference to common structure so we
 	 * don't have to be worry about it being freed until we return
 	 * from this function.  So instead of incrementing counter now
 	 * and decrement in error recovery we increment it only when
 	 * call to usb_add_function() was successful. */
 	rc = usb_add_function(c, &fsg->function);
 	if (rc)
 		kfree(fsg);
 	return rc;
 }
 int fsg_add(struct usb_configuration *c)
 {
 	struct fsg_common *fsg_common;
 	fsg_common = fsg_common_init(NULL, c->cdev);
 	fsg_common->vendor_name = 0;
 	fsg_common->product_name = 0;
 	fsg_common->release = 0xffff;
 	fsg_common->ops = NULL;
 	fsg_common->private_data = NULL;
 	the_fsg_common = fsg_common;
 	return fsg_bind_config(c->cdev, c, fsg_common);
 }
 int fsg_init(struct ums *ums_dev)
 {
 	ums = ums_dev;
 	return 0;
 }
 DECLARE_GADGET_BIND_CALLBACK(usb_dnl_ums, fsg_add);

drivers/usb/gadget/f_thor.c

Diff comments View file @ 8a6b088

 /*
  * f_thor.c -- USB TIZEN THOR Downloader gadget function
  *
  * Copyright (C) 2013 Samsung Electronics
  * Lukasz Majewski <l.majewski@samsung.com>
  *
  * Based on code from:
  * git://review.tizen.org/kernel/u-boot
  *
  * Developed by:
  * Copyright (C) 2009 Samsung Electronics
  * Minkyu Kang <mk7.kang@samsung.com>
  * Sanghee Kim <sh0130.kim@samsung.com>
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <errno.h>
 #include <common.h>
 #include <malloc.h>
 #include <version.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/composite.h>
 #include <linux/usb/cdc.h>
 #include <g_dnl.h>
 #include <dfu.h>
 #include "f_thor.h"
 static void thor_tx_data(unsigned char *data, int len);
 static void thor_set_dma(void *addr, int len);
 static int thor_rx_data(void);
 static struct f_thor *thor_func;
 static inline struct f_thor *func_to_thor(struct usb_function *f)
 {
 	return container_of(f, struct f_thor, usb_function);
 }
 DEFINE_CACHE_ALIGN_BUFFER(unsigned char, thor_tx_data_buf,
 			  sizeof(struct rsp_box));
 DEFINE_CACHE_ALIGN_BUFFER(unsigned char, thor_rx_data_buf,
 			  sizeof(struct rqt_box));
 /* ********************************************************** */
 /*         THOR protocol - transmission handling	      */
 /* ********************************************************** */
 DEFINE_CACHE_ALIGN_BUFFER(char, f_name, F_NAME_BUF_SIZE);
 static unsigned long long int thor_file_size;
 static int alt_setting_num;
 static void send_rsp(const struct rsp_box *rsp)
 {
 	memcpy(thor_tx_data_buf, rsp, sizeof(struct rsp_box));
 	thor_tx_data(thor_tx_data_buf, sizeof(struct rsp_box));
 	debug("-RSP: %d, %d\n", rsp->rsp, rsp->rsp_data);
 }
 static void send_data_rsp(s32 ack, s32 count)
 {
 	ALLOC_CACHE_ALIGN_BUFFER(struct data_rsp_box, rsp,
 				 sizeof(struct data_rsp_box));
 	rsp->ack = ack;
 	rsp->count = count;
 	memcpy(thor_tx_data_buf, rsp, sizeof(struct data_rsp_box));
 	thor_tx_data(thor_tx_data_buf, sizeof(struct data_rsp_box));
 	debug("-DATA RSP: %d, %d\n", ack, count);
 }
 static int process_rqt_info(const struct rqt_box *rqt)
 {
 	ALLOC_CACHE_ALIGN_BUFFER(struct rsp_box, rsp, sizeof(struct rsp_box));
 	memset(rsp, 0, sizeof(struct rsp_box));
 	rsp->rsp = rqt->rqt;
 	rsp->rsp_data = rqt->rqt_data;
 	switch (rqt->rqt_data) {
 	case RQT_INFO_VER_PROTOCOL:
 		rsp->int_data[0] = VER_PROTOCOL_MAJOR;
 		rsp->int_data[1] = VER_PROTOCOL_MINOR;
 		break;
 	case RQT_INIT_VER_HW:
 		snprintf(rsp->str_data[0], sizeof(rsp->str_data[0]),
 			 "%x", checkboard());
 		break;
 	case RQT_INIT_VER_BOOT:
 		sprintf(rsp->str_data[0], "%s", U_BOOT_VERSION);
 		break;
 	case RQT_INIT_VER_KERNEL:
 		sprintf(rsp->str_data[0], "%s", "k unknown");
 		break;
 	case RQT_INIT_VER_PLATFORM:
 		sprintf(rsp->str_data[0], "%s", "p unknown");
 		break;
 	case RQT_INIT_VER_CSC:
 		sprintf(rsp->str_data[0], "%s", "c unknown");
 		break;
 	default:
 		return -EINVAL;
 	}
 	send_rsp(rsp);
 	return true;
 }
 static int process_rqt_cmd(const struct rqt_box *rqt)
 {
 	ALLOC_CACHE_ALIGN_BUFFER(struct rsp_box, rsp, sizeof(struct rsp_box));
 	memset(rsp, 0, sizeof(struct rsp_box));
 	rsp->rsp = rqt->rqt;
 	rsp->rsp_data = rqt->rqt_data;
 	switch (rqt->rqt_data) {
 	case RQT_CMD_REBOOT:
 		debug("TARGET RESET\n");
 		send_rsp(rsp);
 		g_dnl_unregister();
 		dfu_free_entities();
 		run_command("reset", 0);
 		break;
 	case RQT_CMD_POWEROFF:
 	case RQT_CMD_EFSCLEAR:
 		send_rsp(rsp);
 	default:
 		printf("Command not supported -> cmd: %d\n", rqt->rqt_data);
 		return -EINVAL;
 	}
 	return true;
 }
 static long long int download_head(unsigned long long total,
 				   unsigned int packet_size,
 				   long long int *left,
 				   int *cnt)
 {
 	long long int rcv_cnt = 0, left_to_rcv, ret_rcv;
 	struct dfu_entity *dfu_entity = dfu_get_entity(alt_setting_num);
 	void *transfer_buffer = dfu_get_buf(dfu_entity);
 	void *buf = transfer_buffer;
 	int usb_pkt_cnt = 0, ret;
 	/*
 	 * Files smaller than THOR_STORE_UNIT_SIZE (now 32 MiB) are stored on
 	 * the medium.
 	 * The packet response is sent on the purpose after successful data
 	 * chunk write. There is a room for improvement when asynchronous write
 	 * is performed.
 	 */
 	while (total - rcv_cnt >= packet_size) {
 		thor_set_dma(buf, packet_size);
 		buf += packet_size;
 		ret_rcv = thor_rx_data();
 		if (ret_rcv < 0)
 			return ret_rcv;
 		rcv_cnt += ret_rcv;
 		debug("%d: RCV data count: %llu cnt: %d\n", usb_pkt_cnt,
 		      rcv_cnt, *cnt);
 		if ((rcv_cnt % THOR_STORE_UNIT_SIZE) == 0) {
 			ret = dfu_write(dfu_get_entity(alt_setting_num),
 					transfer_buffer, THOR_STORE_UNIT_SIZE,
 					(*cnt)++);
 			if (ret) {
 				error("DFU write failed [%d] cnt: %d",
 				      ret, *cnt);
 				return ret;
 			}
 			buf = transfer_buffer;
 		}
 		send_data_rsp(0, ++usb_pkt_cnt);
 	}
 	/* Calculate the amount of data to arrive from PC (in bytes) */
 	left_to_rcv = total - rcv_cnt;
 	/*
 	 * Calculate number of data already received. but not yet stored
 	 * on the medium (they are smaller than THOR_STORE_UNIT_SIZE)
 	 */
 	*left = left_to_rcv + buf - transfer_buffer;
 	debug("%s: left: %llu left_to_rcv: %llu buf: 0x%p\n", __func__,
 	      *left, left_to_rcv, buf);
 	if (left_to_rcv) {
 		thor_set_dma(buf, packet_size);
 		ret_rcv = thor_rx_data();
 		if (ret_rcv < 0)
 			return ret_rcv;
 		rcv_cnt += ret_rcv;
 		send_data_rsp(0, ++usb_pkt_cnt);
 	}
 	debug("%s: %llu total: %llu cnt: %d\n", __func__, rcv_cnt, total, *cnt);
 	return rcv_cnt;
 }
 static int download_tail(long long int left, int cnt)
 {
 	struct dfu_entity *dfu_entity = dfu_get_entity(alt_setting_num);
 	void *transfer_buffer = dfu_get_buf(dfu_entity);
 	int ret;
 	debug("%s: left: %llu cnt: %d\n", __func__, left, cnt);
 	if (left) {
 		ret = dfu_write(dfu_entity, transfer_buffer, left, cnt++);
 		if (ret) {
 			error("DFU write failed [%d]: left: %llu", ret, left);
 			return ret;
 		}
 	}
 	/*
 	 * To store last "packet" or write file from buffer to filesystem
 	 * DFU storage backend requires dfu_flush
 	 *
 	 * This also frees memory malloc'ed by dfu_get_buf(), so no explicit
 	 * need fo call dfu_free_buf() is needed.
 	 */
 	ret = dfu_flush(dfu_entity, transfer_buffer, 0, cnt);
 	if (ret)
 		error("DFU flush failed!");
 	return ret;
 }
 static long long int process_rqt_download(const struct rqt_box *rqt)
 {
 	ALLOC_CACHE_ALIGN_BUFFER(struct rsp_box, rsp, sizeof(struct rsp_box));
 	static long long int left, ret_head;
 	int file_type, ret = 0;
 	static int cnt;
 	memset(rsp, 0, sizeof(struct rsp_box));
 	rsp->rsp = rqt->rqt;
 	rsp->rsp_data = rqt->rqt_data;
 	switch (rqt->rqt_data) {
 	case RQT_DL_INIT:
 		thor_file_size = rqt->int_data[0];
 		debug("INIT: total %d bytes\n", rqt->int_data[0]);
 		break;
 	case RQT_DL_FILE_INFO:
 		file_type = rqt->int_data[0];
 		if (file_type == FILE_TYPE_PIT) {
 			puts("PIT table file - not supported\n");
 			rsp->ack = -ENOTSUPP;
 			ret = rsp->ack;
 			break;
 		}
 		thor_file_size = rqt->int_data[1];
 		memcpy(f_name, rqt->str_data[0], F_NAME_BUF_SIZE);
 		debug("INFO: name(%s, %d), size(%llu), type(%d)\n",
 		      f_name, 0, thor_file_size, file_type);
 		rsp->int_data[0] = THOR_PACKET_SIZE;
 		alt_setting_num = dfu_get_alt(f_name);
 		if (alt_setting_num < 0) {
 			error("Alt setting [%d] to write not found!",
 			      alt_setting_num);
 			rsp->ack = -ENODEV;
 			ret = rsp->ack;
 		}
 		break;
 	case RQT_DL_FILE_START:
 		send_rsp(rsp);
 		ret_head = download_head(thor_file_size, THOR_PACKET_SIZE,
 					 &left, &cnt);
 		if (ret_head < 0) {
 			left = 0;
 			cnt = 0;
 		}
 		return ret_head;
 	case RQT_DL_FILE_END:
 		debug("DL FILE_END\n");
 		rsp->ack = download_tail(left, cnt);
 		ret = rsp->ack;
 		left = 0;
 		cnt = 0;
 		break;
 	case RQT_DL_EXIT:
 		debug("DL EXIT\n");
 		break;
 	default:
 		error("Operation not supported: %d", rqt->rqt_data);
 		ret = -ENOTSUPP;
 	}
 	send_rsp(rsp);
 	return ret;
 }
 static int process_data(void)
 {
 	ALLOC_CACHE_ALIGN_BUFFER(struct rqt_box, rqt, sizeof(struct rqt_box));
 	int ret = -EINVAL;
 	memcpy(rqt, thor_rx_data_buf, sizeof(struct rqt_box));
 	debug("+RQT: %d, %d\n", rqt->rqt, rqt->rqt_data);
 	switch (rqt->rqt) {
 	case RQT_INFO:
 		ret = process_rqt_info(rqt);
 		break;
 	case RQT_CMD:
 		ret = process_rqt_cmd(rqt);
 		break;
 	case RQT_DL:
 		ret = (int) process_rqt_download(rqt);
 		break;
 	case RQT_UL:
 		puts("RQT: UPLOAD not supported!\n");
 		break;
 	default:
 		error("unknown request (%d)", rqt->rqt);
 	}
 	return ret;
 }
 /* ********************************************************** */
 /*         THOR USB Function				      */
 /* ********************************************************** */
 static inline struct usb_endpoint_descriptor *
 ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
 	struct usb_endpoint_descriptor *fs)
 {
 	if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
 		return hs;
 	return fs;
 }
 static struct usb_interface_descriptor thor_downloader_intf_data = {
 	.bLength =		sizeof(thor_downloader_intf_data),
 	.bDescriptorType =	USB_DT_INTERFACE,
 	.bNumEndpoints =	2,
 	.bInterfaceClass =	USB_CLASS_CDC_DATA,
 };
 static struct usb_endpoint_descriptor fs_in_desc = {
 	.bLength =		USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType =	USB_DT_ENDPOINT,
 	.bEndpointAddress =	USB_DIR_IN,
 	.bmAttributes =	USB_ENDPOINT_XFER_BULK,
 };
 static struct usb_endpoint_descriptor fs_out_desc = {
 	.bLength =		USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType =	USB_DT_ENDPOINT,
 	.bEndpointAddress =	USB_DIR_OUT,
 	.bmAttributes =	USB_ENDPOINT_XFER_BULK,
 };
 /* CDC configuration */
 static struct usb_interface_descriptor thor_downloader_intf_int = {
 	.bLength =		sizeof(thor_downloader_intf_int),
 	.bDescriptorType =	USB_DT_INTERFACE,
 	.bNumEndpoints =	1,
 	.bInterfaceClass =	USB_CLASS_COMM,
 	 /* 0x02 Abstract Line Control Model */
 	.bInterfaceSubClass =   USB_CDC_SUBCLASS_ACM,
 	/* 0x01 Common AT commands */
 	.bInterfaceProtocol =   USB_CDC_ACM_PROTO_AT_V25TER,
 };
 static struct usb_cdc_header_desc thor_downloader_cdc_header = {
 	.bLength         =    sizeof(thor_downloader_cdc_header),
 	.bDescriptorType =    0x24, /* CS_INTERFACE */
 	.bDescriptorSubType = 0x00,
 	.bcdCDC =             0x0110,
 };
 static struct usb_cdc_call_mgmt_descriptor thor_downloader_cdc_call = {
 	.bLength         =    sizeof(thor_downloader_cdc_call),
 	.bDescriptorType =    0x24, /* CS_INTERFACE */
 	.bDescriptorSubType = 0x01,
 	.bmCapabilities =     0x00,
 	.bDataInterface =     0x01,
 };
 static struct usb_cdc_acm_descriptor thor_downloader_cdc_abstract = {
 	.bLength         =    sizeof(thor_downloader_cdc_abstract),
 	.bDescriptorType =    0x24, /* CS_INTERFACE */
 	.bDescriptorSubType = 0x02,
 	.bmCapabilities =     0x00,
 };
 static struct usb_cdc_union_desc thor_downloader_cdc_union = {
 	.bLength         =     sizeof(thor_downloader_cdc_union),
 	.bDescriptorType =     0x24, /* CS_INTERFACE */
 	.bDescriptorSubType =  USB_CDC_UNION_TYPE,
 };
 static struct usb_endpoint_descriptor fs_int_desc = {
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
 	.bEndpointAddress = 3 | USB_DIR_IN,
 	.bmAttributes = USB_ENDPOINT_XFER_INT,
 	.wMaxPacketSize = __constant_cpu_to_le16(16),
 	.bInterval = 0x9,
 };
 static struct usb_interface_assoc_descriptor
 thor_iad_descriptor = {
 	.bLength =		sizeof(thor_iad_descriptor),
 	.bDescriptorType =	USB_DT_INTERFACE_ASSOCIATION,
 	.bFirstInterface =	0,
 	.bInterfaceCount =	2,	/* control + data */
 	.bFunctionClass =	USB_CLASS_COMM,
 	.bFunctionSubClass =	USB_CDC_SUBCLASS_ACM,
 	.bFunctionProtocol =	USB_CDC_PROTO_NONE,
 };
 static struct usb_endpoint_descriptor hs_in_desc = {
 	.bLength =		USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType =	USB_DT_ENDPOINT,
 	.bmAttributes =	USB_ENDPOINT_XFER_BULK,
 	.wMaxPacketSize =	__constant_cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor hs_out_desc = {
 	.bLength =		USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType =	USB_DT_ENDPOINT,
 	.bmAttributes =	USB_ENDPOINT_XFER_BULK,
 	.wMaxPacketSize =	__constant_cpu_to_le16(512),
 };
 static struct usb_endpoint_descriptor hs_int_desc = {
 	.bLength = USB_DT_ENDPOINT_SIZE,
 	.bDescriptorType = USB_DT_ENDPOINT,
 	.bmAttributes = USB_ENDPOINT_XFER_INT,
 	.wMaxPacketSize = __constant_cpu_to_le16(16),
 	.bInterval = 0x9,
 };
-static struct usb_qualifier_descriptor dev_qualifier = {
-	.bLength =		sizeof(dev_qualifier),
-	.bDescriptorType =	USB_DT_DEVICE_QUALIFIER,
-	.bcdUSB =		__constant_cpu_to_le16(0x0200),
-	.bDeviceClass =	USB_CLASS_VENDOR_SPEC,
-	.bNumConfigurations =	2,
-};
 /*
  * This attribute vendor descriptor is necessary for correct operation with
  * Windows version of THOR download program
  *
  * It prevents windows driver from sending zero lenght packet (ZLP) after
  * each THOR_PACKET_SIZE. This assures consistent behaviour with libusb
  */
 static struct usb_cdc_attribute_vendor_descriptor thor_downloader_cdc_av = {
 	.bLength =              sizeof(thor_downloader_cdc_av),
 	.bDescriptorType =      0x24,
 	.bDescriptorSubType =   0x80,
 	.DAUType =              0x0002,
 	.DAULength =            0x0001,
 	.DAUValue =             0x00,
 };
 static const struct usb_descriptor_header *hs_thor_downloader_function[] = {
 	(struct usb_descriptor_header *)&thor_iad_descriptor,
 	(struct usb_descriptor_header *)&thor_downloader_intf_int,
 	(struct usb_descriptor_header *)&thor_downloader_cdc_header,
 	(struct usb_descriptor_header *)&thor_downloader_cdc_call,
 	(struct usb_descriptor_header *)&thor_downloader_cdc_abstract,
 	(struct usb_descriptor_header *)&thor_downloader_cdc_union,
 	(struct usb_descriptor_header *)&hs_int_desc,
 	(struct usb_descriptor_header *)&thor_downloader_intf_data,
 	(struct usb_descriptor_header *)&thor_downloader_cdc_av,
 	(struct usb_descriptor_header *)&hs_in_desc,
 	(struct usb_descriptor_header *)&hs_out_desc,
 	NULL,
 };
 /*-------------------------------------------------------------------------*/
 static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
 {
 	struct usb_request *req;
 	req = usb_ep_alloc_request(ep, 0);
 	if (!req)
 		return req;
 	req->length = length;
 	req->buf = memalign(CONFIG_SYS_CACHELINE_SIZE, length);
 	if (!req->buf) {
 		usb_ep_free_request(ep, req);
 		req = NULL;
 	}
 	return req;
 }
 static int thor_rx_data(void)
 {
 	struct thor_dev *dev = thor_func->dev;
 	int data_to_rx, tmp, status;
 	data_to_rx = dev->out_req->length;
 	tmp = data_to_rx;
 	do {
 		dev->out_req->length = data_to_rx;
 		debug("dev->out_req->length:%d dev->rxdata:%d\n",
 		      dev->out_req->length, dev->rxdata);
 		status = usb_ep_queue(dev->out_ep, dev->out_req, 0);
 		if (status) {
 			error("kill %s:  resubmit %d bytes --> %d",
 			      dev->out_ep->name, dev->out_req->length, status);
 			usb_ep_set_halt(dev->out_ep);
 			return -EAGAIN;
 		}
 		while (!dev->rxdata) {
 			usb_gadget_handle_interrupts();
 			if (ctrlc())
 				return -1;
 		}
 		dev->rxdata = 0;
 		data_to_rx -= dev->out_req->actual;
 	} while (data_to_rx);
 	return tmp;
 }
 static void thor_tx_data(unsigned char *data, int len)
 {
 	struct thor_dev *dev = thor_func->dev;
 	unsigned char *ptr = dev->in_req->buf;
 	int status;
 	memset(ptr, 0, len);
 	memcpy(ptr, data, len);
 	dev->in_req->length = len;
 	debug("%s: dev->in_req->length:%d to_cpy:%d\n", __func__,
 	      dev->in_req->length, sizeof(data));
 	status = usb_ep_queue(dev->in_ep, dev->in_req, 0);
 	if (status) {
 		error("kill %s:  resubmit %d bytes --> %d",
 		      dev->in_ep->name, dev->in_req->length, status);
 		usb_ep_set_halt(dev->in_ep);
 	}
 	/* Wait until tx interrupt received */
 	while (!dev->txdata)
 		usb_gadget_handle_interrupts();
 	dev->txdata = 0;
 }
 static void thor_rx_tx_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	struct thor_dev *dev = thor_func->dev;
 	int status = req->status;
 	debug("%s: ep_ptr:%p, req_ptr:%p\n", __func__, ep, req);
 	switch (status) {
 	case 0:
 		if (ep == dev->out_ep)
 			dev->rxdata = 1;
 		else
 			dev->txdata = 1;
 		break;
 	/* this endpoint is normally active while we're configured */
 	case -ECONNABORTED:		/* hardware forced ep reset */
 	case -ECONNRESET:		/* request dequeued */
 	case -ESHUTDOWN:		/* disconnect from host */
 	case -EREMOTEIO:                /* short read */
 	case -EOVERFLOW:
 		error("ERROR:%d", status);
 		break;
 	}
 	debug("%s complete --> %d, %d/%d\n", ep->name,
 	      status, req->actual, req->length);
 }
 static struct usb_request *thor_start_ep(struct usb_ep *ep)
 {
 	struct usb_request *req;
 	req = alloc_ep_req(ep, THOR_PACKET_SIZE);
 	debug("%s: ep:%p req:%p\n", __func__, ep, req);
 	if (!req)
 		return NULL;
 	memset(req->buf, 0, req->length);
 	req->complete = thor_rx_tx_complete;
 	return req;
 }
 static void thor_setup_complete(struct usb_ep *ep, struct usb_request *req)
 {
 	if (req->status || req->actual != req->length)
 		debug("setup complete --> %d, %d/%d\n",
 		      req->status, req->actual, req->length);
 }
 static int
 thor_func_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 {
 	struct thor_dev *dev = thor_func->dev;
 	struct usb_request *req = dev->req;
 	struct usb_gadget *gadget = dev->gadget;
 	int value = 0;
 	u16 len = le16_to_cpu(ctrl->wLength);
 	debug("Req_Type: 0x%x Req: 0x%x wValue: 0x%x wIndex: 0x%x wLen: 0x%x\n",
 	      ctrl->bRequestType, ctrl->bRequest, ctrl->wValue, ctrl->wIndex,
 	      ctrl->wLength);
 	switch (ctrl->bRequest) {
 	case USB_CDC_REQ_SET_CONTROL_LINE_STATE:
 		value = 0;
 		break;
 	case USB_CDC_REQ_SET_LINE_CODING:
 		value = len;
 		/* Line Coding set done = configuration done */
 		thor_func->dev->configuration_done = 1;
 		break;
 	default:
 		error("thor_setup: unknown request: %d", ctrl->bRequest);
 	}
 	if (value >= 0) {
 		req->length = value;
 		req->zero = value < len;
 		value = usb_ep_queue(gadget->ep0, req, 0);
 		if (value < 0) {
 			debug("%s: ep_queue: %d\n", __func__, value);
 			req->status = 0;
 		}
 	}
 	return value;
 }
 /* Specific to the THOR protocol */
 static void thor_set_dma(void *addr, int len)
 {
 	struct thor_dev *dev = thor_func->dev;
 	debug("in_req:%p, out_req:%p\n", dev->in_req, dev->out_req);
 	debug("addr:%p, len:%d\n", addr, len);
 	dev->out_req->buf = addr;
 	dev->out_req->length = len;
 }
 int thor_init(void)
 {
 	struct thor_dev *dev = thor_func->dev;
 	/* Wait for a device enumeration and configuration settings */
 	debug("THOR enumeration/configuration setting....\n");
 	while (!dev->configuration_done)
 		usb_gadget_handle_interrupts();
 	thor_set_dma(thor_rx_data_buf, strlen("THOR"));
 	/* detect the download request from Host PC */
 	if (thor_rx_data() < 0) {
 		printf("%s: Data not received!\n", __func__);
 		return -1;
 	}
 	if (!strncmp((char *)thor_rx_data_buf, "THOR", strlen("THOR"))) {
 		puts("Download request from the Host PC\n");
 		udelay(30 * 1000); /* 30 ms */
 		strcpy((char *)thor_tx_data_buf, "ROHT");
 		thor_tx_data(thor_tx_data_buf, strlen("ROHT"));
 	} else {
 		puts("Wrong reply information\n");
 		return -1;
 	}
 	return 0;
 }
 int thor_handle(void)
 {
 	int ret;
 	/* receive the data from Host PC */
 	while (1) {
 		thor_set_dma(thor_rx_data_buf, sizeof(struct rqt_box));
 		ret = thor_rx_data();
 		if (ret > 0) {
 			ret = process_data();
 			if (ret < 0)
 				return ret;
 		} else {
 			printf("%s: No data received!\n", __func__);
 			break;
 		}
 	}
 	return 0;
 }
 static int thor_func_bind(struct usb_configuration *c, struct usb_function *f)
 {
 	struct usb_gadget *gadget = c->cdev->gadget;
 	struct f_thor *f_thor = func_to_thor(f);
 	struct thor_dev *dev;
 	struct usb_ep *ep;
 	int status;
 	thor_func = f_thor;
 	dev = memalign(CONFIG_SYS_CACHELINE_SIZE, sizeof(*dev));
 	if (!dev)
 		return -ENOMEM;
 	memset(dev, 0, sizeof(*dev));
 	dev->gadget = gadget;
 	f_thor->dev = dev;
 	debug("%s: usb_configuration: 0x%p usb_function: 0x%p\n",
 	      __func__, c, f);
 	debug("f_thor: 0x%p thor: 0x%p\n", f_thor, dev);
 	/* EP0  */
 	/* preallocate control response and buffer */
 	dev->req = usb_ep_alloc_request(gadget->ep0, 0);
 	if (!dev->req) {
 		status = -ENOMEM;
 		goto fail;
 	}
 	dev->req->buf = memalign(CONFIG_SYS_CACHELINE_SIZE,
 				 gadget->ep0->maxpacket);
 	if (!dev->req->buf) {
 		status = -ENOMEM;
 		goto fail;
 	}
 	dev->req->complete = thor_setup_complete;
 	/* DYNAMIC interface numbers assignments */
 	status = usb_interface_id(c, f);
 	if (status < 0)
 		goto fail;
 	thor_downloader_intf_int.bInterfaceNumber = status;
 	thor_downloader_cdc_union.bMasterInterface0 = status;
 	status = usb_interface_id(c, f);
 	if (status < 0)
 		goto fail;
 	thor_downloader_intf_data.bInterfaceNumber = status;
 	thor_downloader_cdc_union.bSlaveInterface0 = status;
 	/* allocate instance-specific endpoints */
 	ep = usb_ep_autoconfig(gadget, &fs_in_desc);
 	if (!ep) {
 		status = -ENODEV;
 		goto fail;
 	}
 	if (gadget_is_dualspeed(gadget)) {
 		hs_in_desc.bEndpointAddress =
 				fs_in_desc.bEndpointAddress;
 	}
 	dev->in_ep = ep; /* Store IN EP for enabling @ setup */
 	ep = usb_ep_autoconfig(gadget, &fs_out_desc);
 	if (!ep) {
 		status = -ENODEV;
 		goto fail;
 	}
 	if (gadget_is_dualspeed(gadget))
 		hs_out_desc.bEndpointAddress =
 				fs_out_desc.bEndpointAddress;
 	dev->out_ep = ep; /* Store OUT EP for enabling @ setup */
 	ep = usb_ep_autoconfig(gadget, &fs_int_desc);
 	if (!ep) {
 		status = -ENODEV;
 		goto fail;
 	}
 	dev->int_ep = ep;
 	if (gadget_is_dualspeed(gadget)) {
 		hs_int_desc.bEndpointAddress =
 				fs_int_desc.bEndpointAddress;
 		f->hs_descriptors = (struct usb_descriptor_header **)
 			&hs_thor_downloader_function;
 		if (!f->hs_descriptors)
 			goto fail;
 	}
 	debug("%s: out_ep:%p out_req:%p\n", __func__,
 	      dev->out_ep, dev->out_req);
 	return 0;
  fail:
 	free(dev);
 	return status;
 }
 static void free_ep_req(struct usb_ep *ep, struct usb_request *req)
 {
 	free(req->buf);
 	usb_ep_free_request(ep, req);
 }
 static void thor_unbind(struct usb_configuration *c, struct usb_function *f)
 {
 	struct f_thor *f_thor = func_to_thor(f);
 	struct thor_dev *dev = f_thor->dev;
 	free(dev);
 	memset(thor_func, 0, sizeof(*thor_func));
 	thor_func = NULL;
 }
 static void thor_func_disable(struct usb_function *f)
 {
 	struct f_thor *f_thor = func_to_thor(f);
 	struct thor_dev *dev = f_thor->dev;
 	debug("%s:\n", __func__);
 	/* Avoid freeing memory when ep is still claimed */
 	if (dev->in_ep->driver_data) {
 		free_ep_req(dev->in_ep, dev->in_req);
 		usb_ep_disable(dev->in_ep);
 		dev->in_ep->driver_data = NULL;
 	}
 	if (dev->out_ep->driver_data) {
 		dev->out_req->buf = NULL;
 		usb_ep_free_request(dev->out_ep, dev->out_req);
 		usb_ep_disable(dev->out_ep);
 		dev->out_ep->driver_data = NULL;
 	}
 	if (dev->int_ep->driver_data) {
 		usb_ep_disable(dev->int_ep);
 		dev->int_ep->driver_data = NULL;
 	}
 }
 static int thor_eps_setup(struct usb_function *f)
 {
 	struct usb_composite_dev *cdev = f->config->cdev;
 	struct usb_gadget *gadget = cdev->gadget;
 	struct thor_dev *dev = thor_func->dev;
 	struct usb_endpoint_descriptor *d;
 	struct usb_request *req;
 	struct usb_ep *ep;
 	int result;
 	ep = dev->in_ep;
 	d = ep_desc(gadget, &hs_in_desc, &fs_in_desc);
 	debug("(d)bEndpointAddress: 0x%x\n", d->bEndpointAddress);
 	result = usb_ep_enable(ep, d);
 	if (result)
 		goto exit;
 	ep->driver_data = cdev; /* claim */
 	req = thor_start_ep(ep);
 	if (!req) {
 		usb_ep_disable(ep);
 		result = -EIO;
 		goto exit;
 	}
 	dev->in_req = req;
 	ep = dev->out_ep;
 	d = ep_desc(gadget, &hs_out_desc, &fs_out_desc);
 	debug("(d)bEndpointAddress: 0x%x\n", d->bEndpointAddress);
 	result = usb_ep_enable(ep, d);
 	if (result)
 		goto exit;
 	ep->driver_data = cdev; /* claim */
 	req = thor_start_ep(ep);
 	if (!req) {
 		usb_ep_disable(ep);
 		result = -EIO;
 		goto exit;
 	}
 	dev->out_req = req;
 	/* ACM control EP */
 	ep = dev->int_ep;
 	ep->driver_data = cdev;	/* claim */
  exit:
 	return result;
 }
 static int thor_func_set_alt(struct usb_function *f,
 			     unsigned intf, unsigned alt)
 {
 	struct thor_dev *dev = thor_func->dev;
 	int result;
 	debug("%s: func: %s intf: %d alt: %d\n",
 	      __func__, f->name, intf, alt);
 	switch (intf) {
 	case 0:
 		debug("ACM INTR interface\n");
 		break;
 	case 1:
 		debug("Communication Data interface\n");
 		result = thor_eps_setup(f);
 		if (result)
 			error("%s: EPs setup failed!", __func__);
 		dev->configuration_done = 1;
 		break;
 	}
 	return 0;
 }
 static int thor_func_init(struct usb_configuration *c)
 {
 	struct f_thor *f_thor;
 	int status;
 	debug("%s: cdev: 0x%p\n", __func__, c->cdev);
 	f_thor = memalign(CONFIG_SYS_CACHELINE_SIZE, sizeof(*f_thor));
 	if (!f_thor)
 		return -ENOMEM;
 	memset(f_thor, 0, sizeof(*f_thor));
 	f_thor->usb_function.name = "f_thor";
 	f_thor->usb_function.bind = thor_func_bind;
 	f_thor->usb_function.unbind = thor_unbind;
 	f_thor->usb_function.setup = thor_func_setup;
 	f_thor->usb_function.set_alt = thor_func_set_alt;
 	f_thor->usb_function.disable = thor_func_disable;
 	status = usb_add_function(c, &f_thor->usb_function);
 	if (status)
 		free(f_thor);
 	return status;
 }
 int thor_add(struct usb_configuration *c)
 {
 	debug("%s:\n", __func__);
 	return thor_func_init(c);
 }
 DECLARE_GADGET_BIND_CALLBACK(usb_dnl_thor, thor_add);

drivers/usb/host/ehci-hcd.c

Diff comments View file @ 8a6b088

 /*-
  * Copyright (c) 2007-2008, Juniper Networks, Inc.
  * Copyright (c) 2008, Excito Elektronik i Skåne AB
  * Copyright (c) 2008, Michael Trimarchi <trimarchimichael@yahoo.it>
  *
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation version 2 of
  * the License.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  * MA 02111-1307 USA
  */
 #include <common.h>
 #include <errno.h>
 #include <asm/byteorder.h>
 #include <asm/unaligned.h>
 #include <usb.h>
 #include <asm/io.h>
 #include <malloc.h>
 #include <watchdog.h>
 #include <linux/compiler.h>
 #include "ehci.h"
 #ifndef CONFIG_USB_MAX_CONTROLLER_COUNT
 #define CONFIG_USB_MAX_CONTROLLER_COUNT 1
 #endif
 /*
  * EHCI spec page 20 says that the HC may take up to 16 uFrames (= 4ms) to halt.
  * Let's time out after 8 to have a little safety margin on top of that.
  */
 #define HCHALT_TIMEOUT (8 * 1000)
 static struct ehci_ctrl ehcic[CONFIG_USB_MAX_CONTROLLER_COUNT];
 #define ALIGN_END_ADDR(type, ptr, size)			\
 	((uint32_t)(ptr) + roundup((size) * sizeof(type), USB_DMA_MINALIGN))
 static struct descriptor {
 	struct usb_hub_descriptor hub;
 	struct usb_device_descriptor device;
 	struct usb_linux_config_descriptor config;
 	struct usb_linux_interface_descriptor interface;
 	struct usb_endpoint_descriptor endpoint;
 }  __attribute__ ((packed)) descriptor = {
 	{
 		0x8,		/* bDescLength */
 		0x29,		/* bDescriptorType: hub descriptor */
 		2,		/* bNrPorts -- runtime modified */
 		0,		/* wHubCharacteristics */
 		10,		/* bPwrOn2PwrGood */
 		0,		/* bHubCntrCurrent */
 		{},		/* Device removable */
 		{}		/* at most 7 ports! XXX */
 	},
 	{
 		0x12,		/* bLength */
 		1,		/* bDescriptorType: UDESC_DEVICE */
 		cpu_to_le16(0x0200), /* bcdUSB: v2.0 */
 		9,		/* bDeviceClass: UDCLASS_HUB */
 		0,		/* bDeviceSubClass: UDSUBCLASS_HUB */
 		1,		/* bDeviceProtocol: UDPROTO_HSHUBSTT */
 		64,		/* bMaxPacketSize: 64 bytes */
 		0x0000,		/* idVendor */
 		0x0000,		/* idProduct */
 		cpu_to_le16(0x0100), /* bcdDevice */
 		1,		/* iManufacturer */
 		2,		/* iProduct */
 		0,		/* iSerialNumber */
 		1		/* bNumConfigurations: 1 */
 	},
 	{
 		0x9,
 		2,		/* bDescriptorType: UDESC_CONFIG */
 		cpu_to_le16(0x19),
 		1,		/* bNumInterface */
 		1,		/* bConfigurationValue */
 		0,		/* iConfiguration */
 		0x40,		/* bmAttributes: UC_SELF_POWER */
 		0		/* bMaxPower */
 	},
 	{
 		0x9,		/* bLength */
 		4,		/* bDescriptorType: UDESC_INTERFACE */
 		0,		/* bInterfaceNumber */
 		0,		/* bAlternateSetting */
 		1,		/* bNumEndpoints */
 		9,		/* bInterfaceClass: UICLASS_HUB */
 		0,		/* bInterfaceSubClass: UISUBCLASS_HUB */
 		0,		/* bInterfaceProtocol: UIPROTO_HSHUBSTT */
 		0		/* iInterface */
 	},
 	{
 		0x7,		/* bLength */
 		5,		/* bDescriptorType: UDESC_ENDPOINT */
 		0x81,		/* bEndpointAddress:
 				 * UE_DIR_IN | EHCI_INTR_ENDPT
 				 */
 		3,		/* bmAttributes: UE_INTERRUPT */
 		8,		/* wMaxPacketSize */
 		255		/* bInterval */
 	},
 };
 #if defined(CONFIG_EHCI_IS_TDI)
 #define ehci_is_TDI()	(1)
 #else
 #define ehci_is_TDI()	(0)
 #endif
 int __ehci_get_port_speed(struct ehci_hcor *hcor, uint32_t reg)
 {
 	return PORTSC_PSPD(reg);
 }
 int ehci_get_port_speed(struct ehci_hcor *hcor, uint32_t reg)
 	__attribute__((weak, alias("__ehci_get_port_speed")));
 void __ehci_set_usbmode(int index)
 {
 	uint32_t tmp;
 	uint32_t *reg_ptr;
 	reg_ptr = (uint32_t *)((u8 *)&ehcic[index].hcor->or_usbcmd + USBMODE);
 	tmp = ehci_readl(reg_ptr);
 	tmp |= USBMODE_CM_HC;
 #if defined(CONFIG_EHCI_MMIO_BIG_ENDIAN)
 	tmp |= USBMODE_BE;
 #endif
 	ehci_writel(reg_ptr, tmp);
 }
 void ehci_set_usbmode(int index)
 	__attribute__((weak, alias("__ehci_set_usbmode")));
 void __ehci_powerup_fixup(uint32_t *status_reg, uint32_t *reg)
 {
 	mdelay(50);
 }
 void ehci_powerup_fixup(uint32_t *status_reg, uint32_t *reg)
 	__attribute__((weak, alias("__ehci_powerup_fixup")));
 static int handshake(uint32_t *ptr, uint32_t mask, uint32_t done, int usec)
 {
 	uint32_t result;
 	do {
 		result = ehci_readl(ptr);
 		udelay(5);
 		if (result == ~(uint32_t)0)
 			return -1;
 		result &= mask;
 		if (result == done)
 			return 0;
 		usec--;
 	} while (usec > 0);
 	return -1;
 }
 static int ehci_reset(int index)
 {
 	uint32_t cmd;
 	int ret = 0;
 	cmd = ehci_readl(&ehcic[index].hcor->or_usbcmd);
 	cmd = (cmd & ~CMD_RUN) | CMD_RESET;
 	ehci_writel(&ehcic[index].hcor->or_usbcmd, cmd);
 	ret = handshake((uint32_t *)&ehcic[index].hcor->or_usbcmd,
 			CMD_RESET, 0, 250 * 1000);
 	if (ret < 0) {
 		printf("EHCI fail to reset\n");
 		goto out;
 	}
 	if (ehci_is_TDI())
 		ehci_set_usbmode(index);
 #ifdef CONFIG_USB_EHCI_TXFIFO_THRESH
 	cmd = ehci_readl(&ehcic[index].hcor->or_txfilltuning);
 	cmd &= ~TXFIFO_THRESH_MASK;
 	cmd |= TXFIFO_THRESH(CONFIG_USB_EHCI_TXFIFO_THRESH);
 	ehci_writel(&ehcic[index].hcor->or_txfilltuning, cmd);
 #endif
 out:
 	return ret;
 }
 static int ehci_shutdown(struct ehci_ctrl *ctrl)
 {
 	int i, ret = 0;
 	uint32_t cmd, reg;
 	if (!ctrl || !ctrl->hcor)
 		return -EINVAL;
 	cmd = ehci_readl(&ctrl->hcor->or_usbcmd);
 	cmd &= ~(CMD_PSE | CMD_ASE);
 	ehci_writel(&ctrl->hcor->or_usbcmd, cmd);
 	ret = handshake(&ctrl->hcor->or_usbsts, STS_ASS | STS_PSS, 0,
 		100 * 1000);
 	if (!ret) {
 		for (i = 0; i < CONFIG_SYS_USB_EHCI_MAX_ROOT_PORTS; i++) {
 			reg = ehci_readl(&ctrl->hcor->or_portsc[i]);
 			reg |= EHCI_PS_SUSP;
 			ehci_writel(&ctrl->hcor->or_portsc[i], reg);
 		}
 		cmd &= ~CMD_RUN;
 		ehci_writel(&ctrl->hcor->or_usbcmd, cmd);
 		ret = handshake(&ctrl->hcor->or_usbsts, STS_HALT, STS_HALT,
 			HCHALT_TIMEOUT);
 	}
 	if (ret)
 		puts("EHCI failed to shut down host controller.\n");
 	return ret;
 }
 static int ehci_td_buffer(struct qTD *td, void *buf, size_t sz)
 {
 	uint32_t delta, next;
 	uint32_t addr = (uint32_t)buf;
 	int idx;
 	if (addr != ALIGN(addr, ARCH_DMA_MINALIGN))
 		debug("EHCI-HCD: Misaligned buffer address (%p)\n", buf);
 	flush_dcache_range(addr, ALIGN(addr + sz, ARCH_DMA_MINALIGN));
 	idx = 0;
 	while (idx < QT_BUFFER_CNT) {
 		td->qt_buffer[idx] = cpu_to_hc32(addr);
 		td->qt_buffer_hi[idx] = 0;
 		next = (addr + EHCI_PAGE_SIZE) & ~(EHCI_PAGE_SIZE - 1);
 		delta = next - addr;
 		if (delta >= sz)
 			break;
 		sz -= delta;
 		addr = next;
 		idx++;
 	}
 	if (idx == QT_BUFFER_CNT) {
 		printf("out of buffer pointers (%u bytes left)\n", sz);
 		return -1;
 	}
 	return 0;
 }
 static inline u8 ehci_encode_speed(enum usb_device_speed speed)
 {
 	#define QH_HIGH_SPEED	2
 	#define QH_FULL_SPEED	0
 	#define QH_LOW_SPEED	1
 	if (speed == USB_SPEED_HIGH)
 		return QH_HIGH_SPEED;
 	if (speed == USB_SPEED_LOW)
 		return QH_LOW_SPEED;
 	return QH_FULL_SPEED;
 }
+static void ehci_update_endpt2_dev_n_port(struct usb_device *dev,
+					  struct QH *qh)
+{
+	struct usb_device *ttdev;
+	if (dev->speed != USB_SPEED_LOW && dev->speed != USB_SPEED_FULL)
+		return;
+	/*
+	 * For full / low speed devices we need to get the devnum and portnr of
+	 * the tt, so of the first upstream usb-2 hub, there may be usb-1 hubs
+	 * in the tree before that one!
+	 */
+	ttdev = dev;
+	while (ttdev->parent && ttdev->parent->speed != USB_SPEED_HIGH)
+		ttdev = ttdev->parent;
+	if (!ttdev->parent)
+		return;
+	qh->qh_endpt2 |= cpu_to_hc32(QH_ENDPT2_PORTNUM(ttdev->portnr) |
+				     QH_ENDPT2_HUBADDR(ttdev->parent->devnum));
+}
 static int
 ehci_submit_async(struct usb_device *dev, unsigned long pipe, void *buffer,
 		   int length, struct devrequest *req)
 {
 	ALLOC_ALIGN_BUFFER(struct QH, qh, 1, USB_DMA_MINALIGN);
 	struct qTD *qtd;
 	int qtd_count = 0;
 	int qtd_counter = 0;
 	volatile struct qTD *vtd;
 	unsigned long ts;
 	uint32_t *tdp;
 	uint32_t endpt, maxpacket, token, usbsts;
 	uint32_t c, toggle;
 	uint32_t cmd;
 	int timeout;
 	int ret = 0;
 	struct ehci_ctrl *ctrl = dev->controller;
 	debug("dev=%p, pipe=%lx, buffer=%p, length=%d, req=%p\n", dev, pipe,
 	      buffer, length, req);
 	if (req != NULL)
 		debug("req=%u (%#x), type=%u (%#x), value=%u (%#x), index=%u\n",
 		      req->request, req->request,
 		      req->requesttype, req->requesttype,
 		      le16_to_cpu(req->value), le16_to_cpu(req->value),
 		      le16_to_cpu(req->index));
 #define PKT_ALIGN	512
 	/*
 	 * The USB transfer is split into qTD transfers. Eeach qTD transfer is
 	 * described by a transfer descriptor (the qTD). The qTDs form a linked
 	 * list with a queue head (QH).
 	 *
 	 * Each qTD transfer starts with a new USB packet, i.e. a packet cannot
 	 * have its beginning in a qTD transfer and its end in the following
 	 * one, so the qTD transfer lengths have to be chosen accordingly.
 	 *
 	 * Each qTD transfer uses up to QT_BUFFER_CNT data buffers, mapped to
 	 * single pages. The first data buffer can start at any offset within a
 	 * page (not considering the cache-line alignment issues), while the
 	 * following buffers must be page-aligned. There is no alignment
 	 * constraint on the size of a qTD transfer.
 	 */
 	if (req != NULL)
 		/* 1 qTD will be needed for SETUP, and 1 for ACK. */
 		qtd_count += 1 + 1;
 	if (length > 0 || req == NULL) {
 		/*
 		 * Determine the qTD transfer size that will be used for the
 		 * data payload (not considering the first qTD transfer, which
 		 * may be longer or shorter, and the final one, which may be
 		 * shorter).
 		 *
 		 * In order to keep each packet within a qTD transfer, the qTD
 		 * transfer size is aligned to PKT_ALIGN, which is a multiple of
 		 * wMaxPacketSize (except in some cases for interrupt transfers,
 		 * see comment in submit_int_msg()).
 		 *
 		 * By default, i.e. if the input buffer is aligned to PKT_ALIGN,
 		 * QT_BUFFER_CNT full pages will be used.
 		 */
 		int xfr_sz = QT_BUFFER_CNT;
 		/*
 		 * However, if the input buffer is not aligned to PKT_ALIGN, the
 		 * qTD transfer size will be one page shorter, and the first qTD
 		 * data buffer of each transfer will be page-unaligned.
 		 */
 		if ((uint32_t)buffer & (PKT_ALIGN - 1))
 			xfr_sz--;
 		/* Convert the qTD transfer size to bytes. */
 		xfr_sz *= EHCI_PAGE_SIZE;
 		/*
 		 * Approximate by excess the number of qTDs that will be
 		 * required for the data payload. The exact formula is way more
 		 * complicated and saves at most 2 qTDs, i.e. a total of 128
 		 * bytes.
 		 */
 		qtd_count += 2 + length / xfr_sz;
 	}
 /*
  * Threshold value based on the worst-case total size of the allocated qTDs for
  * a mass-storage transfer of 65535 blocks of 512 bytes.
  */
 #if CONFIG_SYS_MALLOC_LEN <= 64 + 128 * 1024
 #warning CONFIG_SYS_MALLOC_LEN may be too small for EHCI
 #endif
 	qtd = memalign(USB_DMA_MINALIGN, qtd_count * sizeof(struct qTD));
 	if (qtd == NULL) {
 		printf("unable to allocate TDs\n");
 		return -1;
 	}
 	memset(qh, 0, sizeof(struct QH));
 	memset(qtd, 0, qtd_count * sizeof(*qtd));
 	toggle = usb_gettoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
 	/*
 	 * Setup QH (3.6 in ehci-r10.pdf)
 	 *
 	 *   qh_link ................. 03-00 H
 	 *   qh_endpt1 ............... 07-04 H
 	 *   qh_endpt2 ............... 0B-08 H
 	 * - qh_curtd
 	 *   qh_overlay.qt_next ...... 13-10 H
 	 * - qh_overlay.qt_altnext
 	 */
 	qh->qh_link = cpu_to_hc32((uint32_t)&ctrl->qh_list | QH_LINK_TYPE_QH);
 	c = (dev->speed != USB_SPEED_HIGH) && !usb_pipeendpoint(pipe);
 	maxpacket = usb_maxpacket(dev, pipe);
 	endpt = QH_ENDPT1_RL(8) | QH_ENDPT1_C(c) |
 		QH_ENDPT1_MAXPKTLEN(maxpacket) | QH_ENDPT1_H(0) |
 		QH_ENDPT1_DTC(QH_ENDPT1_DTC_DT_FROM_QTD) |
 		QH_ENDPT1_EPS(ehci_encode_speed(dev->speed)) |
 		QH_ENDPT1_ENDPT(usb_pipeendpoint(pipe)) | QH_ENDPT1_I(0) |
 		QH_ENDPT1_DEVADDR(usb_pipedevice(pipe));
 	qh->qh_endpt1 = cpu_to_hc32(endpt);
-	endpt = QH_ENDPT2_MULT(1) | QH_ENDPT2_PORTNUM(dev->portnr) |
+	endpt = QH_ENDPT2_MULT(1) | QH_ENDPT2_UFCMASK(0) | QH_ENDPT2_UFSMASK(0);
-		QH_ENDPT2_HUBADDR(dev->parent->devnum) |
-		QH_ENDPT2_UFCMASK(0) | QH_ENDPT2_UFSMASK(0);
 	qh->qh_endpt2 = cpu_to_hc32(endpt);
+	ehci_update_endpt2_dev_n_port(dev, qh);
 	qh->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
 	qh->qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
 	tdp = &qh->qh_overlay.qt_next;
 	if (req != NULL) {
 		/*
 		 * Setup request qTD (3.5 in ehci-r10.pdf)
 		 *
 		 *   qt_next ................ 03-00 H
 		 *   qt_altnext ............. 07-04 H
 		 *   qt_token ............... 0B-08 H
 		 *
 		 *   [ buffer, buffer_hi ] loaded with "req".
 		 */
 		qtd[qtd_counter].qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
 		qtd[qtd_counter].qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
 		token = QT_TOKEN_DT(0) | QT_TOKEN_TOTALBYTES(sizeof(*req)) |
 			QT_TOKEN_IOC(0) | QT_TOKEN_CPAGE(0) | QT_TOKEN_CERR(3) |
 			QT_TOKEN_PID(QT_TOKEN_PID_SETUP) |
 			QT_TOKEN_STATUS(QT_TOKEN_STATUS_ACTIVE);
 		qtd[qtd_counter].qt_token = cpu_to_hc32(token);
 		if (ehci_td_buffer(&qtd[qtd_counter], req, sizeof(*req))) {
 			printf("unable to construct SETUP TD\n");
 			goto fail;
 		}
 		/* Update previous qTD! */
 		*tdp = cpu_to_hc32((uint32_t)&qtd[qtd_counter]);
 		tdp = &qtd[qtd_counter++].qt_next;
 		toggle = 1;
 	}
 	if (length > 0 || req == NULL) {
 		uint8_t *buf_ptr = buffer;
 		int left_length = length;
 		do {
 			/*
 			 * Determine the size of this qTD transfer. By default,
 			 * QT_BUFFER_CNT full pages can be used.
 			 */
 			int xfr_bytes = QT_BUFFER_CNT * EHCI_PAGE_SIZE;
 			/*
 			 * However, if the input buffer is not page-aligned, the
 			 * portion of the first page before the buffer start
 			 * offset within that page is unusable.
 			 */
 			xfr_bytes -= (uint32_t)buf_ptr & (EHCI_PAGE_SIZE - 1);
 			/*
 			 * In order to keep each packet within a qTD transfer,
 			 * align the qTD transfer size to PKT_ALIGN.
 			 */
 			xfr_bytes &= ~(PKT_ALIGN - 1);
 			/*
 			 * This transfer may be shorter than the available qTD
 			 * transfer size that has just been computed.
 			 */
 			xfr_bytes = min(xfr_bytes, left_length);
 			/*
 			 * Setup request qTD (3.5 in ehci-r10.pdf)
 			 *
 			 *   qt_next ................ 03-00 H
 			 *   qt_altnext ............. 07-04 H
 			 *   qt_token ............... 0B-08 H
 			 *
 			 *   [ buffer, buffer_hi ] loaded with "buffer".
 			 */
 			qtd[qtd_counter].qt_next =
 					cpu_to_hc32(QT_NEXT_TERMINATE);
 			qtd[qtd_counter].qt_altnext =
 					cpu_to_hc32(QT_NEXT_TERMINATE);
 			token = QT_TOKEN_DT(toggle) |
 				QT_TOKEN_TOTALBYTES(xfr_bytes) |
 				QT_TOKEN_IOC(req == NULL) | QT_TOKEN_CPAGE(0) |
 				QT_TOKEN_CERR(3) |
 				QT_TOKEN_PID(usb_pipein(pipe) ?
 					QT_TOKEN_PID_IN : QT_TOKEN_PID_OUT) |
 				QT_TOKEN_STATUS(QT_TOKEN_STATUS_ACTIVE);
 			qtd[qtd_counter].qt_token = cpu_to_hc32(token);
 			if (ehci_td_buffer(&qtd[qtd_counter], buf_ptr,
 						xfr_bytes)) {
 				printf("unable to construct DATA TD\n");
 				goto fail;
 			}
 			/* Update previous qTD! */
 			*tdp = cpu_to_hc32((uint32_t)&qtd[qtd_counter]);
 			tdp = &qtd[qtd_counter++].qt_next;
 			/*
 			 * Data toggle has to be adjusted since the qTD transfer
 			 * size is not always an even multiple of
 			 * wMaxPacketSize.
 			 */
 			if ((xfr_bytes / maxpacket) & 1)
 				toggle ^= 1;
 			buf_ptr += xfr_bytes;
 			left_length -= xfr_bytes;
 		} while (left_length > 0);
 	}
 	if (req != NULL) {
 		/*
 		 * Setup request qTD (3.5 in ehci-r10.pdf)
 		 *
 		 *   qt_next ................ 03-00 H
 		 *   qt_altnext ............. 07-04 H
 		 *   qt_token ............... 0B-08 H
 		 */
 		qtd[qtd_counter].qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
 		qtd[qtd_counter].qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
 		token = QT_TOKEN_DT(1) | QT_TOKEN_TOTALBYTES(0) |
 			QT_TOKEN_IOC(1) | QT_TOKEN_CPAGE(0) | QT_TOKEN_CERR(3) |
 			QT_TOKEN_PID(usb_pipein(pipe) ?
 				QT_TOKEN_PID_OUT : QT_TOKEN_PID_IN) |
 			QT_TOKEN_STATUS(QT_TOKEN_STATUS_ACTIVE);
 		qtd[qtd_counter].qt_token = cpu_to_hc32(token);
 		/* Update previous qTD! */
 		*tdp = cpu_to_hc32((uint32_t)&qtd[qtd_counter]);
 		tdp = &qtd[qtd_counter++].qt_next;
 	}
 	ctrl->qh_list.qh_link = cpu_to_hc32((uint32_t)qh | QH_LINK_TYPE_QH);
 	/* Flush dcache */
 	flush_dcache_range((uint32_t)&ctrl->qh_list,
 		ALIGN_END_ADDR(struct QH, &ctrl->qh_list, 1));
 	flush_dcache_range((uint32_t)qh, ALIGN_END_ADDR(struct QH, qh, 1));
 	flush_dcache_range((uint32_t)qtd,
 			   ALIGN_END_ADDR(struct qTD, qtd, qtd_count));
 	/* Set async. queue head pointer. */
 	ehci_writel(&ctrl->hcor->or_asynclistaddr, (uint32_t)&ctrl->qh_list);
 	usbsts = ehci_readl(&ctrl->hcor->or_usbsts);
 	ehci_writel(&ctrl->hcor->or_usbsts, (usbsts & 0x3f));
 	/* Enable async. schedule. */
 	cmd = ehci_readl(&ctrl->hcor->or_usbcmd);
 	cmd |= CMD_ASE;
 	ehci_writel(&ctrl->hcor->or_usbcmd, cmd);
 	ret = handshake((uint32_t *)&ctrl->hcor->or_usbsts, STS_ASS, STS_ASS,
 			100 * 1000);
 	if (ret < 0) {
 		printf("EHCI fail timeout STS_ASS set\n");
 		goto fail;
 	}
 	/* Wait for TDs to be processed. */
 	ts = get_timer(0);
 	vtd = &qtd[qtd_counter - 1];
 	timeout = USB_TIMEOUT_MS(pipe);
 	do {
 		/* Invalidate dcache */
 		invalidate_dcache_range((uint32_t)&ctrl->qh_list,
 			ALIGN_END_ADDR(struct QH, &ctrl->qh_list, 1));
 		invalidate_dcache_range((uint32_t)qh,
 			ALIGN_END_ADDR(struct QH, qh, 1));
 		invalidate_dcache_range((uint32_t)qtd,
 			ALIGN_END_ADDR(struct qTD, qtd, qtd_count));
 		token = hc32_to_cpu(vtd->qt_token);
 		if (!(QT_TOKEN_GET_STATUS(token) & QT_TOKEN_STATUS_ACTIVE))
 			break;
 		WATCHDOG_RESET();
 	} while (get_timer(ts) < timeout);
 	/*
 	 * Invalidate the memory area occupied by buffer
 	 * Don't try to fix the buffer alignment, if it isn't properly
 	 * aligned it's upper layer's fault so let invalidate_dcache_range()
 	 * vow about it. But we have to fix the length as it's actual
 	 * transfer length and can be unaligned. This is potentially
 	 * dangerous operation, it's responsibility of the calling
 	 * code to make sure enough space is reserved.
 	 */
 	invalidate_dcache_range((uint32_t)buffer,
 		ALIGN((uint32_t)buffer + length, ARCH_DMA_MINALIGN));
 	/* Check that the TD processing happened */
 	if (QT_TOKEN_GET_STATUS(token) & QT_TOKEN_STATUS_ACTIVE)
 		printf("EHCI timed out on TD - token=%#x\n", token);
 	/* Disable async schedule. */
 	cmd = ehci_readl(&ctrl->hcor->or_usbcmd);
 	cmd &= ~CMD_ASE;
 	ehci_writel(&ctrl->hcor->or_usbcmd, cmd);
 	ret = handshake((uint32_t *)&ctrl->hcor->or_usbsts, STS_ASS, 0,
 			100 * 1000);
 	if (ret < 0) {
 		printf("EHCI fail timeout STS_ASS reset\n");
 		goto fail;
 	}
 	token = hc32_to_cpu(qh->qh_overlay.qt_token);
 	if (!(QT_TOKEN_GET_STATUS(token) & QT_TOKEN_STATUS_ACTIVE)) {
 		debug("TOKEN=%#x\n", token);
 		switch (QT_TOKEN_GET_STATUS(token) &
 			~(QT_TOKEN_STATUS_SPLITXSTATE | QT_TOKEN_STATUS_PERR)) {
 		case 0:
 			toggle = QT_TOKEN_GET_DT(token);
 			usb_settoggle(dev, usb_pipeendpoint(pipe),
 				       usb_pipeout(pipe), toggle);
 			dev->status = 0;
 			break;
 		case QT_TOKEN_STATUS_HALTED:
 			dev->status = USB_ST_STALLED;
 			break;
 		case QT_TOKEN_STATUS_ACTIVE | QT_TOKEN_STATUS_DATBUFERR:
 		case QT_TOKEN_STATUS_DATBUFERR:
 			dev->status = USB_ST_BUF_ERR;
 			break;
 		case QT_TOKEN_STATUS_HALTED | QT_TOKEN_STATUS_BABBLEDET:
 		case QT_TOKEN_STATUS_BABBLEDET:
 			dev->status = USB_ST_BABBLE_DET;
 			break;
 		default:
 			dev->status = USB_ST_CRC_ERR;
 			if (QT_TOKEN_GET_STATUS(token) & QT_TOKEN_STATUS_HALTED)
 				dev->status |= USB_ST_STALLED;
 			break;
 		}
 		dev->act_len = length - QT_TOKEN_GET_TOTALBYTES(token);
 	} else {
 		dev->act_len = 0;
 #ifndef CONFIG_USB_EHCI_FARADAY
 		debug("dev=%u, usbsts=%#x, p[1]=%#x, p[2]=%#x\n",
 		      dev->devnum, ehci_readl(&ctrl->hcor->or_usbsts),
 		      ehci_readl(&ctrl->hcor->or_portsc[0]),
 		      ehci_readl(&ctrl->hcor->or_portsc[1]));
 #endif
 	}
 	free(qtd);
 	return (dev->status != USB_ST_NOT_PROC) ? 0 : -1;
 fail:
 	free(qtd);
 	return -1;
 }
 __weak uint32_t *ehci_get_portsc_register(struct ehci_hcor *hcor, int port)
 {
 	if (port < 0 || port >= CONFIG_SYS_USB_EHCI_MAX_ROOT_PORTS) {
 		/* Printing the message would cause a scan failure! */
 		debug("The request port(%u) is not configured\n", port);
 		return NULL;
 	}
 	return (uint32_t *)&hcor->or_portsc[port];
 }
 int
 ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *buffer,
 		 int length, struct devrequest *req)
 {
 	uint8_t tmpbuf[4];
 	u16 typeReq;
 	void *srcptr = NULL;
 	int len, srclen;
 	uint32_t reg;
 	uint32_t *status_reg;
 	int port = le16_to_cpu(req->index) & 0xff;
 	struct ehci_ctrl *ctrl = dev->controller;
 	srclen = 0;
 	debug("req=%u (%#x), type=%u (%#x), value=%u, index=%u\n",
 	      req->request, req->request,
 	      req->requesttype, req->requesttype,
 	      le16_to_cpu(req->value), le16_to_cpu(req->index));
 	typeReq = req->request | req->requesttype << 8;
 	switch (typeReq) {
 	case USB_REQ_GET_STATUS | ((USB_RT_PORT | USB_DIR_IN) << 8):
 	case USB_REQ_SET_FEATURE | ((USB_DIR_OUT | USB_RT_PORT) << 8):
 	case USB_REQ_CLEAR_FEATURE | ((USB_DIR_OUT | USB_RT_PORT) << 8):
 		status_reg = ehci_get_portsc_register(ctrl->hcor, port - 1);
 		if (!status_reg)
 			return -1;
 		break;
 	default:
 		status_reg = NULL;
 		break;
 	}
 	switch (typeReq) {
 	case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
 		switch (le16_to_cpu(req->value) >> 8) {
 		case USB_DT_DEVICE:
 			debug("USB_DT_DEVICE request\n");
 			srcptr = &descriptor.device;
 			srclen = descriptor.device.bLength;
 			break;
 		case USB_DT_CONFIG:
 			debug("USB_DT_CONFIG config\n");
 			srcptr = &descriptor.config;
 			srclen = descriptor.config.bLength +
 					descriptor.interface.bLength +
 					descriptor.endpoint.bLength;
 			break;
 		case USB_DT_STRING:
 			debug("USB_DT_STRING config\n");
 			switch (le16_to_cpu(req->value) & 0xff) {
 			case 0:	/* Language */
 				srcptr = "\4\3\1\0";
 				srclen = 4;
 				break;
 			case 1:	/* Vendor */
 				srcptr = "\16\3u\0-\0b\0o\0o\0t\0";
 				srclen = 14;
 				break;
 			case 2:	/* Product */
 				srcptr = "\52\3E\0H\0C\0I\0 "
 					 "\0H\0o\0s\0t\0 "
 					 "\0C\0o\0n\0t\0r\0o\0l\0l\0e\0r\0";
 				srclen = 42;
 				break;
 			default:
 				debug("unknown value DT_STRING %x\n",
 					le16_to_cpu(req->value));
 				goto unknown;
 			}
 			break;
 		default:
 			debug("unknown value %x\n", le16_to_cpu(req->value));
 			goto unknown;
 		}
 		break;
 	case USB_REQ_GET_DESCRIPTOR | ((USB_DIR_IN | USB_RT_HUB) << 8):
 		switch (le16_to_cpu(req->value) >> 8) {
 		case USB_DT_HUB:
 			debug("USB_DT_HUB config\n");
 			srcptr = &descriptor.hub;
 			srclen = descriptor.hub.bLength;
 			break;
 		default:
 			debug("unknown value %x\n", le16_to_cpu(req->value));
 			goto unknown;
 		}
 		break;
 	case USB_REQ_SET_ADDRESS | (USB_RECIP_DEVICE << 8):
 		debug("USB_REQ_SET_ADDRESS\n");
 		ctrl->rootdev = le16_to_cpu(req->value);
 		break;
 	case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
 		debug("USB_REQ_SET_CONFIGURATION\n");
 		/* Nothing to do */
 		break;
 	case USB_REQ_GET_STATUS | ((USB_DIR_IN | USB_RT_HUB) << 8):
 		tmpbuf[0] = 1;	/* USB_STATUS_SELFPOWERED */
 		tmpbuf[1] = 0;
 		srcptr = tmpbuf;
 		srclen = 2;
 		break;
 	case USB_REQ_GET_STATUS | ((USB_RT_PORT | USB_DIR_IN) << 8):
 		memset(tmpbuf, 0, 4);
 		reg = ehci_readl(status_reg);
 		if (reg & EHCI_PS_CS)
 			tmpbuf[0] |= USB_PORT_STAT_CONNECTION;
 		if (reg & EHCI_PS_PE)
 			tmpbuf[0] |= USB_PORT_STAT_ENABLE;
 		if (reg & EHCI_PS_SUSP)
 			tmpbuf[0] |= USB_PORT_STAT_SUSPEND;
 		if (reg & EHCI_PS_OCA)
 			tmpbuf[0] |= USB_PORT_STAT_OVERCURRENT;
 		if (reg & EHCI_PS_PR)
 			tmpbuf[0] |= USB_PORT_STAT_RESET;
 		if (reg & EHCI_PS_PP)
 			tmpbuf[1] |= USB_PORT_STAT_POWER >> 8;
 		if (ehci_is_TDI()) {
 			switch (ehci_get_port_speed(ctrl->hcor, reg)) {
 			case PORTSC_PSPD_FS:
 				break;
 			case PORTSC_PSPD_LS:
 				tmpbuf[1] |= USB_PORT_STAT_LOW_SPEED >> 8;
 				break;
 			case PORTSC_PSPD_HS:
 			default:
 				tmpbuf[1] |= USB_PORT_STAT_HIGH_SPEED >> 8;
 				break;
 			}
 		} else {
 			tmpbuf[1] |= USB_PORT_STAT_HIGH_SPEED >> 8;
 		}
 		if (reg & EHCI_PS_CSC)
 			tmpbuf[2] |= USB_PORT_STAT_C_CONNECTION;
 		if (reg & EHCI_PS_PEC)
 			tmpbuf[2] |= USB_PORT_STAT_C_ENABLE;
 		if (reg & EHCI_PS_OCC)
 			tmpbuf[2] |= USB_PORT_STAT_C_OVERCURRENT;
 		if (ctrl->portreset & (1 << port))
 			tmpbuf[2] |= USB_PORT_STAT_C_RESET;
 		srcptr = tmpbuf;
 		srclen = 4;
 		break;
 	case USB_REQ_SET_FEATURE | ((USB_DIR_OUT | USB_RT_PORT) << 8):
 		reg = ehci_readl(status_reg);
 		reg &= ~EHCI_PS_CLEAR;
 		switch (le16_to_cpu(req->value)) {
 		case USB_PORT_FEAT_ENABLE:
 			reg |= EHCI_PS_PE;
 			ehci_writel(status_reg, reg);
 			break;
 		case USB_PORT_FEAT_POWER:
 			if (HCS_PPC(ehci_readl(&ctrl->hccr->cr_hcsparams))) {
 				reg |= EHCI_PS_PP;
 				ehci_writel(status_reg, reg);
 			}
 			break;
 		case USB_PORT_FEAT_RESET:
 			if ((reg & (EHCI_PS_PE | EHCI_PS_CS)) == EHCI_PS_CS &&
 			    !ehci_is_TDI() &&
 			    EHCI_PS_IS_LOWSPEED(reg)) {
 				/* Low speed device, give up ownership. */
 				debug("port %d low speed --> companion\n",
 				      port - 1);
 				reg |= EHCI_PS_PO;
 				ehci_writel(status_reg, reg);
 				break;
 			} else {
 				int ret;
 				reg |= EHCI_PS_PR;
 				reg &= ~EHCI_PS_PE;
 				ehci_writel(status_reg, reg);
 				/*
 				 * caller must wait, then call GetPortStatus
 				 * usb 2.0 specification say 50 ms resets on
 				 * root
 				 */
 				ehci_powerup_fixup(status_reg, &reg);
 				ehci_writel(status_reg, reg & ~EHCI_PS_PR);
 				/*
 				 * A host controller must terminate the reset
 				 * and stabilize the state of the port within
 				 * 2 milliseconds
 				 */
 				ret = handshake(status_reg, EHCI_PS_PR, 0,
 						2 * 1000);
 				if (!ret)
 					ctrl->portreset |= 1 << port;
 				else
 					printf("port(%d) reset error\n",
 					       port - 1);
 			}
 			break;
 		case USB_PORT_FEAT_TEST:
 			ehci_shutdown(ctrl);
 			reg &= ~(0xf << 16);
 			reg |= ((le16_to_cpu(req->index) >> 8) & 0xf) << 16;
 			ehci_writel(status_reg, reg);
 			break;
 		default:
 			debug("unknown feature %x\n", le16_to_cpu(req->value));
 			goto unknown;
 		}
 		/* unblock posted writes */
 		(void) ehci_readl(&ctrl->hcor->or_usbcmd);
 		break;
 	case USB_REQ_CLEAR_FEATURE | ((USB_DIR_OUT | USB_RT_PORT) << 8):
 		reg = ehci_readl(status_reg);
 		reg &= ~EHCI_PS_CLEAR;
 		switch (le16_to_cpu(req->value)) {
 		case USB_PORT_FEAT_ENABLE:
 			reg &= ~EHCI_PS_PE;
 			break;
 		case USB_PORT_FEAT_C_ENABLE:
 			reg |= EHCI_PS_PE;
 			break;
 		case USB_PORT_FEAT_POWER:
 			if (HCS_PPC(ehci_readl(&ctrl->hccr->cr_hcsparams)))
 				reg &= ~EHCI_PS_PP;
 			break;
 		case USB_PORT_FEAT_C_CONNECTION:
 			reg |= EHCI_PS_CSC;
 			break;
 		case USB_PORT_FEAT_OVER_CURRENT:
 			reg |= EHCI_PS_OCC;
 			break;
 		case USB_PORT_FEAT_C_RESET:
 			ctrl->portreset &= ~(1 << port);
 			break;
 		default:
 			debug("unknown feature %x\n", le16_to_cpu(req->value));
 			goto unknown;
 		}
 		ehci_writel(status_reg, reg);
 		/* unblock posted write */
 		(void) ehci_readl(&ctrl->hcor->or_usbcmd);
 		break;
 	default:
 		debug("Unknown request\n");
 		goto unknown;
 	}
 	mdelay(1);
 	len = min3(srclen, le16_to_cpu(req->length), length);
 	if (srcptr != NULL && len > 0)
 		memcpy(buffer, srcptr, len);
 	else
 		debug("Len is 0\n");
 	dev->act_len = len;
 	dev->status = 0;
 	return 0;
 unknown:
 	debug("requesttype=%x, request=%x, value=%x, index=%x, length=%x\n",
 	      req->requesttype, req->request, le16_to_cpu(req->value),
 	      le16_to_cpu(req->index), le16_to_cpu(req->length));
 	dev->act_len = 0;
 	dev->status = USB_ST_STALLED;
 	return -1;
 }
 int usb_lowlevel_stop(int index)
 {
 	ehci_shutdown(&ehcic[index]);
 	return ehci_hcd_stop(index);
 }
 int usb_lowlevel_init(int index, enum usb_init_type init, void **controller)
 {
 	uint32_t reg;
 	uint32_t cmd;
 	struct QH *qh_list;
 	struct QH *periodic;
 	int i;
 	int rc;
 	rc = ehci_hcd_init(index, init, &ehcic[index].hccr, &ehcic[index].hcor);
 	if (rc)
 		return rc;
 	if (init == USB_INIT_DEVICE)
 		goto done;
 	/* EHCI spec section 4.1 */
 	if (ehci_reset(index))
 		return -1;
 #if defined(CONFIG_EHCI_HCD_INIT_AFTER_RESET)
 	rc = ehci_hcd_init(index, init, &ehcic[index].hccr, &ehcic[index].hcor);
 	if (rc)
 		return rc;
 #endif
 	/* Set the high address word (aka segment) for 64-bit controller */
 	if (ehci_readl(&ehcic[index].hccr->cr_hccparams) & 1)
 		ehci_writel(&ehcic[index].hcor->or_ctrldssegment, 0);
 	qh_list = &ehcic[index].qh_list;
 	/* Set head of reclaim list */
 	memset(qh_list, 0, sizeof(*qh_list));
 	qh_list->qh_link = cpu_to_hc32((uint32_t)qh_list | QH_LINK_TYPE_QH);
 	qh_list->qh_endpt1 = cpu_to_hc32(QH_ENDPT1_H(1) |
 						QH_ENDPT1_EPS(USB_SPEED_HIGH));
 	qh_list->qh_curtd = cpu_to_hc32(QT_NEXT_TERMINATE);
 	qh_list->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
 	qh_list->qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
 	qh_list->qh_overlay.qt_token =
 			cpu_to_hc32(QT_TOKEN_STATUS(QT_TOKEN_STATUS_HALTED));
 	flush_dcache_range((uint32_t)qh_list,
 			   ALIGN_END_ADDR(struct QH, qh_list, 1));
 	/* Set async. queue head pointer. */
 	ehci_writel(&ehcic[index].hcor->or_asynclistaddr, (uint32_t)qh_list);
 	/*
 	 * Set up periodic list
 	 * Step 1: Parent QH for all periodic transfers.
 	 */
+	ehcic[index].periodic_schedules = 0;
 	periodic = &ehcic[index].periodic_queue;
 	memset(periodic, 0, sizeof(*periodic));
 	periodic->qh_link = cpu_to_hc32(QH_LINK_TERMINATE);
 	periodic->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
 	periodic->qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
 	flush_dcache_range((uint32_t)periodic,
 			   ALIGN_END_ADDR(struct QH, periodic, 1));
 	/*
 	 * Step 2: Setup frame-list: Every microframe, USB tries the same list.
 	 *         In particular, device specifications on polling frequency
 	 *         are disregarded. Keyboards seem to send NAK/NYet reliably
 	 *         when polled with an empty buffer.
 	 *
 	 *         Split Transactions will be spread across microframes using
 	 *         S-mask and C-mask.
 	 */
 	if (ehcic[index].periodic_list == NULL)
 		ehcic[index].periodic_list = memalign(4096, 1024 * 4);
 	if (!ehcic[index].periodic_list)
 		return -ENOMEM;
 	for (i = 0; i < 1024; i++) {
 		ehcic[index].periodic_list[i] = cpu_to_hc32((uint32_t)periodic
 						| QH_LINK_TYPE_QH);
 	}
 	flush_dcache_range((uint32_t)ehcic[index].periodic_list,
 			   ALIGN_END_ADDR(uint32_t, ehcic[index].periodic_list,
 					  1024));
 	/* Set periodic list base address */
 	ehci_writel(&ehcic[index].hcor->or_periodiclistbase,
 		(uint32_t)ehcic[index].periodic_list);
 	reg = ehci_readl(&ehcic[index].hccr->cr_hcsparams);
 	descriptor.hub.bNbrPorts = HCS_N_PORTS(reg);
 	debug("Register %x NbrPorts %d\n", reg, descriptor.hub.bNbrPorts);
 	/* Port Indicators */
 	if (HCS_INDICATOR(reg))
 		put_unaligned(get_unaligned(&descriptor.hub.wHubCharacteristics)
 				| 0x80, &descriptor.hub.wHubCharacteristics);
 	/* Port Power Control */
 	if (HCS_PPC(reg))
 		put_unaligned(get_unaligned(&descriptor.hub.wHubCharacteristics)
 				| 0x01, &descriptor.hub.wHubCharacteristics);
 	/* Start the host controller. */
 	cmd = ehci_readl(&ehcic[index].hcor->or_usbcmd);
 	/*
 	 * Philips, Intel, and maybe others need CMD_RUN before the
 	 * root hub will detect new devices (why?); NEC doesn't
 	 */
 	cmd &= ~(CMD_LRESET|CMD_IAAD|CMD_PSE|CMD_ASE|CMD_RESET);
 	cmd |= CMD_RUN;
 	ehci_writel(&ehcic[index].hcor->or_usbcmd, cmd);
 #ifndef CONFIG_USB_EHCI_FARADAY
 	/* take control over the ports */
 	cmd = ehci_readl(&ehcic[index].hcor->or_configflag);
 	cmd |= FLAG_CF;
 	ehci_writel(&ehcic[index].hcor->or_configflag, cmd);
 #endif
 	/* unblock posted write */
 	cmd = ehci_readl(&ehcic[index].hcor->or_usbcmd);
 	mdelay(5);
 	reg = HC_VERSION(ehci_readl(&ehcic[index].hccr->cr_capbase));
 	printf("USB EHCI %x.%02x\n", reg >> 8, reg & 0xff);
 	ehcic[index].rootdev = 0;
 done:
 	*controller = &ehcic[index];
 	return 0;
 }
 int
 submit_bulk_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
 		int length)
 {
 	if (usb_pipetype(pipe) != PIPE_BULK) {
 		debug("non-bulk pipe (type=%lu)", usb_pipetype(pipe));
 		return -1;
 	}
 	return ehci_submit_async(dev, pipe, buffer, length, NULL);
 }
 int
 submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
 		   int length, struct devrequest *setup)
 {
 	struct ehci_ctrl *ctrl = dev->controller;
 	if (usb_pipetype(pipe) != PIPE_CONTROL) {
 		debug("non-control pipe (type=%lu)", usb_pipetype(pipe));
 		return -1;
 	}
 	if (usb_pipedevice(pipe) == ctrl->rootdev) {
 		if (!ctrl->rootdev)
 			dev->speed = USB_SPEED_HIGH;
 		return ehci_submit_root(dev, pipe, buffer, length, setup);
 	}
 	return ehci_submit_async(dev, pipe, buffer, length, setup);
 }
 struct int_queue {
 	struct QH *first;
 	struct QH *current;
 	struct QH *last;
 	struct qTD *tds;
 };
 #define NEXT_QH(qh) (struct QH *)(hc32_to_cpu((qh)->qh_link) & ~0x1f)
 static int
 enable_periodic(struct ehci_ctrl *ctrl)
 {
 	uint32_t cmd;
 	struct ehci_hcor *hcor = ctrl->hcor;
 	int ret;
 	cmd = ehci_readl(&hcor->or_usbcmd);
 	cmd |= CMD_PSE;
 	ehci_writel(&hcor->or_usbcmd, cmd);
 	ret = handshake((uint32_t *)&hcor->or_usbsts,
 			STS_PSS, STS_PSS, 100 * 1000);
 	if (ret < 0) {
 		printf("EHCI failed: timeout when enabling periodic list\n");
 		return -ETIMEDOUT;
 	}
 	udelay(1000);
 	return 0;
 }
 static int
 disable_periodic(struct ehci_ctrl *ctrl)
 {
 	uint32_t cmd;
 	struct ehci_hcor *hcor = ctrl->hcor;
 	int ret;
 	cmd = ehci_readl(&hcor->or_usbcmd);
 	cmd &= ~CMD_PSE;
 	ehci_writel(&hcor->or_usbcmd, cmd);
 	ret = handshake((uint32_t *)&hcor->or_usbsts,
 			STS_PSS, 0, 100 * 1000);
 	if (ret < 0) {
 		printf("EHCI failed: timeout when disabling periodic list\n");
 		return -ETIMEDOUT;
 	}
 	return 0;
 }
-static int periodic_schedules;
 struct int_queue *
 create_int_queue(struct usb_device *dev, unsigned long pipe, int queuesize,
 		 int elementsize, void *buffer)
 {
 	struct ehci_ctrl *ctrl = dev->controller;
 	struct int_queue *result = NULL;
 	int i;
 	debug("Enter create_int_queue\n");
 	if (usb_pipetype(pipe) != PIPE_INTERRUPT) {
 		debug("non-interrupt pipe (type=%lu)", usb_pipetype(pipe));
 		return NULL;
 	}
 	/* limit to 4 full pages worth of data -
 	 * we can safely fit them in a single TD,
 	 * no matter the alignment
 	 */
 	if (elementsize >= 16384) {
 		debug("too large elements for interrupt transfers\n");
 		return NULL;
 	}
 	result = malloc(sizeof(*result));
 	if (!result) {
 		debug("ehci intr queue: out of memory\n");
 		goto fail1;
 	}
 	result->first = memalign(USB_DMA_MINALIGN,
 				 sizeof(struct QH) * queuesize);
 	if (!result->first) {
 		debug("ehci intr queue: out of memory\n");
 		goto fail2;
 	}
 	result->current = result->first;
 	result->last = result->first + queuesize - 1;
 	result->tds = memalign(USB_DMA_MINALIGN,
 			       sizeof(struct qTD) * queuesize);
 	if (!result->tds) {
 		debug("ehci intr queue: out of memory\n");
 		goto fail3;
 	}
 	memset(result->first, 0, sizeof(struct QH) * queuesize);
 	memset(result->tds, 0, sizeof(struct qTD) * queuesize);
 	for (i = 0; i < queuesize; i++) {
 		struct QH *qh = result->first + i;
 		struct qTD *td = result->tds + i;
 		void **buf = &qh->buffer;
 		qh->qh_link = cpu_to_hc32((uint32_t)(qh+1) | QH_LINK_TYPE_QH);
 		if (i == queuesize - 1)
 			qh->qh_link = cpu_to_hc32(QH_LINK_TERMINATE);
 		qh->qh_overlay.qt_next = cpu_to_hc32((uint32_t)td);
 		qh->qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
 		qh->qh_endpt1 =
 			cpu_to_hc32((0 << 28) | /* No NAK reload (ehci 4.9) */
 			(usb_maxpacket(dev, pipe) << 16) | /* MPS */
 			(1 << 14) |
 			QH_ENDPT1_EPS(ehci_encode_speed(dev->speed)) |
 			(usb_pipeendpoint(pipe) << 8) | /* Endpoint Number */
 			(usb_pipedevice(pipe) << 0));
 		qh->qh_endpt2 = cpu_to_hc32((1 << 30) | /* 1 Tx per mframe */
 			(1 << 0)); /* S-mask: microframe 0 */
 		if (dev->speed == USB_SPEED_LOW ||
 				dev->speed == USB_SPEED_FULL) {
-			debug("TT: port: %d, hub address: %d\n",
+			/* C-mask: microframes 2-4 */
-				dev->portnr, dev->parent->devnum);
+			qh->qh_endpt2 |= cpu_to_hc32((0x1c << 8));
-			qh->qh_endpt2 |= cpu_to_hc32((dev->portnr << 23) |
-				(dev->parent->devnum << 16) |
-				(0x1c << 8)); /* C-mask: microframes 2-4 */
 		}
+		ehci_update_endpt2_dev_n_port(dev, qh);
 		td->qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
 		td->qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
 		debug("communication direction is '%s'\n",
 		      usb_pipein(pipe) ? "in" : "out");
 		td->qt_token = cpu_to_hc32((elementsize << 16) |
 			((usb_pipein(pipe) ? 1 : 0) << 8) | /* IN/OUT token */
 			0x80); /* active */
 		td->qt_buffer[0] =
 		    cpu_to_hc32((uint32_t)buffer + i * elementsize);
 		td->qt_buffer[1] =
 		    cpu_to_hc32((td->qt_buffer[0] + 0x1000) & ~0xfff);
 		td->qt_buffer[2] =
 		    cpu_to_hc32((td->qt_buffer[0] + 0x2000) & ~0xfff);
 		td->qt_buffer[3] =
 		    cpu_to_hc32((td->qt_buffer[0] + 0x3000) & ~0xfff);
 		td->qt_buffer[4] =
 		    cpu_to_hc32((td->qt_buffer[0] + 0x4000) & ~0xfff);
 		*buf = buffer + i * elementsize;
 	}
 	flush_dcache_range((uint32_t)buffer,
 			   ALIGN_END_ADDR(char, buffer,
 					  queuesize * elementsize));
 	flush_dcache_range((uint32_t)result->first,
 			   ALIGN_END_ADDR(struct QH, result->first,
 					  queuesize));
 	flush_dcache_range((uint32_t)result->tds,
 			   ALIGN_END_ADDR(struct qTD, result->tds,
 					  queuesize));
 	if (disable_periodic(ctrl) < 0) {
 		debug("FATAL: periodic should never fail, but did");
 		goto fail3;
 	}
 	/* hook up to periodic list */
 	struct QH *list = &ctrl->periodic_queue;
 	result->last->qh_link = list->qh_link;
 	list->qh_link = cpu_to_hc32((uint32_t)result->first | QH_LINK_TYPE_QH);
 	flush_dcache_range((uint32_t)result->last,
 			   ALIGN_END_ADDR(struct QH, result->last, 1));
 	flush_dcache_range((uint32_t)list,
 			   ALIGN_END_ADDR(struct QH, list, 1));
 	if (enable_periodic(ctrl) < 0) {
 		debug("FATAL: periodic should never fail, but did");
 		goto fail3;
 	}
-	periodic_schedules++;
+	ctrl->periodic_schedules++;
 	debug("Exit create_int_queue\n");
 	return result;
 fail3:
 	if (result->tds)
 		free(result->tds);
 fail2:
 	if (result->first)
 		free(result->first);
 	if (result)
 		free(result);
 fail1:
 	return NULL;
 }
 void *poll_int_queue(struct usb_device *dev, struct int_queue *queue)
 {
 	struct QH *cur = queue->current;
+	struct qTD *cur_td;
 	/* depleted queue */
 	if (cur == NULL) {
 		debug("Exit poll_int_queue with completed queue\n");
 		return NULL;
 	}
 	/* still active */
-	invalidate_dcache_range((uint32_t)cur,
+	cur_td = &queue->tds[queue->current - queue->first];
-				ALIGN_END_ADDR(struct QH, cur, 1));
+	invalidate_dcache_range((uint32_t)cur_td,
-	if (cur->qh_overlay.qt_token & cpu_to_hc32(0x80)) {
+				ALIGN_END_ADDR(struct qTD, cur_td, 1));
-		debug("Exit poll_int_queue with no completed intr transfer. "
+	if (QT_TOKEN_GET_STATUS(hc32_to_cpu(cur_td->qt_token)) &
-		      "token is %x\n", cur->qh_overlay.qt_token);
+			QT_TOKEN_STATUS_ACTIVE) {
+		debug("Exit poll_int_queue with no completed intr transfer. token is %x\n",
+		      hc32_to_cpu(cur_td->qt_token));
 		return NULL;
 	}
 	if (!(cur->qh_link & QH_LINK_TERMINATE))
 		queue->current++;
 	else
 		queue->current = NULL;
-	debug("Exit poll_int_queue with completed intr transfer. "
+	debug("Exit poll_int_queue with completed intr transfer. token is %x at %p (first at %p)\n",
-	      "token is %x at %p (first at %p)\n", cur->qh_overlay.qt_token,
+	      hc32_to_cpu(cur_td->qt_token), cur, queue->first);
-	      &cur->qh_overlay.qt_token, queue->first);
 	return cur->buffer;
 }
 /* Do not free buffers associated with QHs, they're owned by someone else */
 int
 destroy_int_queue(struct usb_device *dev, struct int_queue *queue)
 {
 	struct ehci_ctrl *ctrl = dev->controller;
 	int result = -1;
 	unsigned long timeout;
 	if (disable_periodic(ctrl) < 0) {
 		debug("FATAL: periodic should never fail, but did");
 		goto out;
 	}
-	periodic_schedules--;
+	ctrl->periodic_schedules--;
 	struct QH *cur = &ctrl->periodic_queue;
 	timeout = get_timer(0) + 500; /* abort after 500ms */
 	while (!(cur->qh_link & cpu_to_hc32(QH_LINK_TERMINATE))) {
 		debug("considering %p, with qh_link %x\n", cur, cur->qh_link);
 		if (NEXT_QH(cur) == queue->first) {
 			debug("found candidate. removing from chain\n");
 			cur->qh_link = queue->last->qh_link;
+			flush_dcache_range((uint32_t)cur,
+					   ALIGN_END_ADDR(struct QH, cur, 1));
 			result = 0;
 			break;
 		}
 		cur = NEXT_QH(cur);
 		if (get_timer(0) > timeout) {
 			printf("Timeout destroying interrupt endpoint queue\n");
 			result = -1;
 			goto out;
 		}
 	}
-	if (periodic_schedules > 0) {
+	if (ctrl->periodic_schedules > 0) {
 		result = enable_periodic(ctrl);
 		if (result < 0)
 			debug("FATAL: periodic should never fail, but did");
 	}
 out:
 	free(queue->tds);
 	free(queue->first);
 	free(queue);
 	return result;
 }
 int
 submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
 	       int length, int interval)
 {
 	void *backbuffer;
 	struct int_queue *queue;
 	unsigned long timeout;
 	int result = 0, ret;
 	debug("dev=%p, pipe=%lu, buffer=%p, length=%d, interval=%d",
 	      dev, pipe, buffer, length, interval);
 	/*
 	 * Interrupt transfers requiring several transactions are not supported
 	 * because bInterval is ignored.
 	 *
 	 * Also, ehci_submit_async() relies on wMaxPacketSize being a power of 2
 	 * <= PKT_ALIGN if several qTDs are required, while the USB
 	 * specification does not constrain this for interrupt transfers. That
 	 * means that ehci_submit_async() would support interrupt transfers
 	 * requiring several transactions only as long as the transfer size does
 	 * not require more than a single qTD.
 	 */
 	if (length > usb_maxpacket(dev, pipe)) {
 		printf("%s: Interrupt transfers requiring several "
 			"transactions are not supported.\n", __func__);
 		return -1;
 	}
 	queue = create_int_queue(dev, pipe, 1, length, buffer);
 	timeout = get_timer(0) + USB_TIMEOUT_MS(pipe);
 	while ((backbuffer = poll_int_queue(dev, queue)) == NULL)
 		if (get_timer(0) > timeout) {
 			printf("Timeout poll on interrupt endpoint\n");
 			result = -ETIMEDOUT;
 			break;
 		}
 	if (backbuffer != buffer) {
 		debug("got wrong buffer back (%x instead of %x)\n",
 		      (uint32_t)backbuffer, (uint32_t)buffer);
 		return -EINVAL;
 	}
 	invalidate_dcache_range((uint32_t)buffer,
 				ALIGN_END_ADDR(char, buffer, length));

drivers/usb/host/ehci-tegra.c

Diff comments View file @ 8a6b088

drivers/usb/host/ehci.h

Diff comments View file @ 8a6b088

 /*-
  * Copyright (c) 2007-2008, Juniper Networks, Inc.
  * Copyright (c) 2008, Michael Trimarchi <trimarchimichael@yahoo.it>
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation version 2 of
  * the License.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  * MA 02111-1307 USA
  */
 #ifndef USB_EHCI_H
 #define USB_EHCI_H
 #include <usb.h>
 #if !defined(CONFIG_SYS_USB_EHCI_MAX_ROOT_PORTS)
 #define CONFIG_SYS_USB_EHCI_MAX_ROOT_PORTS	2
 #endif
 /*
  * Register Space.
  */
 struct ehci_hccr {
 	uint32_t cr_capbase;
 #define HC_LENGTH(p)		(((p) >> 0) & 0x00ff)
 #define HC_VERSION(p)		(((p) >> 16) & 0xffff)
 	uint32_t cr_hcsparams;
 #define HCS_PPC(p)		((p) & (1 << 4))
 #define HCS_INDICATOR(p)	((p) & (1 << 16)) /* Port indicators */
 #define HCS_N_PORTS(p)		(((p) >> 0) & 0xf)
 	uint32_t cr_hccparams;
 	uint8_t cr_hcsp_portrt[8];
 } __attribute__ ((packed, aligned(4)));
 struct ehci_hcor {
 	uint32_t or_usbcmd;
 #define CMD_PARK	(1 << 11)		/* enable "park" */
 #define CMD_PARK_CNT(c)	(((c) >> 8) & 3)	/* how many transfers to park */
 #define CMD_ASE		(1 << 5)		/* async schedule enable */
 #define CMD_LRESET	(1 << 7)		/* partial reset */
 #define CMD_IAAD	(1 << 5)		/* "doorbell" interrupt */
 #define CMD_PSE		(1 << 4)		/* periodic schedule enable */
 #define CMD_RESET	(1 << 1)		/* reset HC not bus */
 #define CMD_RUN		(1 << 0)		/* start/stop HC */
 	uint32_t or_usbsts;
 #define STS_ASS		(1 << 15)
 #define	STS_PSS		(1 << 14)
 #define STS_HALT	(1 << 12)
 	uint32_t or_usbintr;
 #define INTR_UE         (1 << 0)                /* USB interrupt enable */
 #define INTR_UEE        (1 << 1)                /* USB error interrupt enable */
 #define INTR_PCE        (1 << 2)                /* Port change detect enable */
 #define INTR_SEE        (1 << 4)                /* system error enable */
 #define INTR_AAE        (1 << 5)                /* Interrupt on async adavance enable */
 	uint32_t or_frindex;
 	uint32_t or_ctrldssegment;
 	uint32_t or_periodiclistbase;
 	uint32_t or_asynclistaddr;
 	uint32_t _reserved_0_;
 	uint32_t or_burstsize;
 	uint32_t or_txfilltuning;
 #define TXFIFO_THRESH_MASK		(0x3f << 16)
 #define TXFIFO_THRESH(p)		((p & 0x3f) << 16)
 	uint32_t _reserved_1_[6];
 	uint32_t or_configflag;
 #define FLAG_CF		(1 << 0)	/* true:  we'll support "high speed" */
 	uint32_t or_portsc[CONFIG_SYS_USB_EHCI_MAX_ROOT_PORTS];
 #define PORTSC_PSPD(x)		(((x) >> 26) & 0x3)
 #define PORTSC_PSPD_FS			0x0
 #define PORTSC_PSPD_LS			0x1
 #define PORTSC_PSPD_HS			0x2
 	uint32_t or_systune;
 } __attribute__ ((packed, aligned(4)));
 #define USBMODE		0x68		/* USB Device mode */
 #define USBMODE_SDIS	(1 << 3)	/* Stream disable */
 #define USBMODE_BE	(1 << 2)	/* BE/LE endiannes select */
 #define USBMODE_CM_HC	(3 << 0)	/* host controller mode */
 #define USBMODE_CM_IDLE	(0 << 0)	/* idle state */
 /* Interface descriptor */
 struct usb_linux_interface_descriptor {
 	unsigned char	bLength;
 	unsigned char	bDescriptorType;
 	unsigned char	bInterfaceNumber;
 	unsigned char	bAlternateSetting;
 	unsigned char	bNumEndpoints;
 	unsigned char	bInterfaceClass;
 	unsigned char	bInterfaceSubClass;
 	unsigned char	bInterfaceProtocol;
 	unsigned char	iInterface;
 } __attribute__ ((packed));
 /* Configuration descriptor information.. */
 struct usb_linux_config_descriptor {
 	unsigned char	bLength;
 	unsigned char	bDescriptorType;
 	unsigned short	wTotalLength;
 	unsigned char	bNumInterfaces;
 	unsigned char	bConfigurationValue;
 	unsigned char	iConfiguration;
 	unsigned char	bmAttributes;
 	unsigned char	MaxPower;
 } __attribute__ ((packed));
 #if defined CONFIG_EHCI_DESC_BIG_ENDIAN
 #define	ehci_readl(x)		(*((volatile u32 *)(x)))
 #define ehci_writel(a, b)	(*((volatile u32 *)(a)) = ((volatile u32)b))
 #else
 #define ehci_readl(x)		cpu_to_le32((*((volatile u32 *)(x))))
 #define ehci_writel(a, b)	(*((volatile u32 *)(a)) = \
 					cpu_to_le32(((volatile u32)b)))
 #endif
 #if defined CONFIG_EHCI_MMIO_BIG_ENDIAN
 #define hc32_to_cpu(x)		be32_to_cpu((x))
 #define cpu_to_hc32(x)		cpu_to_be32((x))
 #else
 #define hc32_to_cpu(x)		le32_to_cpu((x))
 #define cpu_to_hc32(x)		cpu_to_le32((x))
 #endif
 #define EHCI_PS_WKOC_E		(1 << 22)	/* RW wake on over current */
 #define EHCI_PS_WKDSCNNT_E	(1 << 21)	/* RW wake on disconnect */
 #define EHCI_PS_WKCNNT_E	(1 << 20)	/* RW wake on connect */
 #define EHCI_PS_PO		(1 << 13)	/* RW port owner */
 #define EHCI_PS_PP		(1 << 12)	/* RW,RO port power */
 #define EHCI_PS_LS		(3 << 10)	/* RO line status */
 #define EHCI_PS_PR		(1 << 8)	/* RW port reset */
 #define EHCI_PS_SUSP		(1 << 7)	/* RW suspend */
 #define EHCI_PS_FPR		(1 << 6)	/* RW force port resume */
 #define EHCI_PS_OCC		(1 << 5)	/* RWC over current change */
 #define EHCI_PS_OCA		(1 << 4)	/* RO over current active */
 #define EHCI_PS_PEC		(1 << 3)	/* RWC port enable change */
 #define EHCI_PS_PE		(1 << 2)	/* RW port enable */
 #define EHCI_PS_CSC		(1 << 1)	/* RWC connect status change */
 #define EHCI_PS_CS		(1 << 0)	/* RO connect status */
 #define EHCI_PS_CLEAR		(EHCI_PS_OCC | EHCI_PS_PEC | EHCI_PS_CSC)
 #define EHCI_PS_IS_LOWSPEED(x)	(((x) & EHCI_PS_LS) == (1 << 10))
 /*
  * Schedule Interface Space.
  *
  * IMPORTANT: Software must ensure that no interface data structure
  * reachable by the EHCI host controller spans a 4K page boundary!
  *
  * Periodic transfers (i.e. isochronous and interrupt transfers) are
  * not supported.
  */
 /* Queue Element Transfer Descriptor (qTD). */
 struct qTD {
 	/* this part defined by EHCI spec */
 	uint32_t qt_next;			/* see EHCI 3.5.1 */
 #define	QT_NEXT_TERMINATE	1
 	uint32_t qt_altnext;			/* see EHCI 3.5.2 */
 	uint32_t qt_token;			/* see EHCI 3.5.3 */
 #define QT_TOKEN_DT(x)		(((x) & 0x1) << 31)	/* Data Toggle */
 #define QT_TOKEN_GET_DT(x)		(((x) >> 31) & 0x1)
 #define QT_TOKEN_TOTALBYTES(x)	(((x) & 0x7fff) << 16)	/* Total Bytes to Transfer */
 #define QT_TOKEN_GET_TOTALBYTES(x)	(((x) >> 16) & 0x7fff)
 #define QT_TOKEN_IOC(x)		(((x) & 0x1) << 15)	/* Interrupt On Complete */
 #define QT_TOKEN_CPAGE(x)	(((x) & 0x7) << 12)	/* Current Page */
 #define QT_TOKEN_CERR(x)	(((x) & 0x3) << 10)	/* Error Counter */
 #define QT_TOKEN_PID(x)		(((x) & 0x3) << 8)	/* PID Code */
 #define QT_TOKEN_PID_OUT		0x0
 #define QT_TOKEN_PID_IN			0x1
 #define QT_TOKEN_PID_SETUP		0x2
 #define QT_TOKEN_STATUS(x)	(((x) & 0xff) << 0)	/* Status */
 #define QT_TOKEN_GET_STATUS(x)		(((x) >> 0) & 0xff)
 #define QT_TOKEN_STATUS_ACTIVE		0x80
 #define QT_TOKEN_STATUS_HALTED		0x40
 #define QT_TOKEN_STATUS_DATBUFERR	0x20
 #define QT_TOKEN_STATUS_BABBLEDET	0x10
 #define QT_TOKEN_STATUS_XACTERR		0x08
 #define QT_TOKEN_STATUS_MISSEDUFRAME	0x04
 #define QT_TOKEN_STATUS_SPLITXSTATE	0x02
 #define QT_TOKEN_STATUS_PERR		0x01
 #define QT_BUFFER_CNT		5
 	uint32_t qt_buffer[QT_BUFFER_CNT];	/* see EHCI 3.5.4 */
 	uint32_t qt_buffer_hi[QT_BUFFER_CNT];	/* Appendix B */
 	/* pad struct for 32 byte alignment */
 	uint32_t unused[3];
 };
 #define EHCI_PAGE_SIZE		4096
 /* Queue Head (QH). */
 struct QH {
 	uint32_t qh_link;
 #define	QH_LINK_TERMINATE	1
 #define	QH_LINK_TYPE_ITD	0
 #define	QH_LINK_TYPE_QH		2
 #define	QH_LINK_TYPE_SITD	4
 #define	QH_LINK_TYPE_FSTN	6
 	uint32_t qh_endpt1;
 #define QH_ENDPT1_RL(x)		(((x) & 0xf) << 28)	/* NAK Count Reload */
 #define QH_ENDPT1_C(x)		(((x) & 0x1) << 27)	/* Control Endpoint Flag */
 #define QH_ENDPT1_MAXPKTLEN(x)	(((x) & 0x7ff) << 16)	/* Maximum Packet Length */
 #define QH_ENDPT1_H(x)		(((x) & 0x1) << 15)	/* Head of Reclamation List Flag */
 #define QH_ENDPT1_DTC(x)	(((x) & 0x1) << 14)	/* Data Toggle Control */
 #define QH_ENDPT1_DTC_IGNORE_QTD_TD	0x0
 #define QH_ENDPT1_DTC_DT_FROM_QTD	0x1
 #define QH_ENDPT1_EPS(x)	(((x) & 0x3) << 12)	/* Endpoint Speed */
 #define QH_ENDPT1_EPS_FS		0x0
 #define QH_ENDPT1_EPS_LS		0x1
 #define QH_ENDPT1_EPS_HS		0x2
 #define QH_ENDPT1_ENDPT(x)	(((x) & 0xf) << 8)	/* Endpoint Number */
 #define QH_ENDPT1_I(x)		(((x) & 0x1) << 7)	/* Inactivate on Next Transaction */
 #define QH_ENDPT1_DEVADDR(x)	(((x) & 0x7f) << 0)	/* Device Address */
 	uint32_t qh_endpt2;
 #define QH_ENDPT2_MULT(x)	(((x) & 0x3) << 30)	/* High-Bandwidth Pipe Multiplier */
 #define QH_ENDPT2_PORTNUM(x)	(((x) & 0x7f) << 23)	/* Port Number */
 #define QH_ENDPT2_HUBADDR(x)	(((x) & 0x7f) << 16)	/* Hub Address */
 #define QH_ENDPT2_UFCMASK(x)	(((x) & 0xff) << 8)	/* Split Completion Mask */
 #define QH_ENDPT2_UFSMASK(x)	(((x) & 0xff) << 0)	/* Interrupt Schedule Mask */
 	uint32_t qh_curtd;
 	struct qTD qh_overlay;
 	/*
 	 * Add dummy fill value to make the size of this struct
 	 * aligned to 32 bytes
 	 */
 	union {
 		uint32_t fill[4];
 		void *buffer;
 	};
 };
 struct ehci_ctrl {
 	struct ehci_hccr *hccr;	/* R/O registers, not need for volatile */
 	struct ehci_hcor *hcor;
 	int rootdev;
 	uint16_t portreset;
 	struct QH qh_list __aligned(USB_DMA_MINALIGN);
 	struct QH periodic_queue __aligned(USB_DMA_MINALIGN);
 	uint32_t *periodic_list;
+	int periodic_schedules;
 	int ntds;
 };
 /* Low level init functions */
 int ehci_hcd_init(int index, enum usb_init_type init,
 		struct ehci_hccr **hccr, struct ehci_hcor **hcor);
 int ehci_hcd_stop(int index);
 #endif /* USB_EHCI_H */

drivers/usb/musb-new/musb_core.c

Diff comments View file @ 8a6b088

 /*
  * MUSB OTG driver core code
  *
  * Copyright 2005 Mentor Graphics Corporation
  * Copyright (C) 2005-2006 by Texas Instruments
  * Copyright (C) 2006-2007 Nokia Corporation
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA
  *
  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
 /*
  * Inventra (Multipoint) Dual-Role Controller Driver for Linux.
  *
  * This consists of a Host Controller Driver (HCD) and a peripheral
  * controller driver implementing the "Gadget" API; OTG support is
  * in the works.  These are normal Linux-USB controller drivers which
  * use IRQs and have no dedicated thread.
  *
  * This version of the driver has only been used with products from
  * Texas Instruments.  Those products integrate the Inventra logic
  * with other DMA, IRQ, and bus modules, as well as other logic that
  * needs to be reflected in this driver.
  *
  *
  * NOTE:  the original Mentor code here was pretty much a collection
  * of mechanisms that don't seem to have been fully integrated/working
  * for *any* Linux kernel version.  This version aims at Linux 2.6.now,
  * Key open issues include:
  *
  *  - Lack of host-side transaction scheduling, for all transfer types.
  *    The hardware doesn't do it; instead, software must.
  *
  *    This is not an issue for OTG devices that don't support external
  *    hubs, but for more "normal" USB hosts it's a user issue that the
  *    "multipoint" support doesn't scale in the expected ways.  That
  *    includes DaVinci EVM in a common non-OTG mode.
  *
  *      * Control and bulk use dedicated endpoints, and there's as
  *        yet no mechanism to either (a) reclaim the hardware when
  *        peripherals are NAKing, which gets complicated with bulk
  *        endpoints, or (b) use more than a single bulk endpoint in
  *        each direction.
  *
  *        RESULT:  one device may be perceived as blocking another one.
  *
  *      * Interrupt and isochronous will dynamically allocate endpoint
  *        hardware, but (a) there's no record keeping for bandwidth;
  *        (b) in the common case that few endpoints are available, there
  *        is no mechanism to reuse endpoints to talk to multiple devices.
  *
  *        RESULT:  At one extreme, bandwidth can be overcommitted in
  *        some hardware configurations, no faults will be reported.
  *        At the other extreme, the bandwidth capabilities which do
  *        exist tend to be severely undercommitted.  You can't yet hook
  *        up both a keyboard and a mouse to an external USB hub.
  */
 /*
  * This gets many kinds of configuration information:
  *	- Kconfig for everything user-configurable
  *	- platform_device for addressing, irq, and platform_data
  *	- platform_data is mostly for board-specific informarion
  *	  (plus recentrly, SOC or family details)
  *
  * Most of the conditional compilation will (someday) vanish.
  */
 #ifndef __UBOOT__
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/kobject.h>
 #include <linux/prefetch.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #else
 #include <common.h>
 #include <usb.h>
 #include <asm/errno.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/musb.h>
 #include <asm/io.h>
 #include "linux-compat.h"
 #include "usb-compat.h"
 #endif
 #include "musb_core.h"
 #define TA_WAIT_BCON(m) max_t(int, (m)->a_wait_bcon, OTG_TIME_A_WAIT_BCON)
 #define DRIVER_AUTHOR "Mentor Graphics, Texas Instruments, Nokia"
 #define DRIVER_DESC "Inventra Dual-Role USB Controller Driver"
 #define MUSB_VERSION "6.0"
 #define DRIVER_INFO DRIVER_DESC ", v" MUSB_VERSION
 #define MUSB_DRIVER_NAME "musb-hdrc"
 const char musb_driver_name[] = MUSB_DRIVER_NAME;
 MODULE_DESCRIPTION(DRIVER_INFO);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:" MUSB_DRIVER_NAME);
 #ifndef __UBOOT__
 /*-------------------------------------------------------------------------*/
 static inline struct musb *dev_to_musb(struct device *dev)
 {
 	return dev_get_drvdata(dev);
 }
 #endif
 /*-------------------------------------------------------------------------*/
 #ifndef __UBOOT__
 #ifndef CONFIG_BLACKFIN
 static int musb_ulpi_read(struct usb_phy *phy, u32 offset)
 {
 	void __iomem *addr = phy->io_priv;
 	int	i = 0;
 	u8	r;
 	u8	power;
 	int	ret;
 	pm_runtime_get_sync(phy->io_dev);
 	/* Make sure the transceiver is not in low power mode */
 	power = musb_readb(addr, MUSB_POWER);
 	power &= ~MUSB_POWER_SUSPENDM;
 	musb_writeb(addr, MUSB_POWER, power);
 	/* REVISIT: musbhdrc_ulpi_an.pdf recommends setting the
 	 * ULPICarKitControlDisableUTMI after clearing POWER_SUSPENDM.
 	 */
 	musb_writeb(addr, MUSB_ULPI_REG_ADDR, (u8)offset);
 	musb_writeb(addr, MUSB_ULPI_REG_CONTROL,
 			MUSB_ULPI_REG_REQ | MUSB_ULPI_RDN_WR);
 	while (!(musb_readb(addr, MUSB_ULPI_REG_CONTROL)
 				& MUSB_ULPI_REG_CMPLT)) {
 		i++;
 		if (i == 10000) {
 			ret = -ETIMEDOUT;
 			goto out;
 		}
 	}
 	r = musb_readb(addr, MUSB_ULPI_REG_CONTROL);
 	r &= ~MUSB_ULPI_REG_CMPLT;
 	musb_writeb(addr, MUSB_ULPI_REG_CONTROL, r);
 	ret = musb_readb(addr, MUSB_ULPI_REG_DATA);
 out:
 	pm_runtime_put(phy->io_dev);
 	return ret;
 }
 static int musb_ulpi_write(struct usb_phy *phy, u32 offset, u32 data)
 {
 	void __iomem *addr = phy->io_priv;
 	int	i = 0;
 	u8	r = 0;
 	u8	power;
 	int	ret = 0;
 	pm_runtime_get_sync(phy->io_dev);
 	/* Make sure the transceiver is not in low power mode */
 	power = musb_readb(addr, MUSB_POWER);
 	power &= ~MUSB_POWER_SUSPENDM;
 	musb_writeb(addr, MUSB_POWER, power);
 	musb_writeb(addr, MUSB_ULPI_REG_ADDR, (u8)offset);
 	musb_writeb(addr, MUSB_ULPI_REG_DATA, (u8)data);
 	musb_writeb(addr, MUSB_ULPI_REG_CONTROL, MUSB_ULPI_REG_REQ);
 	while (!(musb_readb(addr, MUSB_ULPI_REG_CONTROL)
 				& MUSB_ULPI_REG_CMPLT)) {
 		i++;
 		if (i == 10000) {
 			ret = -ETIMEDOUT;
 			goto out;
 		}
 	}
 	r = musb_readb(addr, MUSB_ULPI_REG_CONTROL);
 	r &= ~MUSB_ULPI_REG_CMPLT;
 	musb_writeb(addr, MUSB_ULPI_REG_CONTROL, r);
 out:
 	pm_runtime_put(phy->io_dev);
 	return ret;
 }
 #else
 #define musb_ulpi_read		NULL
 #define musb_ulpi_write		NULL
 #endif
 static struct usb_phy_io_ops musb_ulpi_access = {
 	.read = musb_ulpi_read,
 	.write = musb_ulpi_write,
 };
 #endif
 /*-------------------------------------------------------------------------*/
 #if !defined(CONFIG_USB_MUSB_TUSB6010) && !defined(CONFIG_USB_MUSB_BLACKFIN)
 /*
  * Load an endpoint's FIFO
  */
 void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *src)
 {
 	struct musb *musb = hw_ep->musb;
 	void __iomem *fifo = hw_ep->fifo;
 	prefetch((u8 *)src);
 	dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",
 			'T', hw_ep->epnum, fifo, len, src);
 	/* we can't assume unaligned reads work */
 	if (likely((0x01 & (unsigned long) src) == 0)) {
 		u16	index = 0;
 		/* best case is 32bit-aligned source address */
 		if ((0x02 & (unsigned long) src) == 0) {
 			if (len >= 4) {
 				writesl(fifo, src + index, len >> 2);
 				index += len & ~0x03;
 			}
 			if (len & 0x02) {
 				musb_writew(fifo, 0, *(u16 *)&src[index]);
 				index += 2;
 			}
 		} else {
 			if (len >= 2) {
 				writesw(fifo, src + index, len >> 1);
 				index += len & ~0x01;
 			}
 		}
 		if (len & 0x01)
 			musb_writeb(fifo, 0, src[index]);
 	} else  {
 		/* byte aligned */
 		writesb(fifo, src, len);
 	}
 }
 #if !defined(CONFIG_USB_MUSB_AM35X)
 /*
  * Unload an endpoint's FIFO
  */
 void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
 {
 	struct musb *musb = hw_ep->musb;
 	void __iomem *fifo = hw_ep->fifo;
 	dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",
 			'R', hw_ep->epnum, fifo, len, dst);
 	/* we can't assume unaligned writes work */
 	if (likely((0x01 & (unsigned long) dst) == 0)) {
 		u16	index = 0;
 		/* best case is 32bit-aligned destination address */
 		if ((0x02 & (unsigned long) dst) == 0) {
 			if (len >= 4) {
 				readsl(fifo, dst, len >> 2);
 				index = len & ~0x03;
 			}
 			if (len & 0x02) {
 				*(u16 *)&dst[index] = musb_readw(fifo, 0);
 				index += 2;
 			}
 		} else {
 			if (len >= 2) {
 				readsw(fifo, dst, len >> 1);
 				index = len & ~0x01;
 			}
 		}
 		if (len & 0x01)
 			dst[index] = musb_readb(fifo, 0);
 	} else  {
 		/* byte aligned */
 		readsb(fifo, dst, len);
 	}
 }
 #endif
 #endif	/* normal PIO */
 /*-------------------------------------------------------------------------*/
 /* for high speed test mode; see USB 2.0 spec 7.1.20 */
 static const u8 musb_test_packet[53] = {
 	/* implicit SYNC then DATA0 to start */
 	/* JKJKJKJK x9 */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	/* JJKKJJKK x8 */
 	0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 	/* JJJJKKKK x8 */
 	0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
 	/* JJJJJJJKKKKKKK x8 */
 	0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 	/* JJJJJJJK x8 */
 	0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd,
 	/* JKKKKKKK x10, JK */
 	0xfc, 0x7e, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0x7e
 	/* implicit CRC16 then EOP to end */
 };
 void musb_load_testpacket(struct musb *musb)
 {
 	void __iomem	*regs = musb->endpoints[0].regs;
 	musb_ep_select(musb->mregs, 0);
 	musb_write_fifo(musb->control_ep,
 			sizeof(musb_test_packet), musb_test_packet);
 	musb_writew(regs, MUSB_CSR0, MUSB_CSR0_TXPKTRDY);
 }
 #ifndef __UBOOT__
 /*-------------------------------------------------------------------------*/
 /*
  * Handles OTG hnp timeouts, such as b_ase0_brst
  */
 void musb_otg_timer_func(unsigned long data)
 {
 	struct musb	*musb = (struct musb *)data;
 	unsigned long	flags;
 	spin_lock_irqsave(&musb->lock, flags);
 	switch (musb->xceiv->state) {
 	case OTG_STATE_B_WAIT_ACON:
 		dev_dbg(musb->controller, "HNP: b_wait_acon timeout; back to b_peripheral\n");
 		musb_g_disconnect(musb);
 		musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
 		musb->is_active = 0;
 		break;
 	case OTG_STATE_A_SUSPEND:
 	case OTG_STATE_A_WAIT_BCON:
 		dev_dbg(musb->controller, "HNP: %s timeout\n",
 			otg_state_string(musb->xceiv->state));
 		musb_platform_set_vbus(musb, 0);
 		musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
 		break;
 	default:
 		dev_dbg(musb->controller, "HNP: Unhandled mode %s\n",
 			otg_state_string(musb->xceiv->state));
 	}
 	musb->ignore_disconnect = 0;
 	spin_unlock_irqrestore(&musb->lock, flags);
 }
 /*
  * Stops the HNP transition. Caller must take care of locking.
  */
 void musb_hnp_stop(struct musb *musb)
 {
 	struct usb_hcd	*hcd = musb_to_hcd(musb);
 	void __iomem	*mbase = musb->mregs;
 	u8	reg;
 	dev_dbg(musb->controller, "HNP: stop from %s\n", otg_state_string(musb->xceiv->state));
 	switch (musb->xceiv->state) {
 	case OTG_STATE_A_PERIPHERAL:
 		musb_g_disconnect(musb);
 		dev_dbg(musb->controller, "HNP: back to %s\n",
 			otg_state_string(musb->xceiv->state));
 		break;
 	case OTG_STATE_B_HOST:
 		dev_dbg(musb->controller, "HNP: Disabling HR\n");
 		hcd->self.is_b_host = 0;
 		musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
 		MUSB_DEV_MODE(musb);
 		reg = musb_readb(mbase, MUSB_POWER);
 		reg |= MUSB_POWER_SUSPENDM;
 		musb_writeb(mbase, MUSB_POWER, reg);
 		/* REVISIT: Start SESSION_REQUEST here? */
 		break;
 	default:
 		dev_dbg(musb->controller, "HNP: Stopping in unknown state %s\n",
 			otg_state_string(musb->xceiv->state));
 	}
 	/*
 	 * When returning to A state after HNP, avoid hub_port_rebounce(),
 	 * which cause occasional OPT A "Did not receive reset after connect"
 	 * errors.
 	 */
 	musb->port1_status &= ~(USB_PORT_STAT_C_CONNECTION << 16);
 }
 #endif
 /*
  * Interrupt Service Routine to record USB "global" interrupts.
  * Since these do not happen often and signify things of
  * paramount importance, it seems OK to check them individually;
  * the order of the tests is specified in the manual
  *
  * @param musb instance pointer
  * @param int_usb register contents
  * @param devctl
  * @param power
  */
 static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
 				u8 devctl, u8 power)
 {
 #ifndef __UBOOT__
 	struct usb_otg *otg = musb->xceiv->otg;
 #endif
 	irqreturn_t handled = IRQ_NONE;
 	dev_dbg(musb->controller, "<== Power=%02x, DevCtl=%02x, int_usb=0x%x\n", power, devctl,
 		int_usb);
 #ifndef __UBOOT__
 	/* in host mode, the peripheral may issue remote wakeup.
 	 * in peripheral mode, the host may resume the link.
 	 * spurious RESUME irqs happen too, paired with SUSPEND.
 	 */
 	if (int_usb & MUSB_INTR_RESUME) {
 		handled = IRQ_HANDLED;
 		dev_dbg(musb->controller, "RESUME (%s)\n", otg_state_string(musb->xceiv->state));
 		if (devctl & MUSB_DEVCTL_HM) {
 			void __iomem *mbase = musb->mregs;
 			switch (musb->xceiv->state) {
 			case OTG_STATE_A_SUSPEND:
 				/* remote wakeup?  later, GetPortStatus
 				 * will stop RESUME signaling
 				 */
 				if (power & MUSB_POWER_SUSPENDM) {
 					/* spurious */
 					musb->int_usb &= ~MUSB_INTR_SUSPEND;
 					dev_dbg(musb->controller, "Spurious SUSPENDM\n");
 					break;
 				}
 				power &= ~MUSB_POWER_SUSPENDM;
 				musb_writeb(mbase, MUSB_POWER,
 						power | MUSB_POWER_RESUME);
 				musb->port1_status |=
 						(USB_PORT_STAT_C_SUSPEND << 16)
 						| MUSB_PORT_STAT_RESUME;
 				musb->rh_timer = jiffies
 						+ msecs_to_jiffies(20);
 				musb->xceiv->state = OTG_STATE_A_HOST;
 				musb->is_active = 1;
 				usb_hcd_resume_root_hub(musb_to_hcd(musb));
 				break;
 			case OTG_STATE_B_WAIT_ACON:
 				musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
 				musb->is_active = 1;
 				MUSB_DEV_MODE(musb);
 				break;
 			default:
 				WARNING("bogus %s RESUME (%s)\n",
 					"host",
 					otg_state_string(musb->xceiv->state));
 			}
 		} else {
 			switch (musb->xceiv->state) {
 			case OTG_STATE_A_SUSPEND:
 				/* possibly DISCONNECT is upcoming */
 				musb->xceiv->state = OTG_STATE_A_HOST;
 				usb_hcd_resume_root_hub(musb_to_hcd(musb));
 				break;
 			case OTG_STATE_B_WAIT_ACON:
 			case OTG_STATE_B_PERIPHERAL:
 				/* disconnect while suspended?  we may
 				 * not get a disconnect irq...
 				 */
 				if ((devctl & MUSB_DEVCTL_VBUS)
 						!= (3 << MUSB_DEVCTL_VBUS_SHIFT)
 						) {
 					musb->int_usb |= MUSB_INTR_DISCONNECT;
 					musb->int_usb &= ~MUSB_INTR_SUSPEND;
 					break;
 				}
 				musb_g_resume(musb);
 				break;
 			case OTG_STATE_B_IDLE:
 				musb->int_usb &= ~MUSB_INTR_SUSPEND;
 				break;
 			default:
 				WARNING("bogus %s RESUME (%s)\n",
 					"peripheral",
 					otg_state_string(musb->xceiv->state));
 			}
 		}
 	}
 	/* see manual for the order of the tests */
 	if (int_usb & MUSB_INTR_SESSREQ) {
 		void __iomem *mbase = musb->mregs;
 		if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS
 				&& (devctl & MUSB_DEVCTL_BDEVICE)) {
 			dev_dbg(musb->controller, "SessReq while on B state\n");
 			return IRQ_HANDLED;
 		}
 		dev_dbg(musb->controller, "SESSION_REQUEST (%s)\n",
 			otg_state_string(musb->xceiv->state));
 		/* IRQ arrives from ID pin sense or (later, if VBUS power
 		 * is removed) SRP.  responses are time critical:
 		 *  - turn on VBUS (with silicon-specific mechanism)
 		 *  - go through A_WAIT_VRISE
 		 *  - ... to A_WAIT_BCON.
 		 * a_wait_vrise_tmout triggers VBUS_ERROR transitions
 		 */
 		musb_writeb(mbase, MUSB_DEVCTL, MUSB_DEVCTL_SESSION);
 		musb->ep0_stage = MUSB_EP0_START;
 		musb->xceiv->state = OTG_STATE_A_IDLE;
 		MUSB_HST_MODE(musb);
 		musb_platform_set_vbus(musb, 1);
 		handled = IRQ_HANDLED;
 	}
 	if (int_usb & MUSB_INTR_VBUSERROR) {
 		int	ignore = 0;
 		/* During connection as an A-Device, we may see a short
 		 * current spikes causing voltage drop, because of cable
 		 * and peripheral capacitance combined with vbus draw.
 		 * (So: less common with truly self-powered devices, where
 		 * vbus doesn't act like a power supply.)
 		 *
 		 * Such spikes are short; usually less than ~500 usec, max
 		 * of ~2 msec.  That is, they're not sustained overcurrent
 		 * errors, though they're reported using VBUSERROR irqs.
 		 *
 		 * Workarounds:  (a) hardware: use self powered devices.
 		 * (b) software:  ignore non-repeated VBUS errors.
 		 *
 		 * REVISIT:  do delays from lots of DEBUG_KERNEL checks
 		 * make trouble here, keeping VBUS < 4.4V ?
 		 */
 		switch (musb->xceiv->state) {
 		case OTG_STATE_A_HOST:
 			/* recovery is dicey once we've gotten past the
 			 * initial stages of enumeration, but if VBUS
 			 * stayed ok at the other end of the link, and
 			 * another reset is due (at least for high speed,
 			 * to redo the chirp etc), it might work OK...
 			 */
 		case OTG_STATE_A_WAIT_BCON:
 		case OTG_STATE_A_WAIT_VRISE:
 			if (musb->vbuserr_retry) {
 				void __iomem *mbase = musb->mregs;
 				musb->vbuserr_retry--;
 				ignore = 1;
 				devctl |= MUSB_DEVCTL_SESSION;
 				musb_writeb(mbase, MUSB_DEVCTL, devctl);
 			} else {
 				musb->port1_status |=
 					  USB_PORT_STAT_OVERCURRENT
 					| (USB_PORT_STAT_C_OVERCURRENT << 16);
 			}
 			break;
 		default:
 			break;
 		}
 		dev_dbg(musb->controller, "VBUS_ERROR in %s (%02x, %s), retry #%d, port1 %08x\n",
 				otg_state_string(musb->xceiv->state),
 				devctl,
 				({ char *s;
 				switch (devctl & MUSB_DEVCTL_VBUS) {
 				case 0 << MUSB_DEVCTL_VBUS_SHIFT:
 					s = "<SessEnd"; break;
 				case 1 << MUSB_DEVCTL_VBUS_SHIFT:
 					s = "<AValid"; break;
 				case 2 << MUSB_DEVCTL_VBUS_SHIFT:
 					s = "<VBusValid"; break;
 				/* case 3 << MUSB_DEVCTL_VBUS_SHIFT: */
 				default:
 					s = "VALID"; break;
 				}; s; }),
 				VBUSERR_RETRY_COUNT - musb->vbuserr_retry,
 				musb->port1_status);
 		/* go through A_WAIT_VFALL then start a new session */
 		if (!ignore)
 			musb_platform_set_vbus(musb, 0);
 		handled = IRQ_HANDLED;
 	}
 	if (int_usb & MUSB_INTR_SUSPEND) {
 		dev_dbg(musb->controller, "SUSPEND (%s) devctl %02x power %02x\n",
 			otg_state_string(musb->xceiv->state), devctl, power);
 		handled = IRQ_HANDLED;
 		switch (musb->xceiv->state) {
 		case OTG_STATE_A_PERIPHERAL:
 			/* We also come here if the cable is removed, since
 			 * this silicon doesn't report ID-no-longer-grounded.
 			 *
 			 * We depend on T(a_wait_bcon) to shut us down, and
 			 * hope users don't do anything dicey during this
 			 * undesired detour through A_WAIT_BCON.
 			 */
 			musb_hnp_stop(musb);
 			usb_hcd_resume_root_hub(musb_to_hcd(musb));
 			musb_root_disconnect(musb);
 			musb_platform_try_idle(musb, jiffies
 					+ msecs_to_jiffies(musb->a_wait_bcon
 						? : OTG_TIME_A_WAIT_BCON));
 			break;
 		case OTG_STATE_B_IDLE:
 			if (!musb->is_active)
 				break;
 		case OTG_STATE_B_PERIPHERAL:
 			musb_g_suspend(musb);
 			musb->is_active = is_otg_enabled(musb)
 					&& otg->gadget->b_hnp_enable;
 			if (musb->is_active) {
 				musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
 				dev_dbg(musb->controller, "HNP: Setting timer for b_ase0_brst\n");
 				mod_timer(&musb->otg_timer, jiffies
 					+ msecs_to_jiffies(
 							OTG_TIME_B_ASE0_BRST));
 			}
 			break;
 		case OTG_STATE_A_WAIT_BCON:
 			if (musb->a_wait_bcon != 0)
 				musb_platform_try_idle(musb, jiffies
 					+ msecs_to_jiffies(musb->a_wait_bcon));
 			break;
 		case OTG_STATE_A_HOST:
 			musb->xceiv->state = OTG_STATE_A_SUSPEND;
 			musb->is_active = is_otg_enabled(musb)
 					&& otg->host->b_hnp_enable;
 			break;
 		case OTG_STATE_B_HOST:
 			/* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */
 			dev_dbg(musb->controller, "REVISIT: SUSPEND as B_HOST\n");
 			break;
 		default:
 			/* "should not happen" */
 			musb->is_active = 0;
 			break;
 		}
 	}
 #endif
 	if (int_usb & MUSB_INTR_CONNECT) {
 		struct usb_hcd *hcd = musb_to_hcd(musb);
 		handled = IRQ_HANDLED;
 		musb->is_active = 1;
 		musb->ep0_stage = MUSB_EP0_START;
 		/* flush endpoints when transitioning from Device Mode */
 		if (is_peripheral_active(musb)) {
 			/* REVISIT HNP; just force disconnect */
 		}
 		musb_writew(musb->mregs, MUSB_INTRTXE, musb->epmask);
 		musb_writew(musb->mregs, MUSB_INTRRXE, musb->epmask & 0xfffe);
 		musb_writeb(musb->mregs, MUSB_INTRUSBE, 0xf7);
 #ifndef __UBOOT__
 		musb->port1_status &= ~(USB_PORT_STAT_LOW_SPEED
 					|USB_PORT_STAT_HIGH_SPEED
 					|USB_PORT_STAT_ENABLE
 					);
 		musb->port1_status |= USB_PORT_STAT_CONNECTION
 					|(USB_PORT_STAT_C_CONNECTION << 16);
 		/* high vs full speed is just a guess until after reset */
 		if (devctl & MUSB_DEVCTL_LSDEV)
 			musb->port1_status |= USB_PORT_STAT_LOW_SPEED;
 		/* indicate new connection to OTG machine */
 		switch (musb->xceiv->state) {
 		case OTG_STATE_B_PERIPHERAL:
 			if (int_usb & MUSB_INTR_SUSPEND) {
 				dev_dbg(musb->controller, "HNP: SUSPEND+CONNECT, now b_host\n");
 				int_usb &= ~MUSB_INTR_SUSPEND;
 				goto b_host;
 			} else
 				dev_dbg(musb->controller, "CONNECT as b_peripheral???\n");
 			break;
 		case OTG_STATE_B_WAIT_ACON:
 			dev_dbg(musb->controller, "HNP: CONNECT, now b_host\n");
 b_host:
 			musb->xceiv->state = OTG_STATE_B_HOST;
 			hcd->self.is_b_host = 1;
 			musb->ignore_disconnect = 0;
 			del_timer(&musb->otg_timer);
 			break;
 		default:
 			if ((devctl & MUSB_DEVCTL_VBUS)
 					== (3 << MUSB_DEVCTL_VBUS_SHIFT)) {
 				musb->xceiv->state = OTG_STATE_A_HOST;
 				hcd->self.is_b_host = 0;
 			}
 			break;
 		}
 		/* poke the root hub */
 		MUSB_HST_MODE(musb);
 		if (hcd->status_urb)
 			usb_hcd_poll_rh_status(hcd);
 		else
 			usb_hcd_resume_root_hub(hcd);
 		dev_dbg(musb->controller, "CONNECT (%s) devctl %02x\n",
 				otg_state_string(musb->xceiv->state), devctl);
 #endif
 	}
 #ifndef __UBOOT__
 	if ((int_usb & MUSB_INTR_DISCONNECT) && !musb->ignore_disconnect) {
 		dev_dbg(musb->controller, "DISCONNECT (%s) as %s, devctl %02x\n",
 				otg_state_string(musb->xceiv->state),
 				MUSB_MODE(musb), devctl);
 		handled = IRQ_HANDLED;
 		switch (musb->xceiv->state) {
 		case OTG_STATE_A_HOST:
 		case OTG_STATE_A_SUSPEND:
 			usb_hcd_resume_root_hub(musb_to_hcd(musb));
 			musb_root_disconnect(musb);
 			if (musb->a_wait_bcon != 0 && is_otg_enabled(musb))
 				musb_platform_try_idle(musb, jiffies
 					+ msecs_to_jiffies(musb->a_wait_bcon));
 			break;
 		case OTG_STATE_B_HOST:
 			/* REVISIT this behaves for "real disconnect"
 			 * cases; make sure the other transitions from
 			 * from B_HOST act right too.  The B_HOST code
 			 * in hnp_stop() is currently not used...
 			 */
 			musb_root_disconnect(musb);
 			musb_to_hcd(musb)->self.is_b_host = 0;
 			musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
 			MUSB_DEV_MODE(musb);
 			musb_g_disconnect(musb);
 			break;
 		case OTG_STATE_A_PERIPHERAL:
 			musb_hnp_stop(musb);
 			musb_root_disconnect(musb);
 			/* FALLTHROUGH */
 		case OTG_STATE_B_WAIT_ACON:
 			/* FALLTHROUGH */
 		case OTG_STATE_B_PERIPHERAL:
 		case OTG_STATE_B_IDLE:
 			musb_g_disconnect(musb);
 			break;
 		default:
 			WARNING("unhandled DISCONNECT transition (%s)\n",
 				otg_state_string(musb->xceiv->state));
 			break;
 		}
 	}
 	/* mentor saves a bit: bus reset and babble share the same irq.
 	 * only host sees babble; only peripheral sees bus reset.
 	 */
 	if (int_usb & MUSB_INTR_RESET) {
 		handled = IRQ_HANDLED;
 		if (is_host_capable() && (devctl & MUSB_DEVCTL_HM) != 0) {
 			/*
 			 * Looks like non-HS BABBLE can be ignored, but
 			 * HS BABBLE is an error condition. For HS the solution
 			 * is to avoid babble in the first place and fix what
 			 * caused BABBLE. When HS BABBLE happens we can only
 			 * stop the session.
 			 */
 			if (devctl & (MUSB_DEVCTL_FSDEV | MUSB_DEVCTL_LSDEV))
 				dev_dbg(musb->controller, "BABBLE devctl: %02x\n", devctl);
 			else {
 				ERR("Stopping host session -- babble\n");
 				musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
 			}
 		} else if (is_peripheral_capable()) {
 			dev_dbg(musb->controller, "BUS RESET as %s\n",
 				otg_state_string(musb->xceiv->state));
 			switch (musb->xceiv->state) {
 			case OTG_STATE_A_SUSPEND:
 				/* We need to ignore disconnect on suspend
 				 * otherwise tusb 2.0 won't reconnect after a
 				 * power cycle, which breaks otg compliance.
 				 */
 				musb->ignore_disconnect = 1;
 				musb_g_reset(musb);
 				/* FALLTHROUGH */
 			case OTG_STATE_A_WAIT_BCON:	/* OPT TD.4.7-900ms */
 				/* never use invalid T(a_wait_bcon) */
 				dev_dbg(musb->controller, "HNP: in %s, %d msec timeout\n",
 					otg_state_string(musb->xceiv->state),
 					TA_WAIT_BCON(musb));
 				mod_timer(&musb->otg_timer, jiffies
 					+ msecs_to_jiffies(TA_WAIT_BCON(musb)));
 				break;
 			case OTG_STATE_A_PERIPHERAL:
 				musb->ignore_disconnect = 0;
 				del_timer(&musb->otg_timer);
 				musb_g_reset(musb);
 				break;
 			case OTG_STATE_B_WAIT_ACON:
 				dev_dbg(musb->controller, "HNP: RESET (%s), to b_peripheral\n",
 					otg_state_string(musb->xceiv->state));
 				musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
 				musb_g_reset(musb);
 				break;
 			case OTG_STATE_B_IDLE:
 				musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
 				/* FALLTHROUGH */
 			case OTG_STATE_B_PERIPHERAL:
 				musb_g_reset(musb);
 				break;
 			default:
 				dev_dbg(musb->controller, "Unhandled BUS RESET as %s\n",
 					otg_state_string(musb->xceiv->state));
 			}
 		}
 	}
 #endif
 #if 0
 /* REVISIT ... this would be for multiplexing periodic endpoints, or
  * supporting transfer phasing to prevent exceeding ISO bandwidth
  * limits of a given frame or microframe.
  *
  * It's not needed for peripheral side, which dedicates endpoints;
  * though it _might_ use SOF irqs for other purposes.
  *
  * And it's not currently needed for host side, which also dedicates
  * endpoints, relies on TX/RX interval registers, and isn't claimed
  * to support ISO transfers yet.
  */
 	if (int_usb & MUSB_INTR_SOF) {
 		void __iomem *mbase = musb->mregs;
 		struct musb_hw_ep	*ep;
 		u8 epnum;
 		u16 frame;
 		dev_dbg(musb->controller, "START_OF_FRAME\n");
 		handled = IRQ_HANDLED;
 		/* start any periodic Tx transfers waiting for current frame */
 		frame = musb_readw(mbase, MUSB_FRAME);
 		ep = musb->endpoints;
 		for (epnum = 1; (epnum < musb->nr_endpoints)
 					&& (musb->epmask >= (1 << epnum));
 				epnum++, ep++) {
 			/*
 			 * FIXME handle framecounter wraps (12 bits)
 			 * eliminate duplicated StartUrb logic
 			 */
 			if (ep->dwWaitFrame >= frame) {
 				ep->dwWaitFrame = 0;
 				pr_debug("SOF --> periodic TX%s on %d\n",
 					ep->tx_channel ? " DMA" : "",
 					epnum);
 				if (!ep->tx_channel)
 					musb_h_tx_start(musb, epnum);
 				else
 					cppi_hostdma_start(musb, epnum);
 			}
 		}		/* end of for loop */
 	}
 #endif
 	schedule_work(&musb->irq_work);
 	return handled;
 }
 /*-------------------------------------------------------------------------*/
 /*
 * Program the HDRC to start (enable interrupts, dma, etc.).
 */
 void musb_start(struct musb *musb)
 {
 	void __iomem	*regs = musb->mregs;
 	u8		devctl = musb_readb(regs, MUSB_DEVCTL);
 	dev_dbg(musb->controller, "<== devctl %02x\n", devctl);
 	/*  Set INT enable registers, enable interrupts */
 	musb_writew(regs, MUSB_INTRTXE, musb->epmask);
 	musb_writew(regs, MUSB_INTRRXE, musb->epmask & 0xfffe);
 	musb_writeb(regs, MUSB_INTRUSBE, 0xf7);
 	musb_writeb(regs, MUSB_TESTMODE, 0);
 	/* put into basic highspeed mode and start session */
 	musb_writeb(regs, MUSB_POWER, MUSB_POWER_ISOUPDATE
-#ifdef CONFIG_USB_GADGET_DUALSPEED
 						| MUSB_POWER_HSENAB
-#endif
 						/* ENSUSPEND wedges tusb */
 						/* | MUSB_POWER_ENSUSPEND */
 						);
 	musb->is_active = 0;
 	devctl = musb_readb(regs, MUSB_DEVCTL);
 	devctl &= ~MUSB_DEVCTL_SESSION;
 	if (is_otg_enabled(musb)) {
 #ifndef __UBOOT__
 		/* session started after:
 		 * (a) ID-grounded irq, host mode;
 		 * (b) vbus present/connect IRQ, peripheral mode;
 		 * (c) peripheral initiates, using SRP
 		 */
 		if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
 			musb->is_active = 1;
 		else
 			devctl |= MUSB_DEVCTL_SESSION;
 #endif
 	} else if (is_host_enabled(musb)) {
 		/* assume ID pin is hard-wired to ground */
 		devctl |= MUSB_DEVCTL_SESSION;
 	} else /* peripheral is enabled */ {
 		if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
 			musb->is_active = 1;
 	}
 	musb_platform_enable(musb);
 	musb_writeb(regs, MUSB_DEVCTL, devctl);
 }
 static void musb_generic_disable(struct musb *musb)
 {
 	void __iomem	*mbase = musb->mregs;
 	u16	temp;
 	/* disable interrupts */
 	musb_writeb(mbase, MUSB_INTRUSBE, 0);
 	musb_writew(mbase, MUSB_INTRTXE, 0);
 	musb_writew(mbase, MUSB_INTRRXE, 0);
 	/* off */
 	musb_writeb(mbase, MUSB_DEVCTL, 0);
 	/*  flush pending interrupts */
 	temp = musb_readb(mbase, MUSB_INTRUSB);
 	temp = musb_readw(mbase, MUSB_INTRTX);
 	temp = musb_readw(mbase, MUSB_INTRRX);
 }
 /*
  * Make the HDRC stop (disable interrupts, etc.);
  * reversible by musb_start
  * called on gadget driver unregister
  * with controller locked, irqs blocked
  * acts as a NOP unless some role activated the hardware
  */
 void musb_stop(struct musb *musb)
 {
 	/* stop IRQs, timers, ... */
 	musb_platform_disable(musb);
 	musb_generic_disable(musb);
 	dev_dbg(musb->controller, "HDRC disabled\n");
 	/* FIXME
 	 *  - mark host and/or peripheral drivers unusable/inactive
 	 *  - disable DMA (and enable it in HdrcStart)
 	 *  - make sure we can musb_start() after musb_stop(); with
 	 *    OTG mode, gadget driver module rmmod/modprobe cycles that
 	 *  - ...
 	 */
 	musb_platform_try_idle(musb, 0);
 }
 #ifndef __UBOOT__
 static void musb_shutdown(struct platform_device *pdev)
 {
 	struct musb	*musb = dev_to_musb(&pdev->dev);
 	unsigned long	flags;
 	pm_runtime_get_sync(musb->controller);
 	musb_gadget_cleanup(musb);
 	spin_lock_irqsave(&musb->lock, flags);
 	musb_platform_disable(musb);
 	musb_generic_disable(musb);
 	spin_unlock_irqrestore(&musb->lock, flags);
 	if (!is_otg_enabled(musb) && is_host_enabled(musb))
 		usb_remove_hcd(musb_to_hcd(musb));
 	musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
 	musb_platform_exit(musb);
 	pm_runtime_put(musb->controller);
 	/* FIXME power down */
 }
 #endif
 /*-------------------------------------------------------------------------*/
 /*
  * The silicon either has hard-wired endpoint configurations, or else
  * "dynamic fifo" sizing.  The driver has support for both, though at this
  * writing only the dynamic sizing is very well tested.   Since we switched
  * away from compile-time hardware parameters, we can no longer rely on
  * dead code elimination to leave only the relevant one in the object file.
  *
  * We don't currently use dynamic fifo setup capability to do anything
  * more than selecting one of a bunch of predefined configurations.
  */
 #if defined(CONFIG_USB_MUSB_TUSB6010)			\
 	|| defined(CONFIG_USB_MUSB_TUSB6010_MODULE)	\
 	|| defined(CONFIG_USB_MUSB_OMAP2PLUS)		\
 	|| defined(CONFIG_USB_MUSB_OMAP2PLUS_MODULE)	\
 	|| defined(CONFIG_USB_MUSB_AM35X)		\
 	|| defined(CONFIG_USB_MUSB_AM35X_MODULE)	\
 	|| defined(CONFIG_USB_MUSB_DSPS)		\
 	|| defined(CONFIG_USB_MUSB_DSPS_MODULE)
 static ushort __devinitdata fifo_mode = 4;
 #elif defined(CONFIG_USB_MUSB_UX500)			\
 	|| defined(CONFIG_USB_MUSB_UX500_MODULE)
 static ushort __devinitdata fifo_mode = 5;
 #else
 static ushort __devinitdata fifo_mode = 2;
 #endif
 /* "modprobe ... fifo_mode=1" etc */
 module_param(fifo_mode, ushort, 0);
 MODULE_PARM_DESC(fifo_mode, "initial endpoint configuration");
 /*
  * tables defining fifo_mode values.  define more if you like.
  * for host side, make sure both halves of ep1 are set up.
  */
 /* mode 0 - fits in 2KB */
 static struct musb_fifo_cfg __devinitdata mode_0_cfg[] = {
 { .hw_ep_num = 1, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num = 1, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num = 2, .style = FIFO_RXTX, .maxpacket = 512, },
 { .hw_ep_num = 3, .style = FIFO_RXTX, .maxpacket = 256, },
 { .hw_ep_num = 4, .style = FIFO_RXTX, .maxpacket = 256, },
 };
 /* mode 1 - fits in 4KB */
 static struct musb_fifo_cfg __devinitdata mode_1_cfg[] = {
 { .hw_ep_num = 1, .style = FIFO_TX,   .maxpacket = 512, .mode = BUF_DOUBLE, },
 { .hw_ep_num = 1, .style = FIFO_RX,   .maxpacket = 512, .mode = BUF_DOUBLE, },
 { .hw_ep_num = 2, .style = FIFO_RXTX, .maxpacket = 512, .mode = BUF_DOUBLE, },
 { .hw_ep_num = 3, .style = FIFO_RXTX, .maxpacket = 256, },
 { .hw_ep_num = 4, .style = FIFO_RXTX, .maxpacket = 256, },
 };
 /* mode 2 - fits in 4KB */
 static struct musb_fifo_cfg __devinitdata mode_2_cfg[] = {
 { .hw_ep_num = 1, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num = 1, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num = 2, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num = 2, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num = 3, .style = FIFO_RXTX, .maxpacket = 256, },
 { .hw_ep_num = 4, .style = FIFO_RXTX, .maxpacket = 256, },
 };
 /* mode 3 - fits in 4KB */
 static struct musb_fifo_cfg __devinitdata mode_3_cfg[] = {
 { .hw_ep_num = 1, .style = FIFO_TX,   .maxpacket = 512, .mode = BUF_DOUBLE, },
 { .hw_ep_num = 1, .style = FIFO_RX,   .maxpacket = 512, .mode = BUF_DOUBLE, },
 { .hw_ep_num = 2, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num = 2, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num = 3, .style = FIFO_RXTX, .maxpacket = 256, },
 { .hw_ep_num = 4, .style = FIFO_RXTX, .maxpacket = 256, },
 };
 /* mode 4 - fits in 16KB */
 static struct musb_fifo_cfg __devinitdata mode_4_cfg[] = {
 { .hw_ep_num =  1, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  1, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  2, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  2, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  3, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  3, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  4, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  4, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  5, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  5, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  6, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  6, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  7, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  7, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  8, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  8, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  9, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  9, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num = 10, .style = FIFO_TX,   .maxpacket = 256, },
 { .hw_ep_num = 10, .style = FIFO_RX,   .maxpacket = 64, },
 { .hw_ep_num = 11, .style = FIFO_TX,   .maxpacket = 256, },
 { .hw_ep_num = 11, .style = FIFO_RX,   .maxpacket = 64, },
 { .hw_ep_num = 12, .style = FIFO_TX,   .maxpacket = 256, },
 { .hw_ep_num = 12, .style = FIFO_RX,   .maxpacket = 64, },
 { .hw_ep_num = 13, .style = FIFO_RXTX, .maxpacket = 4096, },
 { .hw_ep_num = 14, .style = FIFO_RXTX, .maxpacket = 1024, },
 { .hw_ep_num = 15, .style = FIFO_RXTX, .maxpacket = 1024, },
 };
 /* mode 5 - fits in 8KB */
 static struct musb_fifo_cfg __devinitdata mode_5_cfg[] = {
 { .hw_ep_num =  1, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  1, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  2, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  2, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  3, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  3, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  4, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  4, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  5, .style = FIFO_TX,   .maxpacket = 512, },
 { .hw_ep_num =  5, .style = FIFO_RX,   .maxpacket = 512, },
 { .hw_ep_num =  6, .style = FIFO_TX,   .maxpacket = 32, },
 { .hw_ep_num =  6, .style = FIFO_RX,   .maxpacket = 32, },
 { .hw_ep_num =  7, .style = FIFO_TX,   .maxpacket = 32, },
 { .hw_ep_num =  7, .style = FIFO_RX,   .maxpacket = 32, },
 { .hw_ep_num =  8, .style = FIFO_TX,   .maxpacket = 32, },
 { .hw_ep_num =  8, .style = FIFO_RX,   .maxpacket = 32, },
 { .hw_ep_num =  9, .style = FIFO_TX,   .maxpacket = 32, },
 { .hw_ep_num =  9, .style = FIFO_RX,   .maxpacket = 32, },
 { .hw_ep_num = 10, .style = FIFO_TX,   .maxpacket = 32, },
 { .hw_ep_num = 10, .style = FIFO_RX,   .maxpacket = 32, },
 { .hw_ep_num = 11, .style = FIFO_TX,   .maxpacket = 32, },
 { .hw_ep_num = 11, .style = FIFO_RX,   .maxpacket = 32, },
 { .hw_ep_num = 12, .style = FIFO_TX,   .maxpacket = 32, },
 { .hw_ep_num = 12, .style = FIFO_RX,   .maxpacket = 32, },
 { .hw_ep_num = 13, .style = FIFO_RXTX, .maxpacket = 512, },
 { .hw_ep_num = 14, .style = FIFO_RXTX, .maxpacket = 1024, },
 { .hw_ep_num = 15, .style = FIFO_RXTX, .maxpacket = 1024, },
 };
 /*
  * configure a fifo; for non-shared endpoints, this may be called
  * once for a tx fifo and once for an rx fifo.
  *
  * returns negative errno or offset for next fifo.
  */
 static int __devinit
 fifo_setup(struct musb *musb, struct musb_hw_ep  *hw_ep,
 		const struct musb_fifo_cfg *cfg, u16 offset)
 {
 	void __iomem	*mbase = musb->mregs;
 	int	size = 0;
 	u16	maxpacket = cfg->maxpacket;
 	u16	c_off = offset >> 3;
 	u8	c_size;
 	/* expect hw_ep has already been zero-initialized */
 	size = ffs(max(maxpacket, (u16) 8)) - 1;
 	maxpacket = 1 << size;
 	c_size = size - 3;
 	if (cfg->mode == BUF_DOUBLE) {
 		if ((offset + (maxpacket << 1)) >
 				(1 << (musb->config->ram_bits + 2)))
 			return -EMSGSIZE;
 		c_size |= MUSB_FIFOSZ_DPB;
 	} else {
 		if ((offset + maxpacket) > (1 << (musb->config->ram_bits + 2)))
 			return -EMSGSIZE;
 	}
 	/* configure the FIFO */
 	musb_writeb(mbase, MUSB_INDEX, hw_ep->epnum);
 	/* EP0 reserved endpoint for control, bidirectional;
 	 * EP1 reserved for bulk, two unidirection halves.
 	 */
 	if (hw_ep->epnum == 1)
 		musb->bulk_ep = hw_ep;
 	/* REVISIT error check:  be sure ep0 can both rx and tx ... */
 	switch (cfg->style) {
 	case FIFO_TX:
 		musb_write_txfifosz(mbase, c_size);
 		musb_write_txfifoadd(mbase, c_off);
 		hw_ep->tx_double_buffered = !!(c_size & MUSB_FIFOSZ_DPB);
 		hw_ep->max_packet_sz_tx = maxpacket;
 		break;
 	case FIFO_RX:
 		musb_write_rxfifosz(mbase, c_size);
 		musb_write_rxfifoadd(mbase, c_off);
 		hw_ep->rx_double_buffered = !!(c_size & MUSB_FIFOSZ_DPB);
 		hw_ep->max_packet_sz_rx = maxpacket;
 		break;
 	case FIFO_RXTX:
 		musb_write_txfifosz(mbase, c_size);
 		musb_write_txfifoadd(mbase, c_off);
 		hw_ep->rx_double_buffered = !!(c_size & MUSB_FIFOSZ_DPB);
 		hw_ep->max_packet_sz_rx = maxpacket;
 		musb_write_rxfifosz(mbase, c_size);
 		musb_write_rxfifoadd(mbase, c_off);
 		hw_ep->tx_double_buffered = hw_ep->rx_double_buffered;
 		hw_ep->max_packet_sz_tx = maxpacket;
 		hw_ep->is_shared_fifo = true;
 		break;
 	}
 	/* NOTE rx and tx endpoint irqs aren't managed separately,
 	 * which happens to be ok
 	 */
 	musb->epmask |= (1 << hw_ep->epnum);
 	return offset + (maxpacket << ((c_size & MUSB_FIFOSZ_DPB) ? 1 : 0));
 }
 static struct musb_fifo_cfg __devinitdata ep0_cfg = {
 	.style = FIFO_RXTX, .maxpacket = 64,
 };
 static int __devinit ep_config_from_table(struct musb *musb)
 {
 	const struct musb_fifo_cfg	*cfg;
 	unsigned		i, n;
 	int			offset;
 	struct musb_hw_ep	*hw_ep = musb->endpoints;
 	if (musb->config->fifo_cfg) {
 		cfg = musb->config->fifo_cfg;
 		n = musb->config->fifo_cfg_size;
 		goto done;
 	}
 	switch (fifo_mode) {
 	default:
 		fifo_mode = 0;
 		/* FALLTHROUGH */
 	case 0:
 		cfg = mode_0_cfg;
 		n = ARRAY_SIZE(mode_0_cfg);
 		break;
 	case 1:
 		cfg = mode_1_cfg;
 		n = ARRAY_SIZE(mode_1_cfg);
 		break;
 	case 2:
 		cfg = mode_2_cfg;
 		n = ARRAY_SIZE(mode_2_cfg);
 		break;
 	case 3:
 		cfg = mode_3_cfg;
 		n = ARRAY_SIZE(mode_3_cfg);
 		break;
 	case 4:
 		cfg = mode_4_cfg;
 		n = ARRAY_SIZE(mode_4_cfg);
 		break;
 	case 5:
 		cfg = mode_5_cfg;
 		n = ARRAY_SIZE(mode_5_cfg);
 		break;
 	}
 	pr_debug("%s: setup fifo_mode %d\n", musb_driver_name, fifo_mode);
 done:
 	offset = fifo_setup(musb, hw_ep, &ep0_cfg, 0);
 	/* assert(offset > 0) */
 	/* NOTE:  for RTL versions >= 1.400 EPINFO and RAMINFO would
 	 * be better than static musb->config->num_eps and DYN_FIFO_SIZE...
 	 */
 	for (i = 0; i < n; i++) {
 		u8	epn = cfg->hw_ep_num;
 		if (epn >= musb->config->num_eps) {
 			pr_debug("%s: invalid ep %d\n",
 					musb_driver_name, epn);
 			return -EINVAL;
 		}
 		offset = fifo_setup(musb, hw_ep + epn, cfg++, offset);
 		if (offset < 0) {
 			pr_debug("%s: mem overrun, ep %d\n",
 					musb_driver_name, epn);
 			return -EINVAL;
 		}
 		epn++;
 		musb->nr_endpoints = max(epn, musb->nr_endpoints);
 	}
 	pr_debug("%s: %d/%d max ep, %d/%d memory\n", musb_driver_name, n + 1,
 		 musb->config->num_eps * 2 - 1, offset,
 		 (1 << (musb->config->ram_bits + 2)));
 	if (!musb->bulk_ep) {
 		pr_debug("%s: missing bulk\n", musb_driver_name);
 		return -EINVAL;
 	}
 	return 0;
 }
 /*
  * ep_config_from_hw - when MUSB_C_DYNFIFO_DEF is false
  * @param musb the controller
  */
 static int __devinit ep_config_from_hw(struct musb *musb)
 {
 	u8 epnum = 0;
 	struct musb_hw_ep *hw_ep;
 	void *mbase = musb->mregs;
 	int ret = 0;
 	dev_dbg(musb->controller, "<== static silicon ep config\n");
 	/* FIXME pick up ep0 maxpacket size */
 	for (epnum = 1; epnum < musb->config->num_eps; epnum++) {
 		musb_ep_select(mbase, epnum);
 		hw_ep = musb->endpoints + epnum;
 		ret = musb_read_fifosize(musb, hw_ep, epnum);
 		if (ret < 0)
 			break;
 		/* FIXME set up hw_ep->{rx,tx}_double_buffered */
 		/* pick an RX/TX endpoint for bulk */
 		if (hw_ep->max_packet_sz_tx < 512
 				|| hw_ep->max_packet_sz_rx < 512)
 			continue;
 		/* REVISIT:  this algorithm is lazy, we should at least
 		 * try to pick a double buffered endpoint.
 		 */
 		if (musb->bulk_ep)
 			continue;
 		musb->bulk_ep = hw_ep;
 	}
 	if (!musb->bulk_ep) {
 		pr_debug("%s: missing bulk\n", musb_driver_name);
 		return -EINVAL;
 	}
 	return 0;
 }
 enum { MUSB_CONTROLLER_MHDRC, MUSB_CONTROLLER_HDRC, };
 /* Initialize MUSB (M)HDRC part of the USB hardware subsystem;
  * configure endpoints, or take their config from silicon
  */
 static int __devinit musb_core_init(u16 musb_type, struct musb *musb)
 {
 	u8 reg;
 	char *type;
 	char aInfo[90], aRevision[32], aDate[12];
 	void __iomem	*mbase = musb->mregs;
 	int		status = 0;
 	int		i;
 	/* log core options (read using indexed model) */
 	reg = musb_read_configdata(mbase);
 	strcpy(aInfo, (reg & MUSB_CONFIGDATA_UTMIDW) ? "UTMI-16" : "UTMI-8");
 	if (reg & MUSB_CONFIGDATA_DYNFIFO) {
 		strcat(aInfo, ", dyn FIFOs");
 		musb->dyn_fifo = true;
 	}
 #ifndef CONFIG_MUSB_DISABLE_BULK_COMBINE_SPLIT
 	if (reg & MUSB_CONFIGDATA_MPRXE) {
 		strcat(aInfo, ", bulk combine");
 		musb->bulk_combine = true;
 	}
 	if (reg & MUSB_CONFIGDATA_MPTXE) {
 		strcat(aInfo, ", bulk split");
 		musb->bulk_split = true;
 	}
 #else
 	musb->bulk_combine = false;
 	musb->bulk_split = false;
 #endif
 	if (reg & MUSB_CONFIGDATA_HBRXE) {
 		strcat(aInfo, ", HB-ISO Rx");
 		musb->hb_iso_rx = true;
 	}
 	if (reg & MUSB_CONFIGDATA_HBTXE) {
 		strcat(aInfo, ", HB-ISO Tx");
 		musb->hb_iso_tx = true;
 	}
 	if (reg & MUSB_CONFIGDATA_SOFTCONE)
 		strcat(aInfo, ", SoftConn");
 	pr_debug("%s:ConfigData=0x%02x (%s)\n", musb_driver_name, reg, aInfo);
 	aDate[0] = 0;
 	if (MUSB_CONTROLLER_MHDRC == musb_type) {
 		musb->is_multipoint = 1;
 		type = "M";
 	} else {
 		musb->is_multipoint = 0;
 		type = "";
 #ifndef	CONFIG_USB_OTG_BLACKLIST_HUB
 		printk(KERN_ERR
 			"%s: kernel must blacklist external hubs\n",
 			musb_driver_name);
 #endif
 	}
 	/* log release info */
 	musb->hwvers = musb_read_hwvers(mbase);
 	snprintf(aRevision, 32, "%d.%d%s", MUSB_HWVERS_MAJOR(musb->hwvers),
 		MUSB_HWVERS_MINOR(musb->hwvers),
 		(musb->hwvers & MUSB_HWVERS_RC) ? "RC" : "");
 	pr_debug("%s: %sHDRC RTL version %s %s\n", musb_driver_name, type,
 		 aRevision, aDate);
 	/* configure ep0 */
 	musb_configure_ep0(musb);
 	/* discover endpoint configuration */
 	musb->nr_endpoints = 1;
 	musb->epmask = 1;
 	if (musb->dyn_fifo)
 		status = ep_config_from_table(musb);
 	else
 		status = ep_config_from_hw(musb);
 	if (status < 0)
 		return status;
 	/* finish init, and print endpoint config */
 	for (i = 0; i < musb->nr_endpoints; i++) {
 		struct musb_hw_ep	*hw_ep = musb->endpoints + i;
 		hw_ep->fifo = MUSB_FIFO_OFFSET(i) + mbase;
 #if defined(CONFIG_USB_MUSB_TUSB6010) || defined (CONFIG_USB_MUSB_TUSB6010_MODULE)
 		hw_ep->fifo_async = musb->async + 0x400 + MUSB_FIFO_OFFSET(i);
 		hw_ep->fifo_sync = musb->sync + 0x400 + MUSB_FIFO_OFFSET(i);
 		hw_ep->fifo_sync_va =
 			musb->sync_va + 0x400 + MUSB_FIFO_OFFSET(i);
 		if (i == 0)
 			hw_ep->conf = mbase - 0x400 + TUSB_EP0_CONF;
 		else
 			hw_ep->conf = mbase + 0x400 + (((i - 1) & 0xf) << 2);
 #endif
 		hw_ep->regs = MUSB_EP_OFFSET(i, 0) + mbase;
 		hw_ep->target_regs = musb_read_target_reg_base(i, mbase);
 		hw_ep->rx_reinit = 1;
 		hw_ep->tx_reinit = 1;
 		if (hw_ep->max_packet_sz_tx) {
 			dev_dbg(musb->controller,
 				"%s: hw_ep %d%s, %smax %d\n",
 				musb_driver_name, i,
 				hw_ep->is_shared_fifo ? "shared" : "tx",
 				hw_ep->tx_double_buffered
 					? "doublebuffer, " : "",
 				hw_ep->max_packet_sz_tx);
 		}
 		if (hw_ep->max_packet_sz_rx && !hw_ep->is_shared_fifo) {
 			dev_dbg(musb->controller,
 				"%s: hw_ep %d%s, %smax %d\n",
 				musb_driver_name, i,
 				"rx",
 				hw_ep->rx_double_buffered
 					? "doublebuffer, " : "",
 				hw_ep->max_packet_sz_rx);
 		}
 		if (!(hw_ep->max_packet_sz_tx || hw_ep->max_packet_sz_rx))
 			dev_dbg(musb->controller, "hw_ep %d not configured\n", i);
 	}
 	return 0;
 }
 /*-------------------------------------------------------------------------*/
 #if defined(CONFIG_SOC_OMAP2430) || defined(CONFIG_SOC_OMAP3430) || \
 	defined(CONFIG_ARCH_OMAP4) || defined(CONFIG_ARCH_U8500)
 static irqreturn_t generic_interrupt(int irq, void *__hci)
 {
 	unsigned long	flags;
 	irqreturn_t	retval = IRQ_NONE;
 	struct musb	*musb = __hci;
 	spin_lock_irqsave(&musb->lock, flags);
 	musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
 	musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);
 	musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);
 	if (musb->int_usb || musb->int_tx || musb->int_rx)
 		retval = musb_interrupt(musb);
 	spin_unlock_irqrestore(&musb->lock, flags);
 	return retval;
 }
 #else
 #define generic_interrupt	NULL
 #endif
 /*
  * handle all the irqs defined by the HDRC core. for now we expect:  other
  * irq sources (phy, dma, etc) will be handled first, musb->int_* values
  * will be assigned, and the irq will already have been acked.
  *
  * called in irq context with spinlock held, irqs blocked
  */
 irqreturn_t musb_interrupt(struct musb *musb)
 {
 	irqreturn_t	retval = IRQ_NONE;
 	u8		devctl, power;
 	int		ep_num;
 	u32		reg;
 	devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 	power = musb_readb(musb->mregs, MUSB_POWER);
 	dev_dbg(musb->controller, "** IRQ %s usb%04x tx%04x rx%04x\n",
 		(devctl & MUSB_DEVCTL_HM) ? "host" : "peripheral",
 		musb->int_usb, musb->int_tx, musb->int_rx);
 	/* the core can interrupt us for multiple reasons; docs have
 	 * a generic interrupt flowchart to follow
 	 */
 	if (musb->int_usb)
 		retval |= musb_stage0_irq(musb, musb->int_usb,
 				devctl, power);
 	/* "stage 1" is handling endpoint irqs */
 	/* handle endpoint 0 first */
 	if (musb->int_tx & 1) {
 		if (devctl & MUSB_DEVCTL_HM) {
 			if (is_host_capable())
 				retval |= musb_h_ep0_irq(musb);
 		} else {
 			if (is_peripheral_capable())
 				retval |= musb_g_ep0_irq(musb);
 		}
 	}
 	/* RX on endpoints 1-15 */
 	reg = musb->int_rx >> 1;
 	ep_num = 1;
 	while (reg) {
 		if (reg & 1) {
 			/* musb_ep_select(musb->mregs, ep_num); */
 			/* REVISIT just retval = ep->rx_irq(...) */
 			retval = IRQ_HANDLED;
 			if (devctl & MUSB_DEVCTL_HM) {
 				if (is_host_capable())
 					musb_host_rx(musb, ep_num);
 			} else {
 				if (is_peripheral_capable())
 					musb_g_rx(musb, ep_num);
 			}
 		}
 		reg >>= 1;
 		ep_num++;
 	}
 	/* TX on endpoints 1-15 */
 	reg = musb->int_tx >> 1;
 	ep_num = 1;
 	while (reg) {
 		if (reg & 1) {
 			/* musb_ep_select(musb->mregs, ep_num); */
 			/* REVISIT just retval |= ep->tx_irq(...) */
 			retval = IRQ_HANDLED;
 			if (devctl & MUSB_DEVCTL_HM) {
 				if (is_host_capable())
 					musb_host_tx(musb, ep_num);
 			} else {
 				if (is_peripheral_capable())
 					musb_g_tx(musb, ep_num);
 			}
 		}
 		reg >>= 1;
 		ep_num++;
 	}
 	return retval;
 }
 EXPORT_SYMBOL_GPL(musb_interrupt);
 #ifndef CONFIG_MUSB_PIO_ONLY
 static bool __devinitdata use_dma = 1;
 /* "modprobe ... use_dma=0" etc */
 module_param(use_dma, bool, 0);
 MODULE_PARM_DESC(use_dma, "enable/disable use of DMA");
 void musb_dma_completion(struct musb *musb, u8 epnum, u8 transmit)
 {
 	u8	devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 	/* called with controller lock already held */
 	if (!epnum) {
 #ifndef CONFIG_USB_TUSB_OMAP_DMA
 		if (!is_cppi_enabled()) {
 			/* endpoint 0 */
 			if (devctl & MUSB_DEVCTL_HM)
 				musb_h_ep0_irq(musb);
 			else
 				musb_g_ep0_irq(musb);
 		}
 #endif
 	} else {
 		/* endpoints 1..15 */
 		if (transmit) {
 			if (devctl & MUSB_DEVCTL_HM) {
 				if (is_host_capable())
 					musb_host_tx(musb, epnum);
 			} else {
 				if (is_peripheral_capable())
 					musb_g_tx(musb, epnum);
 			}
 		} else {
 			/* receive */
 			if (devctl & MUSB_DEVCTL_HM) {
 				if (is_host_capable())
 					musb_host_rx(musb, epnum);
 			} else {
 				if (is_peripheral_capable())
 					musb_g_rx(musb, epnum);
 			}
 		}
 	}
 }
 EXPORT_SYMBOL_GPL(musb_dma_completion);
 #else
 #define use_dma			0
 #endif
 /*-------------------------------------------------------------------------*/
 #ifdef CONFIG_SYSFS
 static ssize_t
 musb_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct musb *musb = dev_to_musb(dev);
 	unsigned long flags;
 	int ret = -EINVAL;
 	spin_lock_irqsave(&musb->lock, flags);
 	ret = sprintf(buf, "%s\n", otg_state_string(musb->xceiv->state));
 	spin_unlock_irqrestore(&musb->lock, flags);
 	return ret;
 }
 static ssize_t
 musb_mode_store(struct device *dev, struct device_attribute *attr,
 		const char *buf, size_t n)
 {
 	struct musb	*musb = dev_to_musb(dev);
 	unsigned long	flags;
 	int		status;
 	spin_lock_irqsave(&musb->lock, flags);
 	if (sysfs_streq(buf, "host"))
 		status = musb_platform_set_mode(musb, MUSB_HOST);
 	else if (sysfs_streq(buf, "peripheral"))
 		status = musb_platform_set_mode(musb, MUSB_PERIPHERAL);
 	else if (sysfs_streq(buf, "otg"))
 		status = musb_platform_set_mode(musb, MUSB_OTG);
 	else
 		status = -EINVAL;
 	spin_unlock_irqrestore(&musb->lock, flags);
 	return (status == 0) ? n : status;
 }
 static DEVICE_ATTR(mode, 0644, musb_mode_show, musb_mode_store);
 static ssize_t
 musb_vbus_store(struct device *dev, struct device_attribute *attr,
 		const char *buf, size_t n)
 {
 	struct musb	*musb = dev_to_musb(dev);
 	unsigned long	flags;
 	unsigned long	val;
 	if (sscanf(buf, "%lu", &val) < 1) {
 		dev_err(dev, "Invalid VBUS timeout ms value\n");
 		return -EINVAL;
 	}
 	spin_lock_irqsave(&musb->lock, flags);
 	/* force T(a_wait_bcon) to be zero/unlimited *OR* valid */
 	musb->a_wait_bcon = val ? max_t(int, val, OTG_TIME_A_WAIT_BCON) : 0 ;
 	if (musb->xceiv->state == OTG_STATE_A_WAIT_BCON)
 		musb->is_active = 0;
 	musb_platform_try_idle(musb, jiffies + msecs_to_jiffies(val));
 	spin_unlock_irqrestore(&musb->lock, flags);
 	return n;
 }
 static ssize_t
 musb_vbus_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
 	struct musb	*musb = dev_to_musb(dev);
 	unsigned long	flags;
 	unsigned long	val;
 	int		vbus;
 	spin_lock_irqsave(&musb->lock, flags);
 	val = musb->a_wait_bcon;
 	/* FIXME get_vbus_status() is normally #defined as false...
 	 * and is effectively TUSB-specific.
 	 */
 	vbus = musb_platform_get_vbus_status(musb);
 	spin_unlock_irqrestore(&musb->lock, flags);
 	return sprintf(buf, "Vbus %s, timeout %lu msec\n",
 			vbus ? "on" : "off", val);
 }
 static DEVICE_ATTR(vbus, 0644, musb_vbus_show, musb_vbus_store);
 /* Gadget drivers can't know that a host is connected so they might want
  * to start SRP, but users can.  This allows userspace to trigger SRP.
  */
 static ssize_t
 musb_srp_store(struct device *dev, struct device_attribute *attr,
 		const char *buf, size_t n)
 {
 	struct musb	*musb = dev_to_musb(dev);
 	unsigned short	srp;
 	if (sscanf(buf, "%hu", &srp) != 1
 			|| (srp != 1)) {
 		dev_err(dev, "SRP: Value must be 1\n");
 		return -EINVAL;
 	}
 	if (srp == 1)
 		musb_g_wakeup(musb);
 	return n;
 }
 static DEVICE_ATTR(srp, 0644, NULL, musb_srp_store);
 static struct attribute *musb_attributes[] = {
 	&dev_attr_mode.attr,
 	&dev_attr_vbus.attr,
 	&dev_attr_srp.attr,
 	NULL
 };
 static const struct attribute_group musb_attr_group = {
 	.attrs = musb_attributes,
 };
 #endif	/* sysfs */
 #ifndef __UBOOT__
 /* Only used to provide driver mode change events */
 static void musb_irq_work(struct work_struct *data)
 {
 	struct musb *musb = container_of(data, struct musb, irq_work);
 	static int old_state;
 	if (musb->xceiv->state != old_state) {
 		old_state = musb->xceiv->state;
 		sysfs_notify(&musb->controller->kobj, NULL, "mode");
 	}
 }
 #endif
 /* --------------------------------------------------------------------------
  * Init support
  */
 static struct musb *__devinit
 allocate_instance(struct device *dev,
 		struct musb_hdrc_config *config, void __iomem *mbase)
 {
 	struct musb		*musb;
 	struct musb_hw_ep	*ep;
 	int			epnum;
 #ifndef __UBOOT__
 	struct usb_hcd	*hcd;
 	hcd = usb_create_hcd(&musb_hc_driver, dev, dev_name(dev));
 	if (!hcd)
 		return NULL;
 	/* usbcore sets dev->driver_data to hcd, and sometimes uses that... */
 	musb = hcd_to_musb(hcd);
 #else
 	musb = calloc(1, sizeof(*musb));
 	if (!musb)
 		return NULL;
 #endif
 	INIT_LIST_HEAD(&musb->control);
 	INIT_LIST_HEAD(&musb->in_bulk);
 	INIT_LIST_HEAD(&musb->out_bulk);
 #ifndef __UBOOT__
 	hcd->uses_new_polling = 1;
 	hcd->has_tt = 1;
 #endif
 	musb->vbuserr_retry = VBUSERR_RETRY_COUNT;
 	musb->a_wait_bcon = OTG_TIME_A_WAIT_BCON;
 	dev_set_drvdata(dev, musb);
 	musb->mregs = mbase;
 	musb->ctrl_base = mbase;
 	musb->nIrq = -ENODEV;
 	musb->config = config;
 	BUG_ON(musb->config->num_eps > MUSB_C_NUM_EPS);
 	for (epnum = 0, ep = musb->endpoints;
 			epnum < musb->config->num_eps;
 			epnum++, ep++) {
 		ep->musb = musb;
 		ep->epnum = epnum;
 	}
 	musb->controller = dev;
 	return musb;
 }
 static void musb_free(struct musb *musb)
 {
 	/* this has multiple entry modes. it handles fault cleanup after
 	 * probe(), where things may be partially set up, as well as rmmod
 	 * cleanup after everything's been de-activated.
 	 */
 #ifdef CONFIG_SYSFS
 	sysfs_remove_group(&musb->controller->kobj, &musb_attr_group);
 #endif
 	if (musb->nIrq >= 0) {
 		if (musb->irq_wake)
 			disable_irq_wake(musb->nIrq);
 		free_irq(musb->nIrq, musb);
 	}
 	if (is_dma_capable() && musb->dma_controller) {
 		struct dma_controller	*c = musb->dma_controller;
 		(void) c->stop(c);
 		dma_controller_destroy(c);
 	}
 	kfree(musb);
 }
 /*
  * Perform generic per-controller initialization.
  *
  * @pDevice: the controller (already clocked, etc)
  * @nIrq: irq
  * @mregs: virtual address of controller registers,
  *	not yet corrected for platform-specific offsets
  */
 #ifndef __UBOOT__
 static int __devinit
 musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
 #else
 struct musb *
 musb_init_controller(struct musb_hdrc_platform_data *plat, struct device *dev,
 			     void *ctrl)
 #endif
 {
 	int			status;
 	struct musb		*musb;
 #ifndef __UBOOT__
 	struct musb_hdrc_platform_data *plat = dev->platform_data;
 #else
 	int nIrq = 0;
 #endif
 	/* The driver might handle more features than the board; OK.
 	 * Fail when the board needs a feature that's not enabled.
 	 */
 	if (!plat) {
 		dev_dbg(dev, "no platform_data?\n");
 		status = -ENODEV;
 		goto fail0;
 	}
 	/* allocate */
 	musb = allocate_instance(dev, plat->config, ctrl);
 	if (!musb) {
 		status = -ENOMEM;
 		goto fail0;
 	}
 	pm_runtime_use_autosuspend(musb->controller);
 	pm_runtime_set_autosuspend_delay(musb->controller, 200);
 	pm_runtime_enable(musb->controller);
 	spin_lock_init(&musb->lock);
 	musb->board_mode = plat->mode;
 	musb->board_set_power = plat->set_power;
 	musb->min_power = plat->min_power;
 	musb->ops = plat->platform_ops;
 	/* The musb_platform_init() call:
 	 *   - adjusts musb->mregs and musb->isr if needed,
 	 *   - may initialize an integrated tranceiver
 	 *   - initializes musb->xceiv, usually by otg_get_phy()
 	 *   - stops powering VBUS
 	 *
 	 * There are various transceiver configurations.  Blackfin,
 	 * DaVinci, TUSB60x0, and others integrate them.  OMAP3 uses
 	 * external/discrete ones in various flavors (twl4030 family,
 	 * isp1504, non-OTG, etc) mostly hooking up through ULPI.
 	 */
 	musb->isr = generic_interrupt;
 	status = musb_platform_init(musb);
 	if (status < 0)
 		goto fail1;
 	if (!musb->isr) {
 		status = -ENODEV;
 		goto fail2;
 	}
 #ifndef __UBOOT__
 	if (!musb->xceiv->io_ops) {
 		musb->xceiv->io_dev = musb->controller;
 		musb->xceiv->io_priv = musb->mregs;
 		musb->xceiv->io_ops = &musb_ulpi_access;
 	}
 #endif
 	pm_runtime_get_sync(musb->controller);
 #ifndef CONFIG_MUSB_PIO_ONLY
 	if (use_dma && dev->dma_mask) {
 		struct dma_controller	*c;
 		c = dma_controller_create(musb, musb->mregs);
 		musb->dma_controller = c;
 		if (c)
 			(void) c->start(c);
 	}
 #endif
 #ifndef __UBOOT__
 	/* ideally this would be abstracted in platform setup */
 	if (!is_dma_capable() || !musb->dma_controller)
 		dev->dma_mask = NULL;
 #endif
 	/* be sure interrupts are disabled before connecting ISR */
 	musb_platform_disable(musb);
 	musb_generic_disable(musb);
 	/* setup musb parts of the core (especially endpoints) */
 	status = musb_core_init(plat->config->multipoint
 			? MUSB_CONTROLLER_MHDRC
 			: MUSB_CONTROLLER_HDRC, musb);
 	if (status < 0)
 		goto fail3;
 	setup_timer(&musb->otg_timer, musb_otg_timer_func, (unsigned long) musb);
 	/* Init IRQ workqueue before request_irq */
 	INIT_WORK(&musb->irq_work, musb_irq_work);
 	/* attach to the IRQ */
 	if (request_irq(nIrq, musb->isr, 0, dev_name(dev), musb)) {
 		dev_err(dev, "request_irq %d failed!\n", nIrq);
 		status = -ENODEV;
 		goto fail3;
 	}
 	musb->nIrq = nIrq;
 /* FIXME this handles wakeup irqs wrong */
 	if (enable_irq_wake(nIrq) == 0) {
 		musb->irq_wake = 1;
 		device_init_wakeup(dev, 1);
 	} else {
 		musb->irq_wake = 0;
 	}
 #ifndef __UBOOT__
 	/* host side needs more setup */
 	if (is_host_enabled(musb)) {
 		struct usb_hcd	*hcd = musb_to_hcd(musb);
 		otg_set_host(musb->xceiv->otg, &hcd->self);
 		if (is_otg_enabled(musb))
 			hcd->self.otg_port = 1;
 		musb->xceiv->otg->host = &hcd->self;
 		hcd->power_budget = 2 * (plat->power ? : 250);
 		/* program PHY to use external vBus if required */
 		if (plat->extvbus) {
 			u8 busctl = musb_read_ulpi_buscontrol(musb->mregs);
 			busctl |= MUSB_ULPI_USE_EXTVBUS;
 			musb_write_ulpi_buscontrol(musb->mregs, busctl);
 		}
 	}
 #endif
 	/* For the host-only role, we can activate right away.
 	 * (We expect the ID pin to be forcibly grounded!!)
 	 * Otherwise, wait till the gadget driver hooks up.
 	 */
 	if (!is_otg_enabled(musb) && is_host_enabled(musb)) {
 		struct usb_hcd	*hcd = musb_to_hcd(musb);
 		MUSB_HST_MODE(musb);
 #ifndef __UBOOT__
 		musb->xceiv->otg->default_a = 1;
 		musb->xceiv->state = OTG_STATE_A_IDLE;
 		status = usb_add_hcd(musb_to_hcd(musb), 0, 0);
 		hcd->self.uses_pio_for_control = 1;
 		dev_dbg(musb->controller, "%s mode, status %d, devctl %02x %c\n",
 			"HOST", status,
 			musb_readb(musb->mregs, MUSB_DEVCTL),
 			(musb_readb(musb->mregs, MUSB_DEVCTL)
 					& MUSB_DEVCTL_BDEVICE
 				? 'B' : 'A'));
 #endif
 	} else /* peripheral is enabled */ {
 		MUSB_DEV_MODE(musb);
 #ifndef __UBOOT__
 		musb->xceiv->otg->default_a = 0;
 		musb->xceiv->state = OTG_STATE_B_IDLE;
 #endif
 		if (is_peripheral_capable())
 			status = musb_gadget_setup(musb);
 #ifndef __UBOOT__
 		dev_dbg(musb->controller, "%s mode, status %d, dev%02x\n",
 			is_otg_enabled(musb) ? "OTG" : "PERIPHERAL",
 			status,
 			musb_readb(musb->mregs, MUSB_DEVCTL));
 #endif
 	}
 	if (status < 0)
 		goto fail3;
 	status = musb_init_debugfs(musb);
 	if (status < 0)
 		goto fail4;
 #ifdef CONFIG_SYSFS
 	status = sysfs_create_group(&musb->controller->kobj, &musb_attr_group);
 	if (status)
 		goto fail5;
 #endif
 	pm_runtime_put(musb->controller);
 	pr_debug("USB %s mode controller at %p using %s, IRQ %d\n",
 			({char *s;
 			 switch (musb->board_mode) {
 			 case MUSB_HOST:		s = "Host"; break;
 			 case MUSB_PERIPHERAL:	s = "Peripheral"; break;
 			 default:		s = "OTG"; break;
 			 }; s; }),
 			ctrl,
 			(is_dma_capable() && musb->dma_controller)
 			? "DMA" : "PIO",
 			musb->nIrq);
 #ifndef __UBOOT__
 	return 0;
 #else
 	return status == 0 ? musb : NULL;
 #endif
 fail5:
 	musb_exit_debugfs(musb);
 fail4:
 #ifndef __UBOOT__
 	if (!is_otg_enabled(musb) && is_host_enabled(musb))
 		usb_remove_hcd(musb_to_hcd(musb));
 	else
 #endif
 		musb_gadget_cleanup(musb);
 fail3:
 	pm_runtime_put_sync(musb->controller);
 fail2:
 	if (musb->irq_wake)
 		device_init_wakeup(dev, 0);
 	musb_platform_exit(musb);
 fail1:
 	dev_err(musb->controller,
 		"musb_init_controller failed with status %d\n", status);
 	musb_free(musb);
 fail0:
 #ifndef __UBOOT__
 	return status;
 #else
 	return status == 0 ? musb : NULL;
 #endif
 }
 /*-------------------------------------------------------------------------*/
 /* all implementations (PCI bridge to FPGA, VLYNQ, etc) should just
  * bridge to a platform device; this driver then suffices.
  */
 #ifndef CONFIG_MUSB_PIO_ONLY
 static u64	*orig_dma_mask;
 #endif
 #ifndef __UBOOT__
 static int __devinit musb_probe(struct platform_device *pdev)
 {
 	struct device	*dev = &pdev->dev;
 	int		irq = platform_get_irq_byname(pdev, "mc");
 	int		status;
 	struct resource	*iomem;
 	void __iomem	*base;
 	iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!iomem || irq <= 0)
 		return -ENODEV;
 	base = ioremap(iomem->start, resource_size(iomem));
 	if (!base) {
 		dev_err(dev, "ioremap failed\n");
 		return -ENOMEM;
 	}
 #ifndef CONFIG_MUSB_PIO_ONLY
 	/* clobbered by use_dma=n */
 	orig_dma_mask = dev->dma_mask;
 #endif
 	status = musb_init_controller(dev, irq, base);
 	if (status < 0)
 		iounmap(base);
 	return status;
 }
 static int __devexit musb_remove(struct platform_device *pdev)
 {
 	struct musb	*musb = dev_to_musb(&pdev->dev);
 	void __iomem	*ctrl_base = musb->ctrl_base;
 	/* this gets called on rmmod.
 	 *  - Host mode: host may still be active
 	 *  - Peripheral mode: peripheral is deactivated (or never-activated)
 	 *  - OTG mode: both roles are deactivated (or never-activated)
 	 */
 	musb_exit_debugfs(musb);
 	musb_shutdown(pdev);
 	musb_free(musb);
 	iounmap(ctrl_base);
 	device_init_wakeup(&pdev->dev, 0);
 #ifndef CONFIG_MUSB_PIO_ONLY
 	pdev->dev.dma_mask = orig_dma_mask;
 #endif
 	return 0;
 }
 #ifdef	CONFIG_PM
 static void musb_save_context(struct musb *musb)
 {
 	int i;
 	void __iomem *musb_base = musb->mregs;
 	void __iomem *epio;
 	if (is_host_enabled(musb)) {
 		musb->context.frame = musb_readw(musb_base, MUSB_FRAME);
 		musb->context.testmode = musb_readb(musb_base, MUSB_TESTMODE);
 		musb->context.busctl = musb_read_ulpi_buscontrol(musb->mregs);
 	}
 	musb->context.power = musb_readb(musb_base, MUSB_POWER);
 	musb->context.intrtxe = musb_readw(musb_base, MUSB_INTRTXE);
 	musb->context.intrrxe = musb_readw(musb_base, MUSB_INTRRXE);
 	musb->context.intrusbe = musb_readb(musb_base, MUSB_INTRUSBE);
 	musb->context.index = musb_readb(musb_base, MUSB_INDEX);
 	musb->context.devctl = musb_readb(musb_base, MUSB_DEVCTL);
 	for (i = 0; i < musb->config->num_eps; ++i) {
 		struct musb_hw_ep	*hw_ep;
 		hw_ep = &musb->endpoints[i];
 		if (!hw_ep)
 			continue;
 		epio = hw_ep->regs;
 		if (!epio)
 			continue;
 		musb_writeb(musb_base, MUSB_INDEX, i);
 		musb->context.index_regs[i].txmaxp =
 			musb_readw(epio, MUSB_TXMAXP);
 		musb->context.index_regs[i].txcsr =
 			musb_readw(epio, MUSB_TXCSR);
 		musb->context.index_regs[i].rxmaxp =
 			musb_readw(epio, MUSB_RXMAXP);
 		musb->context.index_regs[i].rxcsr =
 			musb_readw(epio, MUSB_RXCSR);
 		if (musb->dyn_fifo) {
 			musb->context.index_regs[i].txfifoadd =
 					musb_read_txfifoadd(musb_base);
 			musb->context.index_regs[i].rxfifoadd =
 					musb_read_rxfifoadd(musb_base);
 			musb->context.index_regs[i].txfifosz =
 					musb_read_txfifosz(musb_base);
 			musb->context.index_regs[i].rxfifosz =
 					musb_read_rxfifosz(musb_base);
 		}
 		if (is_host_enabled(musb)) {
 			musb->context.index_regs[i].txtype =
 				musb_readb(epio, MUSB_TXTYPE);
 			musb->context.index_regs[i].txinterval =
 				musb_readb(epio, MUSB_TXINTERVAL);
 			musb->context.index_regs[i].rxtype =
 				musb_readb(epio, MUSB_RXTYPE);
 			musb->context.index_regs[i].rxinterval =
 				musb_readb(epio, MUSB_RXINTERVAL);
 			musb->context.index_regs[i].txfunaddr =
 				musb_read_txfunaddr(musb_base, i);
 			musb->context.index_regs[i].txhubaddr =
 				musb_read_txhubaddr(musb_base, i);
 			musb->context.index_regs[i].txhubport =
 				musb_read_txhubport(musb_base, i);
 			musb->context.index_regs[i].rxfunaddr =
 				musb_read_rxfunaddr(musb_base, i);
 			musb->context.index_regs[i].rxhubaddr =
 				musb_read_rxhubaddr(musb_base, i);
 			musb->context.index_regs[i].rxhubport =
 				musb_read_rxhubport(musb_base, i);
 		}
 	}
 }
 static void musb_restore_context(struct musb *musb)
 {
 	int i;
 	void __iomem *musb_base = musb->mregs;
 	void __iomem *ep_target_regs;
 	void __iomem *epio;
 	if (is_host_enabled(musb)) {
 		musb_writew(musb_base, MUSB_FRAME, musb->context.frame);
 		musb_writeb(musb_base, MUSB_TESTMODE, musb->context.testmode);
 		musb_write_ulpi_buscontrol(musb->mregs, musb->context.busctl);
 	}
 	musb_writeb(musb_base, MUSB_POWER, musb->context.power);
 	musb_writew(musb_base, MUSB_INTRTXE, musb->context.intrtxe);
 	musb_writew(musb_base, MUSB_INTRRXE, musb->context.intrrxe);
 	musb_writeb(musb_base, MUSB_INTRUSBE, musb->context.intrusbe);
 	musb_writeb(musb_base, MUSB_DEVCTL, musb->context.devctl);
 	for (i = 0; i < musb->config->num_eps; ++i) {
 		struct musb_hw_ep	*hw_ep;
 		hw_ep = &musb->endpoints[i];
 		if (!hw_ep)
 			continue;
 		epio = hw_ep->regs;
 		if (!epio)
 			continue;
 		musb_writeb(musb_base, MUSB_INDEX, i);
 		musb_writew(epio, MUSB_TXMAXP,
 			musb->context.index_regs[i].txmaxp);
 		musb_writew(epio, MUSB_TXCSR,
 			musb->context.index_regs[i].txcsr);
 		musb_writew(epio, MUSB_RXMAXP,
 			musb->context.index_regs[i].rxmaxp);
 		musb_writew(epio, MUSB_RXCSR,
 			musb->context.index_regs[i].rxcsr);
 		if (musb->dyn_fifo) {
 			musb_write_txfifosz(musb_base,
 				musb->context.index_regs[i].txfifosz);
 			musb_write_rxfifosz(musb_base,
 				musb->context.index_regs[i].rxfifosz);
 			musb_write_txfifoadd(musb_base,
 				musb->context.index_regs[i].txfifoadd);
 			musb_write_rxfifoadd(musb_base,
 				musb->context.index_regs[i].rxfifoadd);
 		}
 		if (is_host_enabled(musb)) {
 			musb_writeb(epio, MUSB_TXTYPE,
 				musb->context.index_regs[i].txtype);
 			musb_writeb(epio, MUSB_TXINTERVAL,
 				musb->context.index_regs[i].txinterval);
 			musb_writeb(epio, MUSB_RXTYPE,
 				musb->context.index_regs[i].rxtype);
 			musb_writeb(epio, MUSB_RXINTERVAL,
 			musb->context.index_regs[i].rxinterval);
 			musb_write_txfunaddr(musb_base, i,
 				musb->context.index_regs[i].txfunaddr);
 			musb_write_txhubaddr(musb_base, i,
 				musb->context.index_regs[i].txhubaddr);
 			musb_write_txhubport(musb_base, i,
 				musb->context.index_regs[i].txhubport);
 			ep_target_regs =
 				musb_read_target_reg_base(i, musb_base);
 			musb_write_rxfunaddr(ep_target_regs,
 				musb->context.index_regs[i].rxfunaddr);
 			musb_write_rxhubaddr(ep_target_regs,
 				musb->context.index_regs[i].rxhubaddr);
 			musb_write_rxhubport(ep_target_regs,
 				musb->context.index_regs[i].rxhubport);
 		}
 	}
 	musb_writeb(musb_base, MUSB_INDEX, musb->context.index);
 }
 static int musb_suspend(struct device *dev)
 {
 	struct musb	*musb = dev_to_musb(dev);
 	unsigned long	flags;
 	spin_lock_irqsave(&musb->lock, flags);
 	if (is_peripheral_active(musb)) {
 		/* FIXME force disconnect unless we know USB will wake
 		 * the system up quickly enough to respond ...
 		 */
 	} else if (is_host_active(musb)) {
 		/* we know all the children are suspended; sometimes
 		 * they will even be wakeup-enabled.
 		 */
 	}
 	spin_unlock_irqrestore(&musb->lock, flags);
 	return 0;
 }
 static int musb_resume_noirq(struct device *dev)
 {
 	/* for static cmos like DaVinci, register values were preserved
 	 * unless for some reason the whole soc powered down or the USB
 	 * module got reset through the PSC (vs just being disabled).
 	 */
 	return 0;
 }
 static int musb_runtime_suspend(struct device *dev)
 {
 	struct musb	*musb = dev_to_musb(dev);
 	musb_save_context(musb);
 	return 0;
 }
 static int musb_runtime_resume(struct device *dev)
 {
 	struct musb	*musb = dev_to_musb(dev);
 	static int	first = 1;
 	/*
 	 * When pm_runtime_get_sync called for the first time in driver
 	 * init,  some of the structure is still not initialized which is
 	 * used in restore function. But clock needs to be
 	 * enabled before any register access, so
 	 * pm_runtime_get_sync has to be called.
 	 * Also context restore without save does not make
 	 * any sense
 	 */
 	if (!first)
 		musb_restore_context(musb);
 	first = 0;
 	return 0;
 }
 static const struct dev_pm_ops musb_dev_pm_ops = {
 	.suspend	= musb_suspend,
 	.resume_noirq	= musb_resume_noirq,
 	.runtime_suspend = musb_runtime_suspend,
 	.runtime_resume = musb_runtime_resume,
 };
 #define MUSB_DEV_PM_OPS (&musb_dev_pm_ops)
 #else
 #define	MUSB_DEV_PM_OPS	NULL
 #endif
 static struct platform_driver musb_driver = {
 	.driver = {
 		.name		= (char *)musb_driver_name,
 		.bus		= &platform_bus_type,
 		.owner		= THIS_MODULE,
 		.pm		= MUSB_DEV_PM_OPS,
 	},
 	.probe		= musb_probe,
 	.remove		= __devexit_p(musb_remove),
 	.shutdown	= musb_shutdown,
 };
 /*-------------------------------------------------------------------------*/
 static int __init musb_init(void)
 {
 	if (usb_disabled())
 		return 0;
 	pr_info("%s: version " MUSB_VERSION ", "
 		"?dma?"
 		", "
 		"otg (peripheral+host)",
 		musb_driver_name);
 	return platform_driver_register(&musb_driver);
 }
 module_init(musb_init);
 static void __exit musb_cleanup(void)
 {
 	platform_driver_unregister(&musb_driver);
 }
 module_exit(musb_cleanup);
 #endif

include/configs/siemens-am33x-common.h

Diff comments View file @ 8a6b088

1	/*	1	/*
2	* siemens am33x common board options	2	* siemens am33x common board options
3	* (C) Copyright 2013 Siemens Schweiz AG	3	* (C) Copyright 2013 Siemens Schweiz AG
4	* (C) Heiko Schocher, DENX Software Engineering, hs@denx.de.	4	* (C) Heiko Schocher, DENX Software Engineering, hs@denx.de.
5	*	5	*
6	* Based on:	6	* Based on:
7	* U-Boot file:/include/configs/am335x_evm.h	7	* U-Boot file:/include/configs/am335x_evm.h
8	*	8	*
9	* Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/	9	* Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
10	*	10	*
11	* SPDX-License-Identifier: GPL-2.0+	11	* SPDX-License-Identifier: GPL-2.0+
12	*/	12	*/
13		13
14	#ifndef __CONFIG_SIEMENS_AM33X_COMMON_H	14	#ifndef __CONFIG_SIEMENS_AM33X_COMMON_H
15	#define __CONFIG_SIEMENS_AM33X_COMMON_H	15	#define __CONFIG_SIEMENS_AM33X_COMMON_H
16		16
17	#define CONFIG_AM33XX	17	#define CONFIG_AM33XX
18	#define CONFIG_OMAP	18	#define CONFIG_OMAP
19	#define CONFIG_OMAP_COMMON	19	#define CONFIG_OMAP_COMMON
20		20
21	#include <asm/arch/omap.h>	21	#include <asm/arch/omap.h>
22		22
23	#define CONFIG_DMA_COHERENT	23	#define CONFIG_DMA_COHERENT
24	#define CONFIG_DMA_COHERENT_SIZE (1 << 20)	24	#define CONFIG_DMA_COHERENT_SIZE (1 << 20)
25		25
26	#define CONFIG_ENV_SIZE (0x2000)	26	#define CONFIG_ENV_SIZE (0x2000)
27	#define CONFIG_SYS_MALLOC_LEN (16 * 1024 * 1024)	27	#define CONFIG_SYS_MALLOC_LEN (16 * 1024 * 1024)
28	#define CONFIG_SYS_LONGHELP /* undef to save memory */	28	#define CONFIG_SYS_LONGHELP /* undef to save memory */
29	#define CONFIG_SYS_HUSH_PARSER /* use "hush" command parser */	29	#define CONFIG_SYS_HUSH_PARSER /* use "hush" command parser */
30	#define CONFIG_SYS_PROMPT "U-Boot# "	30	#define CONFIG_SYS_PROMPT "U-Boot# "
31	#define CONFIG_SYS_PROMPT_HUSH_PS2 "> "	31	#define CONFIG_SYS_PROMPT_HUSH_PS2 "> "
32	#define CONFIG_BOARD_LATE_INIT	32	#define CONFIG_BOARD_LATE_INIT
33	#define CONFIG_SYS_NO_FLASH	33	#define CONFIG_SYS_NO_FLASH
34	#define CONFIG_MACH_TYPE CONFIG_SIEMENS_MACH_TYPE	34	#define CONFIG_MACH_TYPE CONFIG_SIEMENS_MACH_TYPE
35		35
36	#define CONFIG_CMDLINE_TAG /* enable passing of ATAGs */	36	#define CONFIG_CMDLINE_TAG /* enable passing of ATAGs */
37	#define CONFIG_SETUP_MEMORY_TAGS	37	#define CONFIG_SETUP_MEMORY_TAGS
38	#define CONFIG_INITRD_TAG	38	#define CONFIG_INITRD_TAG
39		39
40	#define CONFIG_SYS_CACHELINE_SIZE 64	40	#define CONFIG_SYS_CACHELINE_SIZE 64
41		41
42	/* commands to include */	42	/* commands to include */
43	#include <config_cmd_default.h>	43	#include <config_cmd_default.h>
44		44
45	#define CONFIG_CMD_ASKENV	45	#define CONFIG_CMD_ASKENV
46	#define CONFIG_CMD_ECHO	46	#define CONFIG_CMD_ECHO
47	#define CONFIG_CMD_CACHE	47	#define CONFIG_CMD_CACHE
48		48
49	#define CONFIG_SYS_GENERIC_BOARD	49	#define CONFIG_SYS_GENERIC_BOARD
50		50
51	#define CONFIG_ENV_VARS_UBOOT_CONFIG	51	#define CONFIG_ENV_VARS_UBOOT_CONFIG
52	#ifndef CONFIG_SPL_BUILD	52	#ifndef CONFIG_SPL_BUILD
53	#define CONFIG_ROOTPATH "/opt/eldk"	53	#define CONFIG_ROOTPATH "/opt/eldk"
54	#endif	54	#endif
55		55
56	#define CONFIG_ENV_OVERWRITE 1	56	#define CONFIG_ENV_OVERWRITE 1
57	#define CONFIG_ENV_IS_NOWHERE	57	#define CONFIG_ENV_IS_NOWHERE
58		58
59	#define CONFIG_SYS_LONGHELP	59	#define CONFIG_SYS_LONGHELP
60	#define CONFIG_CMDLINE_EDITING	60	#define CONFIG_CMDLINE_EDITING
61	#define CONFIG_AUTO_COMPLETE	61	#define CONFIG_AUTO_COMPLETE
62	#define CONFIG_SYS_AUTOLOAD "yes"	62	#define CONFIG_SYS_AUTOLOAD "yes"
63		63
64	/* Clock Defines */	64	/* Clock Defines */
65	#define V_OSCK 24000000 /* Clock output from T2 */	65	#define V_OSCK 24000000 /* Clock output from T2 */
66	#define V_SCLK (V_OSCK)	66	#define V_SCLK (V_OSCK)
67		67
68	/* We set the max number of command args high to avoid HUSH bugs. */	68	/* We set the max number of command args high to avoid HUSH bugs. */
69	#define CONFIG_SYS_MAXARGS 32	69	#define CONFIG_SYS_MAXARGS 32
70		70
71	/* Console I/O Buffer Size */	71	/* Console I/O Buffer Size */
72	#define CONFIG_SYS_CBSIZE 512	72	#define CONFIG_SYS_CBSIZE 512
73		73
74	/* Print Buffer Size */	74	/* Print Buffer Size */
75	#define CONFIG_SYS_PBSIZE (CONFIG_SYS_CBSIZE \	75	#define CONFIG_SYS_PBSIZE (CONFIG_SYS_CBSIZE \
76	+ sizeof(CONFIG_SYS_PROMPT) + 16)	76	+ sizeof(CONFIG_SYS_PROMPT) + 16)
77		77
78	/* Boot Argument Buffer Size */	78	/* Boot Argument Buffer Size */
79	#define CONFIG_SYS_BARGSIZE CONFIG_SYS_CBSIZE	79	#define CONFIG_SYS_BARGSIZE CONFIG_SYS_CBSIZE
80		80
81	/*	81	/*
82	* memtest works on 8 MB in DRAM after skipping 32MB from	82	* memtest works on 8 MB in DRAM after skipping 32MB from
83	* start addr of ram disk	83	* start addr of ram disk
84	*/	84	*/
85	#define CONFIG_SYS_MEMTEST_START (PHYS_DRAM_1 + (64 * 1024 * 1024))	85	#define CONFIG_SYS_MEMTEST_START (PHYS_DRAM_1 + (64 * 1024 * 1024))
86	#define CONFIG_SYS_MEMTEST_END (CONFIG_SYS_MEMTEST_START \	86	#define CONFIG_SYS_MEMTEST_END (CONFIG_SYS_MEMTEST_START \
87	+ (8 * 1024 * 1024))	87	+ (8 * 1024 * 1024))
88		88
89	#define CONFIG_SYS_LOAD_ADDR 0x81000000 /* Default load address */	89	#define CONFIG_SYS_LOAD_ADDR 0x81000000 /* Default load address */
90		90
91	#define CONFIG_MMC	91	#define CONFIG_MMC
92	#define CONFIG_GENERIC_MMC	92	#define CONFIG_GENERIC_MMC
93	#define CONFIG_OMAP_HSMMC	93	#define CONFIG_OMAP_HSMMC
94	#define CONFIG_CMD_MMC	94	#define CONFIG_CMD_MMC
95	#define CONFIG_DOS_PARTITION	95	#define CONFIG_DOS_PARTITION
96	#define CONFIG_CMD_FAT	96	#define CONFIG_CMD_FAT
97	#define CONFIG_CMD_EXT2	97	#define CONFIG_CMD_EXT2
98		98
99	#define CONFIG_SPI	99	#define CONFIG_SPI
100	#define CONFIG_OMAP3_SPI	100	#define CONFIG_OMAP3_SPI
101	#define CONFIG_MTD_DEVICE	101	#define CONFIG_MTD_DEVICE
102	#define CONFIG_SPI_FLASH	102	#define CONFIG_SPI_FLASH
103	#define CONFIG_SPI_FLASH_WINBOND	103	#define CONFIG_SPI_FLASH_WINBOND
104	#define CONFIG_CMD_SF	104	#define CONFIG_CMD_SF
105	#define CONFIG_SF_DEFAULT_SPEED (75000000)	105	#define CONFIG_SF_DEFAULT_SPEED (75000000)
106		106
107	/* Physical Memory Map */	107	/* Physical Memory Map */
108	#define CONFIG_NR_DRAM_BANKS 1 /* 1 bank of DRAM */	108	#define CONFIG_NR_DRAM_BANKS 1 /* 1 bank of DRAM */
109	#define PHYS_DRAM_1 0x80000000 /* DRAM Bank #1 */	109	#define PHYS_DRAM_1 0x80000000 /* DRAM Bank #1 */
110		110
111	#define CONFIG_SYS_SDRAM_BASE PHYS_DRAM_1	111	#define CONFIG_SYS_SDRAM_BASE PHYS_DRAM_1
112	#define CONFIG_SYS_INIT_SP_ADDR (NON_SECURE_SRAM_END - \	112	#define CONFIG_SYS_INIT_SP_ADDR (NON_SECURE_SRAM_END - \
113	GENERATED_GBL_DATA_SIZE)	113	GENERATED_GBL_DATA_SIZE)
114	/* Platform/Board specific defs */	114	/* Platform/Board specific defs */
115	#define CONFIG_SYS_TIMERBASE 0x48040000 /* Use Timer2 */	115	#define CONFIG_SYS_TIMERBASE 0x48040000 /* Use Timer2 */
116	#define CONFIG_SYS_PTV 2 /* Divisor: 2^(PTV+1) => 8 */	116	#define CONFIG_SYS_PTV 2 /* Divisor: 2^(PTV+1) => 8 */
117		117
118	/* NS16550 Configuration */	118	/* NS16550 Configuration */
119	#define CONFIG_SYS_NS16550	119	#define CONFIG_SYS_NS16550
120	#define CONFIG_SYS_NS16550_SERIAL	120	#define CONFIG_SYS_NS16550_SERIAL
121	#define CONFIG_SERIAL_MULTI	121	#define CONFIG_SERIAL_MULTI
122	#define CONFIG_SYS_NS16550_REG_SIZE (-4)	122	#define CONFIG_SYS_NS16550_REG_SIZE (-4)
123	#define CONFIG_SYS_NS16550_CLK (48000000)	123	#define CONFIG_SYS_NS16550_CLK (48000000)
124	#define CONFIG_SYS_NS16550_COM1 0x44e09000	124	#define CONFIG_SYS_NS16550_COM1 0x44e09000
125	#define CONFIG_SYS_NS16550_COM4 0x481a6000	125	#define CONFIG_SYS_NS16550_COM4 0x481a6000
126		126
127	#define CONFIG_BAUDRATE 115200	127	#define CONFIG_BAUDRATE 115200
128		128
129	#define CONFIG_SYS_CONSOLE_INFO_QUIET	129	#define CONFIG_SYS_CONSOLE_INFO_QUIET
130	#define CONFIG_SERIAL1 1	130	#define CONFIG_SERIAL1 1
131	#define CONFIG_CONS_INDEX 1	131	#define CONFIG_CONS_INDEX 1
132		132
133	/* I2C Configuration */	133	/* I2C Configuration */
134	#define CONFIG_I2C	134	#define CONFIG_I2C
135	#define CONFIG_CMD_I2C	135	#define CONFIG_CMD_I2C
136	#define CONFIG_SYS_I2C	136	#define CONFIG_SYS_I2C
137	#define CONFIG_SYS_OMAP24_I2C_SPEED OMAP_I2C_STANDARD	137	#define CONFIG_SYS_OMAP24_I2C_SPEED OMAP_I2C_STANDARD
138	#define CONFIG_SYS_OMAP24_I2C_SLAVE 1	138	#define CONFIG_SYS_OMAP24_I2C_SLAVE 1
139	#define CONFIG_SYS_I2C_OMAP24XX	139	#define CONFIG_SYS_I2C_OMAP24XX
140		140
141	/* Defines for SPL */	141	/* Defines for SPL */
142	#define CONFIG_SPL_FRAMEWORK	142	#define CONFIG_SPL_FRAMEWORK
143	#define CONFIG_SPL_TEXT_BASE 0x402F0400	143	#define CONFIG_SPL_TEXT_BASE 0x402F0400
144	#define CONFIG_SPL_MAX_SIZE (101 * 1024)	144	#define CONFIG_SPL_MAX_SIZE (101 * 1024)
145	#define CONFIG_SPL_STACK CONFIG_SYS_INIT_SP_ADDR	145	#define CONFIG_SPL_STACK CONFIG_SYS_INIT_SP_ADDR
146		146
147	#define CONFIG_SPL_BSS_START_ADDR 0x80000000	147	#define CONFIG_SPL_BSS_START_ADDR 0x80000000
148	#define CONFIG_SPL_BSS_MAX_SIZE 0x80000 /* 512 KB */	148	#define CONFIG_SPL_BSS_MAX_SIZE 0x80000 /* 512 KB */
149		149
150	#define CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR 0x300 /* address 0x60000 */	150	#define CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR 0x300 /* address 0x60000 */
151	#define CONFIG_SYS_MMC_SD_FAT_BOOT_PARTITION 1	151	#define CONFIG_SYS_MMC_SD_FAT_BOOT_PARTITION 1
152	#define CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME "u-boot.img"	152	#define CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME "u-boot.img"
153	#define CONFIG_SPL_MMC_SUPPORT	153	#define CONFIG_SPL_MMC_SUPPORT
154	#define CONFIG_SPL_FAT_SUPPORT	154	#define CONFIG_SPL_FAT_SUPPORT
155	#define CONFIG_FS_FAT	155	#define CONFIG_FS_FAT
156	#define CONFIG_SPL_I2C_SUPPORT	156	#define CONFIG_SPL_I2C_SUPPORT
157		157
158	#define CONFIG_SPL_LIBCOMMON_SUPPORT	158	#define CONFIG_SPL_LIBCOMMON_SUPPORT
159	#define CONFIG_SPL_LIBDISK_SUPPORT	159	#define CONFIG_SPL_LIBDISK_SUPPORT
160	#define CONFIG_SPL_LIBGENERIC_SUPPORT	160	#define CONFIG_SPL_LIBGENERIC_SUPPORT
161	#define CONFIG_SPL_SERIAL_SUPPORT	161	#define CONFIG_SPL_SERIAL_SUPPORT
162	#define CONFIG_SPL_YMODEM_SUPPORT	162	#define CONFIG_SPL_YMODEM_SUPPORT
163		163
164	#define CONFIG_SPL_GPIO_SUPPORT	164	#define CONFIG_SPL_GPIO_SUPPORT
165	#define CONFIG_SPL_WATCHDOG_SUPPORT	165	#define CONFIG_SPL_WATCHDOG_SUPPORT
166		166
167	#define CONFIG_SPL_SPI_SUPPORT	167	#define CONFIG_SPL_SPI_SUPPORT
168	#define CONFIG_SPL_SPI_FLASH_SUPPORT	168	#define CONFIG_SPL_SPI_FLASH_SUPPORT
169	#define CONFIG_SPL_SPI_LOAD	169	#define CONFIG_SPL_SPI_LOAD
170	#define CONFIG_SYS_SPI_U_BOOT_OFFS 0x20000	170	#define CONFIG_SYS_SPI_U_BOOT_OFFS 0x20000
171		171
172	#define CONFIG_SPL_LDSCRIPT "$(CPUDIR)/am33xx/u-boot-spl.lds"	172	#define CONFIG_SPL_LDSCRIPT "$(CPUDIR)/am33xx/u-boot-spl.lds"
173		173
174	#define CONFIG_SPL_BOARD_INIT	174	#define CONFIG_SPL_BOARD_INIT
175	#define CONFIG_SPL_NAND_AM33XX_BCH	175	#define CONFIG_SPL_NAND_AM33XX_BCH
176	#define CONFIG_SPL_NAND_SUPPORT	176	#define CONFIG_SPL_NAND_SUPPORT
177	#define CONFIG_SPL_NAND_BASE	177	#define CONFIG_SPL_NAND_BASE
178	#define CONFIG_SPL_NAND_DRIVERS	178	#define CONFIG_SPL_NAND_DRIVERS
179	#define CONFIG_SPL_NAND_ECC	179	#define CONFIG_SPL_NAND_ECC
180	#define CONFIG_SYS_NAND_5_ADDR_CYCLE	180	#define CONFIG_SYS_NAND_5_ADDR_CYCLE
181	#define CONFIG_SYS_NAND_PAGE_COUNT (CONFIG_SYS_NAND_BLOCK_SIZE / \	181	#define CONFIG_SYS_NAND_PAGE_COUNT (CONFIG_SYS_NAND_BLOCK_SIZE / \
182	CONFIG_SYS_NAND_PAGE_SIZE)	182	CONFIG_SYS_NAND_PAGE_SIZE)
183	#define CONFIG_SYS_NAND_PAGE_SIZE 2048	183	#define CONFIG_SYS_NAND_PAGE_SIZE 2048
184	#define CONFIG_SYS_NAND_OOBSIZE 64	184	#define CONFIG_SYS_NAND_OOBSIZE 64
185	#define CONFIG_SYS_NAND_BLOCK_SIZE (128*1024)	185	#define CONFIG_SYS_NAND_BLOCK_SIZE (128*1024)
186	#define CONFIG_SYS_NAND_BAD_BLOCK_POS NAND_LARGE_BADBLOCK_POS	186	#define CONFIG_SYS_NAND_BAD_BLOCK_POS NAND_LARGE_BADBLOCK_POS
187	#define CONFIG_SYS_NAND_ECCPOS { 2, 3, 4, 5, 6, 7, 8, 9, \	187	#define CONFIG_SYS_NAND_ECCPOS { 2, 3, 4, 5, 6, 7, 8, 9, \
188	10, 11, 12, 13, 14, 15, 16, 17, \	188	10, 11, 12, 13, 14, 15, 16, 17, \
189	18, 19, 20, 21, 22, 23, 24, 25, \	189	18, 19, 20, 21, 22, 23, 24, 25, \
190	26, 27, 28, 29, 30, 31, 32, 33, \	190	26, 27, 28, 29, 30, 31, 32, 33, \
191	34, 35, 36, 37, 38, 39, 40, 41, \	191	34, 35, 36, 37, 38, 39, 40, 41, \
192	42, 43, 44, 45, 46, 47, 48, 49, \	192	42, 43, 44, 45, 46, 47, 48, 49, \
193	50, 51, 52, 53, 54, 55, 56, 57, }	193	50, 51, 52, 53, 54, 55, 56, 57, }
194		194
195	#define CONFIG_SYS_NAND_ECCSIZE 512	195	#define CONFIG_SYS_NAND_ECCSIZE 512
196	#define CONFIG_SYS_NAND_ECCBYTES 14	196	#define CONFIG_SYS_NAND_ECCBYTES 14
197	#define CONFIG_NAND_OMAP_ECCSCHEME OMAP_ECC_BCH8_CODE_HW	197	#define CONFIG_NAND_OMAP_ECCSCHEME OMAP_ECC_BCH8_CODE_HW
198		198
199	#define CONFIG_SYS_NAND_ECCSTEPS 4	199	#define CONFIG_SYS_NAND_ECCSTEPS 4
200	#define CONFIG_SYS_NAND_ECCTOTAL (CONFIG_SYS_NAND_ECCBYTES * \	200	#define CONFIG_SYS_NAND_ECCTOTAL (CONFIG_SYS_NAND_ECCBYTES * \
201	CONFIG_SYS_NAND_ECCSTEPS)	201	CONFIG_SYS_NAND_ECCSTEPS)
202		202
203	#define CONFIG_SYS_NAND_U_BOOT_START CONFIG_SYS_TEXT_BASE	203	#define CONFIG_SYS_NAND_U_BOOT_START CONFIG_SYS_TEXT_BASE
204		204
205	#define CONFIG_SYS_NAND_U_BOOT_OFFS 0x80000	205	#define CONFIG_SYS_NAND_U_BOOT_OFFS 0x80000
206		206
207	/*	207	/*
208	* 1MB into the SDRAM to allow for SPL's bss at the beginning of SDRAM	208	* 1MB into the SDRAM to allow for SPL's bss at the beginning of SDRAM
209	* 64 bytes before this address should be set aside for u-boot.img's	209	* 64 bytes before this address should be set aside for u-boot.img's
210	* header. That is 0x800FFFC0--0x80100000 should not be used for any	210	* header. That is 0x800FFFC0--0x80100000 should not be used for any
211	* other needs.	211	* other needs.
212	*/	212	*/
213	#define CONFIG_SYS_TEXT_BASE 0x80100000	213	#define CONFIG_SYS_TEXT_BASE 0x80100000
214	#define CONFIG_SYS_SPL_MALLOC_START 0x80208000	214	#define CONFIG_SYS_SPL_MALLOC_START 0x80208000
215	#define CONFIG_SYS_SPL_MALLOC_SIZE 0x100000	215	#define CONFIG_SYS_SPL_MALLOC_SIZE 0x100000
216		216
217	/*	217	/*
218	* Since SPL did pll and ddr initialization for us,	218	* Since SPL did pll and ddr initialization for us,
219	* we don't need to do it twice.	219	* we don't need to do it twice.
220	*/	220	*/
221	#ifndef CONFIG_SPL_BUILD	221	#ifndef CONFIG_SPL_BUILD
222	#define CONFIG_SKIP_LOWLEVEL_INIT	222	#define CONFIG_SKIP_LOWLEVEL_INIT
223	#endif	223	#endif
224		224
225	#ifndef CONFIG_SPL_BUILD	225	#ifndef CONFIG_SPL_BUILD
226	/*	226	/*
227	* USB configuration	227	* USB configuration
228	*/	228	*/
229	#define CONFIG_USB_MUSB_DSPS	229	#define CONFIG_USB_MUSB_DSPS
230	#define CONFIG_ARCH_MISC_INIT	230	#define CONFIG_ARCH_MISC_INIT
231	#define CONFIG_MUSB_GADGET	231	#define CONFIG_MUSB_GADGET
232	#define CONFIG_MUSB_PIO_ONLY	232	#define CONFIG_MUSB_PIO_ONLY
233	#define CONFIG_MUSB_DISABLE_BULK_COMBINE_SPLIT	233	#define CONFIG_MUSB_DISABLE_BULK_COMBINE_SPLIT
234	#define CONFIG_USB_GADGET_DUALSPEED	234	#undef CONFIG_USB_GADGET_DUALSPEED
235	#define CONFIG_USB_GADGET_VBUS_DRAW 2	235	#define CONFIG_USB_GADGET_VBUS_DRAW 2
236	#define CONFIG_MUSB_HOST	236	#define CONFIG_MUSB_HOST
237		237
238	#define CONFIG_AM335X_USB0	238	#define CONFIG_AM335X_USB0
239	#define CONFIG_AM335X_USB0_MODE MUSB_PERIPHERAL	239	#define CONFIG_AM335X_USB0_MODE MUSB_PERIPHERAL
240	#define CONFIG_AM335X_USB1	240	#define CONFIG_AM335X_USB1
241	#define CONFIG_AM335X_USB1_MODE MUSB_HOST	241	#define CONFIG_AM335X_USB1_MODE MUSB_HOST
242	#ifdef CONFIG_MUSB_HOST	242	#ifdef CONFIG_MUSB_HOST
243	#define CONFIG_CMD_USB	243	#define CONFIG_CMD_USB
244	#define CONFIG_USB_STORAGE	244	#define CONFIG_USB_STORAGE
245	#endif	245	#endif
246		246
247	#ifdef CONFIG_MUSB_GADGET	247	#ifdef CONFIG_MUSB_GADGET
248	#define CONFIG_USB_ETHER	248	#define CONFIG_USB_ETHER
249	#define CONFIG_USB_ETH_RNDIS	249	#define CONFIG_USB_ETH_RNDIS
250	#define CONFIG_USBNET_HOST_ADDR "de:ad:be:af:00:00"	250	#define CONFIG_USBNET_HOST_ADDR "de:ad:be:af:00:00"
251	#endif /* CONFIG_MUSB_GADGET */	251	#endif /* CONFIG_MUSB_GADGET */
252		252
253	#define CONFIG_USB_GADGET	253	#define CONFIG_USB_GADGET
254	#define CONFIG_USBDOWNLOAD_GADGET	254	#define CONFIG_USBDOWNLOAD_GADGET
255		255
256	/* USB DRACO ID as default */	256	/* USB DRACO ID as default */
257	#define CONFIG_USBD_HS	257	#define CONFIG_USBD_HS
258	#define CONFIG_G_DNL_VENDOR_NUM 0x0908	258	#define CONFIG_G_DNL_VENDOR_NUM 0x0908
259	#define CONFIG_G_DNL_PRODUCT_NUM 0x02d2	259	#define CONFIG_G_DNL_PRODUCT_NUM 0x02d2
260	#define CONFIG_G_DNL_MANUFACTURER "Siemens AG"	260	#define CONFIG_G_DNL_MANUFACTURER "Siemens AG"
261		261
262	/* USB Device Firmware Update support */	262	/* USB Device Firmware Update support */
263	#define CONFIG_DFU_FUNCTION	263	#define CONFIG_DFU_FUNCTION
264	#define CONFIG_DFU_NAND	264	#define CONFIG_DFU_NAND
265	#define CONFIG_CMD_DFU	265	#define CONFIG_CMD_DFU
266	#define CONFIG_SYS_DFU_DATA_BUF_SIZE (1 << 20)	266	#define CONFIG_SYS_DFU_DATA_BUF_SIZE (1 << 20)
267	#define DFU_MANIFEST_POLL_TIMEOUT 25000	267	#define DFU_MANIFEST_POLL_TIMEOUT 25000
268		268
269	#endif /* CONFIG_SPL_BUILD */	269	#endif /* CONFIG_SPL_BUILD */
270		270
271	/*	271	/*
272	* Default to using SPI for environment, etc. We have multiple copies	272	* Default to using SPI for environment, etc. We have multiple copies
273	* of SPL as the ROM will check these locations.	273	* of SPL as the ROM will check these locations.
274	* 0x0 - 0x20000 : First copy of SPL	274	* 0x0 - 0x20000 : First copy of SPL
275	* 0x20000 - 0x40000 : Second copy of SPL	275	* 0x20000 - 0x40000 : Second copy of SPL
276	* 0x40000 - 0x60000 : Third copy of SPL	276	* 0x40000 - 0x60000 : Third copy of SPL
277	* 0x60000 - 0x80000 : Fourth copy of SPL	277	* 0x60000 - 0x80000 : Fourth copy of SPL
278	* 0x80000 - 0xDF000 : U-Boot	278	* 0x80000 - 0xDF000 : U-Boot
279	* 0xDF000 - 0xE0000 : U-Boot Environment	279	* 0xDF000 - 0xE0000 : U-Boot Environment
280	* 0xE0000 - 0x442000 : Linux Kernel	280	* 0xE0000 - 0x442000 : Linux Kernel
281	* 0x442000 - 0x800000 : Userland	281	* 0x442000 - 0x800000 : Userland
282	*/	282	*/
283	#if defined(CONFIG_SPI_BOOT)	283	#if defined(CONFIG_SPI_BOOT)
284	# undef CONFIG_ENV_IS_NOWHERE	284	# undef CONFIG_ENV_IS_NOWHERE
285	# define CONFIG_ENV_IS_IN_SPI_FLASH	285	# define CONFIG_ENV_IS_IN_SPI_FLASH
286	# define CONFIG_ENV_SPI_MAX_HZ CONFIG_SF_DEFAULT_SPEED	286	# define CONFIG_ENV_SPI_MAX_HZ CONFIG_SF_DEFAULT_SPEED
287	# define CONFIG_ENV_OFFSET (892 << 10) /* 892 KiB in */	287	# define CONFIG_ENV_OFFSET (892 << 10) /* 892 KiB in */
288	# define CONFIG_ENV_SECT_SIZE (4 << 10) /* 4 KB sectors */	288	# define CONFIG_ENV_SECT_SIZE (4 << 10) /* 4 KB sectors */
289	#endif /* SPI support */	289	#endif /* SPI support */
290		290
291	/* Unsupported features */	291	/* Unsupported features */
292	#undef CONFIG_USE_IRQ	292	#undef CONFIG_USE_IRQ
293		293
294	#define CONFIG_CMD_NET	294	#define CONFIG_CMD_NET
295	#define CONFIG_CMD_DHCP	295	#define CONFIG_CMD_DHCP
296	#define CONFIG_CMD_PING	296	#define CONFIG_CMD_PING
297	#define CONFIG_DRIVER_TI_CPSW	297	#define CONFIG_DRIVER_TI_CPSW
298	#define CONFIG_MII	298	#define CONFIG_MII
299	#define CONFIG_PHY_GIGE	299	#define CONFIG_PHY_GIGE
300	#define CONFIG_PHYLIB	300	#define CONFIG_PHYLIB
301	#define CONFIG_CMD_MII	301	#define CONFIG_CMD_MII
302	#define CONFIG_BOOTP_DEFAULT	302	#define CONFIG_BOOTP_DEFAULT
303	#define CONFIG_BOOTP_DNS	303	#define CONFIG_BOOTP_DNS
304	#define CONFIG_BOOTP_DNS2	304	#define CONFIG_BOOTP_DNS2
305	#define CONFIG_BOOTP_SEND_HOSTNAME	305	#define CONFIG_BOOTP_SEND_HOSTNAME
306	#define CONFIG_BOOTP_GATEWAY	306	#define CONFIG_BOOTP_GATEWAY
307	#define CONFIG_BOOTP_SUBNETMASK	307	#define CONFIG_BOOTP_SUBNETMASK
308	#define CONFIG_NET_RETRY_COUNT 10	308	#define CONFIG_NET_RETRY_COUNT 10
309	#define CONFIG_NET_MULTI	309	#define CONFIG_NET_MULTI
310		310
311	#define CONFIG_NAND	311	#define CONFIG_NAND
312	/* NAND support */	312	/* NAND support */
313	#ifdef CONFIG_NAND	313	#ifdef CONFIG_NAND
314	#define CONFIG_CMD_NAND	314	#define CONFIG_CMD_NAND
315	#define CONFIG_CMD_MTDPARTS	315	#define CONFIG_CMD_MTDPARTS
316		316
317	#define MTDIDS_NAME_STR "omap2-nand.0"	317	#define MTDIDS_NAME_STR "omap2-nand.0"
318	#define MTDIDS_DEFAULT "nand0=" MTDIDS_NAME_STR	318	#define MTDIDS_DEFAULT "nand0=" MTDIDS_NAME_STR
319	#define MTDPARTS_DEFAULT "mtdparts=" MTDIDS_NAME_STR ":" \	319	#define MTDPARTS_DEFAULT "mtdparts=" MTDIDS_NAME_STR ":" \
320	"128k(spl)," \	320	"128k(spl)," \
321	"128k(spl.backup1)," \	321	"128k(spl.backup1)," \
322	"128k(spl.backup2)," \	322	"128k(spl.backup2)," \
323	"128k(spl.backup3)," \	323	"128k(spl.backup3)," \
324	"1920k(u-boot)," \	324	"1920k(u-boot)," \
325	"128k(uboot.env)," \	325	"128k(uboot.env)," \
326	"5120k(kernel_a)," \	326	"5120k(kernel_a)," \
327	"5120k(kernel_b)," \	327	"5120k(kernel_b)," \
328	"8192k(mtdoops)," \	328	"8192k(mtdoops)," \
329	"-(rootfs)"	329	"-(rootfs)"
330	/*	330	/*
331	* chip-size = 256MiB	331	* chip-size = 256MiB
332	*\| name \| size \| address area \|	332	*\| name \| size \| address area \|
333	*-------------------------------------------------------	333	*-------------------------------------------------------
334	*\| spl \| 128.000 KiB \| 0x 0..0x 1ffff \|	334	*\| spl \| 128.000 KiB \| 0x 0..0x 1ffff \|
335	*\| spl.backup1 \| 128.000 KiB \| 0x 20000..0x 3ffff \|	335	*\| spl.backup1 \| 128.000 KiB \| 0x 20000..0x 3ffff \|
336	*\| spl.backup2 \| 128.000 KiB \| 0x 40000..0x 5ffff \|	336	*\| spl.backup2 \| 128.000 KiB \| 0x 40000..0x 5ffff \|
337	*\| spl.backup3 \| 128.000 KiB \| 0x 60000..0x 7ffff \|	337	*\| spl.backup3 \| 128.000 KiB \| 0x 60000..0x 7ffff \|
338	*\| u-boot \| 1.875 MiB \| 0x 80000..0x 25ffff \|	338	*\| u-boot \| 1.875 MiB \| 0x 80000..0x 25ffff \|
339	*\| uboot.env \| 128.000 KiB \| 0x 260000..0x 27ffff \|	339	*\| uboot.env \| 128.000 KiB \| 0x 260000..0x 27ffff \|
340	*\| kernel_a \| 5.000 MiB \| 0x 280000..0x 77ffff \|	340	*\| kernel_a \| 5.000 MiB \| 0x 280000..0x 77ffff \|
341	*\| kernel_b \| 5.000 MiB \| 0x 780000..0x c7ffff \|	341	*\| kernel_b \| 5.000 MiB \| 0x 780000..0x c7ffff \|
342	*\| mtdoops \| 8.000 MiB \| 0x c80000..0x 147ffff \|	342	*\| mtdoops \| 8.000 MiB \| 0x c80000..0x 147ffff \|
343	*\| rootfs \| 235.500 MiB \| 0x 1480000..0x fffffff \|	343	*\| rootfs \| 235.500 MiB \| 0x 1480000..0x fffffff \|
344	*-------------------------------------------------------	344	*-------------------------------------------------------
345	*/	345	*/
346		346
347	#define DFU_ALT_INFO_NAND \	347	#define DFU_ALT_INFO_NAND \
348	"spl part 0 1;" \	348	"spl part 0 1;" \
349	"spl.backup1 part 0 2;" \	349	"spl.backup1 part 0 2;" \
350	"spl.backup2 part 0 3;" \	350	"spl.backup2 part 0 3;" \
351	"spl.backup3 part 0 4;" \	351	"spl.backup3 part 0 4;" \
352	"u-boot part 0 5;" \	352	"u-boot part 0 5;" \
353	"u-boot.env part 0 6;" \	353	"u-boot.env part 0 6;" \
354	"kernel_a part 0 7;" \	354	"kernel_a part 0 7;" \
355	"kernel_b part 0 8;" \	355	"kernel_b part 0 8;" \
356	"rootfs partubi 0 10"	356	"rootfs partubi 0 10"
357		357
358	#define CONFIG_COMMON_ENV_SETTINGS \	358	#define CONFIG_COMMON_ENV_SETTINGS \
359	"verify=no \0" \	359	"verify=no \0" \
360	"project_dir=targetdir\0" \	360	"project_dir=targetdir\0" \
361	"upgrade_available=0\0" \	361	"upgrade_available=0\0" \
362	"altbootcmd=run bootcmd\0" \	362	"altbootcmd=run bootcmd\0" \
363	"bootlimit=3\0" \	363	"bootlimit=3\0" \
364	"partitionset_active=A\0" \	364	"partitionset_active=A\0" \
365	"loadaddr=0x82000000\0" \	365	"loadaddr=0x82000000\0" \
366	"kloadaddr=0x81000000\0" \	366	"kloadaddr=0x81000000\0" \
367	"script_addr=0x81900000\0" \	367	"script_addr=0x81900000\0" \
368	"console=console=ttyMTD,mtdoops console=ttyO0,115200n8 panic=5\0" \	368	"console=console=ttyMTD,mtdoops console=ttyO0,115200n8 panic=5\0" \
369	"nand_active_ubi_vol=rootfs_a\0" \	369	"nand_active_ubi_vol=rootfs_a\0" \
370	"nand_active_ubi_vol_A=rootfs_a\0" \	370	"nand_active_ubi_vol_A=rootfs_a\0" \
371	"nand_active_ubi_vol_B=rootfs_b\0" \	371	"nand_active_ubi_vol_B=rootfs_b\0" \
372	"nand_root_fs_type=ubifs rootwait=1\0" \	372	"nand_root_fs_type=ubifs rootwait=1\0" \
373	"nand_src_addr=0x280000\0" \	373	"nand_src_addr=0x280000\0" \
374	"nand_src_addr_A=0x280000\0" \	374	"nand_src_addr_A=0x280000\0" \
375	"nand_src_addr_B=0x780000\0" \	375	"nand_src_addr_B=0x780000\0" \
376	"nfsopts=nolock rw mem=128M\0" \	376	"nfsopts=nolock rw mem=128M\0" \
377	"ip_method=none\0" \	377	"ip_method=none\0" \
378	"bootenv=uEnv.txt\0" \	378	"bootenv=uEnv.txt\0" \
379	"bootargs_defaults=setenv bootargs " \	379	"bootargs_defaults=setenv bootargs " \
380	"console=${console} " \	380	"console=${console} " \
381	"${testargs} " \	381	"${testargs} " \
382	"${optargs}\0" \	382	"${optargs}\0" \
383	"nand_args=run bootargs_defaults;" \	383	"nand_args=run bootargs_defaults;" \
384	"mtdparts default;" \	384	"mtdparts default;" \
385	"setenv ${partitionset_active} true;" \	385	"setenv ${partitionset_active} true;" \
386	"if test -n ${A}; then " \	386	"if test -n ${A}; then " \
387	"setenv nand_active_ubi_vol ${nand_active_ubi_vol_A};" \	387	"setenv nand_active_ubi_vol ${nand_active_ubi_vol_A};" \
388	"setenv nand_src_addr ${nand_src_addr_A};" \	388	"setenv nand_src_addr ${nand_src_addr_A};" \
389	"fi;" \	389	"fi;" \
390	"if test -n ${B}; then " \	390	"if test -n ${B}; then " \
391	"setenv nand_active_ubi_vol ${nand_active_ubi_vol_B};" \	391	"setenv nand_active_ubi_vol ${nand_active_ubi_vol_B};" \
392	"setenv nand_src_addr ${nand_src_addr_B};" \	392	"setenv nand_src_addr ${nand_src_addr_B};" \
393	"fi;" \	393	"fi;" \
394	"setenv nand_root ubi0:${nand_active_ubi_vol} rw " \	394	"setenv nand_root ubi0:${nand_active_ubi_vol} rw " \
395	"ubi.mtd=9,2048;" \	395	"ubi.mtd=9,2048;" \
396	"setenv bootargs ${bootargs} " \	396	"setenv bootargs ${bootargs} " \
397	"root=${nand_root} noinitrd ${mtdparts} " \	397	"root=${nand_root} noinitrd ${mtdparts} " \
398	"rootfstype=${nand_root_fs_type} ip=${ip_method} " \	398	"rootfstype=${nand_root_fs_type} ip=${ip_method} " \
399	"console=ttyMTD,mtdoops console=ttyO0,115200n8 mtdoops.mtddev" \	399	"console=ttyMTD,mtdoops console=ttyO0,115200n8 mtdoops.mtddev" \
400	"=mtdoops\0" \	400	"=mtdoops\0" \
401	"dfu_args=run bootargs_defaults;" \	401	"dfu_args=run bootargs_defaults;" \
402	"setenv bootargs ${bootargs} ;" \	402	"setenv bootargs ${bootargs} ;" \
403	"mtdparts default; " \	403	"mtdparts default; " \
404	"led dfu 1;" \	404	"led dfu 1;" \
405	"led stat 0;" \	405	"led stat 0;" \
406	"dfu 0 nand 0;" \	406	"dfu 0 nand 0;" \
407	"led dfu 0;" \	407	"led dfu 0;" \
408	"led stat 1;\0" \	408	"led stat 1;\0" \
409	"dfu_alt_info=" DFU_ALT_INFO_NAND "\0" \	409	"dfu_alt_info=" DFU_ALT_INFO_NAND "\0" \
410	"net_args=run bootargs_defaults;" \	410	"net_args=run bootargs_defaults;" \
411	"mtdparts default;" \	411	"mtdparts default;" \
412	"setenv bootfile ${project_dir}/kernel/uImage;" \	412	"setenv bootfile ${project_dir}/kernel/uImage;" \
413	"setenv rootpath /home/projects/${project_dir}/rootfs;" \	413	"setenv rootpath /home/projects/${project_dir}/rootfs;" \
414	"setenv bootargs ${bootargs} " \	414	"setenv bootargs ${bootargs} " \
415	"root=/dev/nfs ${mtdparts} " \	415	"root=/dev/nfs ${mtdparts} " \
416	"nfsroot=${serverip}:${rootpath},${nfsopts} " \	416	"nfsroot=${serverip}:${rootpath},${nfsopts} " \
417	"ip=${ipaddr}:${serverip}:" \	417	"ip=${ipaddr}:${serverip}:" \
418	"${gatewayip}:${netmask}:${hostname}:eth0:off\0" \	418	"${gatewayip}:${netmask}:${hostname}:eth0:off\0" \
419	"nand_boot=echo Booting from nand; " \	419	"nand_boot=echo Booting from nand; " \
420	"if test ${upgrade_available} -eq 1; then " \	420	"if test ${upgrade_available} -eq 1; then " \
421	"if test ${bootcount} -gt ${bootlimit}; " \	421	"if test ${bootcount} -gt ${bootlimit}; " \
422	"then " \	422	"then " \
423	"setenv upgrade_available 0;" \	423	"setenv upgrade_available 0;" \
424	"setenv ${partitionset_active} true;" \	424	"setenv ${partitionset_active} true;" \
425	"if test -n ${A}; then " \	425	"if test -n ${A}; then " \
426	"setenv partitionset_active B; " \	426	"setenv partitionset_active B; " \
427	"env delete A; " \	427	"env delete A; " \
428	"fi;" \	428	"fi;" \
429	"if test -n ${B}; then " \	429	"if test -n ${B}; then " \
430	"setenv partitionset_active A; " \	430	"setenv partitionset_active A; " \
431	"env delete B; " \	431	"env delete B; " \
432	"fi;" \	432	"fi;" \
433	"saveenv; " \	433	"saveenv; " \
434	"fi;" \	434	"fi;" \
435	"fi;" \	435	"fi;" \
436	"echo set ${partitionset_active}...;" \	436	"echo set ${partitionset_active}...;" \
437	"run nand_args; " \	437	"run nand_args; " \
438	"nand read.i ${kloadaddr} ${nand_src_addr} " \	438	"nand read.i ${kloadaddr} ${nand_src_addr} " \
439	"${nand_img_size}; bootm ${kloadaddr}\0" \	439	"${nand_img_size}; bootm ${kloadaddr}\0" \
440	"net_nfs=echo Booting from network ...; " \	440	"net_nfs=echo Booting from network ...; " \
441	"run net_args; " \	441	"run net_args; " \
442	"tftpboot ${kloadaddr} ${serverip}:${bootfile}; " \	442	"tftpboot ${kloadaddr} ${serverip}:${bootfile}; " \
443	"bootm ${kloadaddr}\0" \	443	"bootm ${kloadaddr}\0" \
444	"flash_self=run nand_boot\0" \	444	"flash_self=run nand_boot\0" \
445	"flash_self_test=setenv testargs test; " \	445	"flash_self_test=setenv testargs test; " \
446	"run nand_boot\0" \	446	"run nand_boot\0" \
447	"dfu_start=echo Preparing for dfu mode ...; " \	447	"dfu_start=echo Preparing for dfu mode ...; " \
448	"run dfu_args; \0" \	448	"run dfu_args; \0" \
449	"preboot=echo; "\	449	"preboot=echo; "\
450	"echo Type 'run flash_self' to use kernel and root " \	450	"echo Type 'run flash_self' to use kernel and root " \
451	"filesystem on memory; echo Type 'run flash_self_test' to " \	451	"filesystem on memory; echo Type 'run flash_self_test' to " \
452	"use kernel and root filesystem on memory, boot in test " \	452	"use kernel and root filesystem on memory, boot in test " \
453	"mode; echo Not ready yet: 'run flash_nfs' to use kernel " \	453	"mode; echo Not ready yet: 'run flash_nfs' to use kernel " \
454	"from memory and root filesystem over NFS; echo Type " \	454	"from memory and root filesystem over NFS; echo Type " \
455	"'run net_nfs' to get Kernel over TFTP and mount root " \	455	"'run net_nfs' to get Kernel over TFTP and mount root " \
456	"filesystem over NFS; " \	456	"filesystem over NFS; " \
457	"echo Set partitionset_active variable to 'A' " \	457	"echo Set partitionset_active variable to 'A' " \
458	"or 'B' to select kernel and rootfs partition; " \	458	"or 'B' to select kernel and rootfs partition; " \
459	"echo" \	459	"echo" \
460	"\0"	460	"\0"
461		461
462	#define CONFIG_NAND_OMAP_GPMC	462	#define CONFIG_NAND_OMAP_GPMC
463	#define CONFIG_NAND_OMAP_ELM	463	#define CONFIG_NAND_OMAP_ELM
464	#define CONFIG_SYS_NAND_BASE (0x08000000) /* physical address */	464	#define CONFIG_SYS_NAND_BASE (0x08000000) /* physical address */
465	/* to access nand at */	465	/* to access nand at */
466	/* CS0 */	466	/* CS0 */
467	#define CONFIG_SYS_MAX_NAND_DEVICE 1 /* Max number of NAND	467	#define CONFIG_SYS_MAX_NAND_DEVICE 1 /* Max number of NAND
468	devices */	468	devices */
469	#if !defined(CONFIG_SPI_BOOT)	469	#if !defined(CONFIG_SPI_BOOT)
470	#undef CONFIG_ENV_IS_NOWHERE	470	#undef CONFIG_ENV_IS_NOWHERE
471	#define CONFIG_ENV_IS_IN_NAND	471	#define CONFIG_ENV_IS_IN_NAND
472	#define CONFIG_ENV_OFFSET 0x260000 /* environment starts here */	472	#define CONFIG_ENV_OFFSET 0x260000 /* environment starts here */
473	#define CONFIG_SYS_ENV_SECT_SIZE (128 << 10) /* 128 KiB */	473	#define CONFIG_SYS_ENV_SECT_SIZE (128 << 10) /* 128 KiB */
474	#endif	474	#endif
475	#endif	475	#endif
476		476
477	#define CONFIG_OMAP_GPIO	477	#define CONFIG_OMAP_GPIO
478		478
479	/* Watchdog */	479	/* Watchdog */
480	#define CONFIG_HW_WATCHDOG	480	#define CONFIG_HW_WATCHDOG
481		481
482	/* Stop autoboot with ESC ESC key detected */	482	/* Stop autoboot with ESC ESC key detected */
483	#define CONFIG_AUTOBOOT_KEYED	483	#define CONFIG_AUTOBOOT_KEYED
484	#define CONFIG_AUTOBOOT_STOP_STR "\x1b\x1b"	484	#define CONFIG_AUTOBOOT_STOP_STR "\x1b\x1b"
485	#define CONFIG_AUTOBOOT_PROMPT "Autobooting in %d seconds, " \	485	#define CONFIG_AUTOBOOT_PROMPT "Autobooting in %d seconds, " \
486	"press \"<Esc><Esc>\" to stop\n", bootdelay	486	"press \"<Esc><Esc>\" to stop\n", bootdelay
487		487
488	/* Reboot after 60 sec if bootcmd fails */	488	/* Reboot after 60 sec if bootcmd fails */
489	#define CONFIG_RESET_TO_RETRY	489	#define CONFIG_RESET_TO_RETRY
490	#define CONFIG_BOOT_RETRY_TIME 60	490	#define CONFIG_BOOT_RETRY_TIME 60
491		491
492	#define CONFIG_BOOTCOUNT_LIMIT	492	#define CONFIG_BOOTCOUNT_LIMIT
493	#define CONFIG_BOOTCOUNT_ENV	493	#define CONFIG_BOOTCOUNT_ENV
494		494
495	/* Enable Device-Tree (FDT) support */	495	/* Enable Device-Tree (FDT) support */
496	#define CONFIG_OF_LIBFDT	496	#define CONFIG_OF_LIBFDT
497	#define CONFIG_CMD_FDT	497	#define CONFIG_CMD_FDT
498		498
499	#endif /* ! __CONFIG_SIEMENS_AM33X_COMMON_H */	499	#endif /* ! __CONFIG_SIEMENS_AM33X_COMMON_H */
500		500

include/stdio_dev.h

Diff comments View file @ 8a6b088

1	/*	1	/*
2	* (C) Copyright 2000	2	* (C) Copyright 2000
3	* Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it	3	* Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it
4	*	4	*
5	* SPDX-License-Identifier: GPL-2.0+	5	* SPDX-License-Identifier: GPL-2.0+
6	*/	6	*/
7		7
8	#ifndef _STDIO_DEV_H_	8	#ifndef _STDIO_DEV_H_
9	#define _STDIO_DEV_H_	9	#define _STDIO_DEV_H_
10		10
11	#include <linux/list.h>	11	#include <linux/list.h>
12		12
13	/*	13	/*
14	* STDIO DEVICES	14	* STDIO DEVICES
15	*/	15	*/
16		16
17	#define DEV_FLAGS_INPUT 0x00000001 /* Device can be used as input console */	17	#define DEV_FLAGS_INPUT 0x00000001 /* Device can be used as input console */
18	#define DEV_FLAGS_OUTPUT 0x00000002 /* Device can be used as output console */	18	#define DEV_FLAGS_OUTPUT 0x00000002 /* Device can be used as output console */
19	#define DEV_FLAGS_SYSTEM 0x80000000 /* Device is a system device */	19	#define DEV_FLAGS_SYSTEM 0x80000000 /* Device is a system device */
20	#define DEV_EXT_VIDEO 0x00000001 /* Video extensions supported */	20	#define DEV_EXT_VIDEO 0x00000001 /* Video extensions supported */
21		21
22	/* Device information */	22	/* Device information */
23	struct stdio_dev {	23	struct stdio_dev {
24	int flags; /* Device flags: input/output/system */	24	int flags; /* Device flags: input/output/system */
25	int ext; /* Supported extensions */	25	int ext; /* Supported extensions */
26	char name[16]; /* Device name */	26	char name[16]; /* Device name */
27		27
28	/* GENERAL functions */	28	/* GENERAL functions */
29		29
30	int (start)(struct stdio_dev dev); /* To start the device */	30	int (start)(struct stdio_dev dev); /* To start the device */
31	int (stop)(struct stdio_dev dev); /* To stop the device */	31	int (stop)(struct stdio_dev dev); /* To stop the device */
32		32
33	/* OUTPUT functions */	33	/* OUTPUT functions */
34		34
35	/* To put a char */	35	/* To put a char */
36	void (putc)(struct stdio_dev dev, const char c);	36	void (putc)(struct stdio_dev dev, const char c);
37	/* To put a string (accelerator) */	37	/* To put a string (accelerator) */
38	void (puts)(struct stdio_dev dev, const char *s);	38	void (puts)(struct stdio_dev dev, const char *s);
39		39
40	/* INPUT functions */	40	/* INPUT functions */
41		41
42	/* To test if a char is ready... */	42	/* To test if a char is ready... */
43	int (tstc)(struct stdio_dev dev);	43	int (tstc)(struct stdio_dev dev);
44	int (getc)(struct stdio_dev dev); /* To get that char */	44	int (getc)(struct stdio_dev dev); /* To get that char */
45		45
46	/* Other functions */	46	/* Other functions */
47		47
48	void priv; / Private extensions */	48	void priv; / Private extensions */
49	struct list_head list;	49	struct list_head list;
50	};	50	};
51		51
52	/*	52	/*
53	* VIDEO EXTENSIONS	53	* VIDEO EXTENSIONS
54	*/	54	*/
55	#define VIDEO_FORMAT_RGB_INDEXED 0x0000	55	#define VIDEO_FORMAT_RGB_INDEXED 0x0000
56	#define VIDEO_FORMAT_RGB_DIRECTCOLOR 0x0001	56	#define VIDEO_FORMAT_RGB_DIRECTCOLOR 0x0001
57	#define VIDEO_FORMAT_YUYV_4_4_4 0x0010	57	#define VIDEO_FORMAT_YUYV_4_4_4 0x0010
58	#define VIDEO_FORMAT_YUYV_4_2_2 0x0011	58	#define VIDEO_FORMAT_YUYV_4_2_2 0x0011
59		59
60	typedef struct {	60	typedef struct {
61	void address; / Address of framebuffer */	61	void address; / Address of framebuffer */
62	ushort width; /* Horizontal resolution */	62	ushort width; /* Horizontal resolution */
63	ushort height; /* Vertical resolution */	63	ushort height; /* Vertical resolution */
64	uchar format; /* Format */	64	uchar format; /* Format */
65	uchar colors; /* Colors number or color depth */	65	uchar colors; /* Colors number or color depth */
66	void (*setcolreg) (int, int, int, int);	66	void (*setcolreg) (int, int, int, int);
67	void (getcolreg) (int, void );	67	void (getcolreg) (int, void );
68	} video_ext_t;	68	} video_ext_t;
69		69
70	/*	70	/*
71	* VARIABLES	71	* VARIABLES
72	*/	72	*/
73	extern struct stdio_dev *stdio_devices[];	73	extern struct stdio_dev *stdio_devices[];
74	extern char *stdio_names[MAX_FILES];	74	extern char *stdio_names[MAX_FILES];
75		75
76	/*	76	/*
77	* PROTOTYPES	77	* PROTOTYPES
78	*/	78	*/
79	int stdio_register (struct stdio_dev * dev);	79	int stdio_register (struct stdio_dev * dev);
80	int stdio_register_dev(struct stdio_dev dev, struct stdio_dev *devp);	80	int stdio_register_dev(struct stdio_dev dev, struct stdio_dev *devp);
81		81
82	/**	82	/**
83	* stdio_init_tables() - set up stdio tables ready for devices	83	* stdio_init_tables() - set up stdio tables ready for devices
84	*	84	*
85	* This does not add any devices, but just prepares stdio for use.	85	* This does not add any devices, but just prepares stdio for use.
86	*/	86	*/
87	int stdio_init_tables(void);	87	int stdio_init_tables(void);
88		88
89	/**	89	/**
90	* stdio_add_devices() - Add stdio devices to the table	90	* stdio_add_devices() - Add stdio devices to the table
91	*	91	*
92	* This makes calls to all the various subsystems that use stdio, to make	92	* This makes calls to all the various subsystems that use stdio, to make
93	* them register with stdio.	93	* them register with stdio.
94	*/	94	*/
95	int stdio_add_devices(void);	95	int stdio_add_devices(void);
96		96
97	/**	97	/**
98	* stdio_init() - Sets up stdio ready for use	98	* stdio_init() - Sets up stdio ready for use
99	*	99	*
100	* This calls stdio_init_tables() and stdio_add_devices()	100	* This calls stdio_init_tables() and stdio_add_devices()
101	*/	101	*/
102	int stdio_init(void);	102	int stdio_init(void);
103		103
104	void stdio_print_current_devices(void);	104	void stdio_print_current_devices(void);
105	#ifdef CONFIG_SYS_STDIO_DEREGISTER	105	#ifdef CONFIG_SYS_STDIO_DEREGISTER
106	int stdio_deregister(const char *devname);	106	int stdio_deregister(const char *devname, int force);
107	int stdio_deregister_dev(struct stdio_dev *dev);	107	int stdio_deregister_dev(struct stdio_dev *dev, int force);
108	#endif	108	#endif
109	struct list_head* stdio_get_list(void);	109	struct list_head* stdio_get_list(void);
110	struct stdio_dev* stdio_get_by_name(const char* name);	110	struct stdio_dev* stdio_get_by_name(const char* name);
111	struct stdio_dev* stdio_clone(struct stdio_dev *dev);	111	struct stdio_dev* stdio_clone(struct stdio_dev *dev);
112		112
113	#ifdef CONFIG_LCD	113	#ifdef CONFIG_LCD
114	int drv_lcd_init (void);	114	int drv_lcd_init (void);
115	#endif	115	#endif
116	#if defined(CONFIG_VIDEO) \|\| defined(CONFIG_CFB_CONSOLE)	116	#if defined(CONFIG_VIDEO) \|\| defined(CONFIG_CFB_CONSOLE)
117	int drv_video_init (void);	117	int drv_video_init (void);
118	#endif	118	#endif
119	#ifdef CONFIG_KEYBOARD	119	#ifdef CONFIG_KEYBOARD
120	int drv_keyboard_init (void);	120	int drv_keyboard_init (void);
121	#endif	121	#endif
122	#ifdef CONFIG_USB_TTY	122	#ifdef CONFIG_USB_TTY
123	int drv_usbtty_init (void);	123	int drv_usbtty_init (void);
124	#endif	124	#endif
125	#ifdef CONFIG_NETCONSOLE	125	#ifdef CONFIG_NETCONSOLE
126	int drv_nc_init (void);	126	int drv_nc_init (void);
127	#endif	127	#endif
128	#ifdef CONFIG_JTAG_CONSOLE	128	#ifdef CONFIG_JTAG_CONSOLE
129	int drv_jtag_console_init (void);	129	int drv_jtag_console_init (void);
130	#endif	130	#endif
131	#ifdef CONFIG_CBMEM_CONSOLE	131	#ifdef CONFIG_CBMEM_CONSOLE
132	int cbmemc_init(void);	132	int cbmemc_init(void);
133	#endif	133	#endif
134		134
135	#endif	135	#endif
136		136

include/usb.h

Diff comments View file @ 8a6b088

1	/*	1	/*
2	* (C) Copyright 2001	2	* (C) Copyright 2001
3	* Denis Peter, MPL AG Switzerland	3	* Denis Peter, MPL AG Switzerland
4	*	4	*
5	* SPDX-License-Identifier: GPL-2.0+	5	* SPDX-License-Identifier: GPL-2.0+
6	* Note: Part of this code has been derived from linux	6	* Note: Part of this code has been derived from linux
7	*	7	*
8	*/	8	*/
9	#ifndef _USB_H_	9	#ifndef _USB_H_
10	#define _USB_H_	10	#define _USB_H_
11		11
12	#include <usb_defs.h>	12	#include <usb_defs.h>
13	#include <linux/usb/ch9.h>	13	#include <linux/usb/ch9.h>
14		14
15	/*	15	/*
16	* The EHCI spec says that we must align to at least 32 bytes. However,	16	* The EHCI spec says that we must align to at least 32 bytes. However,
17	* some platforms require larger alignment.	17	* some platforms require larger alignment.
18	*/	18	*/
19	#if ARCH_DMA_MINALIGN > 32	19	#if ARCH_DMA_MINALIGN > 32
20	#define USB_DMA_MINALIGN ARCH_DMA_MINALIGN	20	#define USB_DMA_MINALIGN ARCH_DMA_MINALIGN
21	#else	21	#else
22	#define USB_DMA_MINALIGN 32	22	#define USB_DMA_MINALIGN 32
23	#endif	23	#endif
24		24
25	/* Everything is aribtrary */	25	/* Everything is aribtrary */
26	#define USB_ALTSETTINGALLOC 4	26	#define USB_ALTSETTINGALLOC 4
27	#define USB_MAXALTSETTING 128 /* Hard limit */	27	#define USB_MAXALTSETTING 128 /* Hard limit */
28		28
29	#define USB_MAX_DEVICE 32	29	#define USB_MAX_DEVICE 32
30	#define USB_MAXCONFIG 8	30	#define USB_MAXCONFIG 8
31	#define USB_MAXINTERFACES 8	31	#define USB_MAXINTERFACES 8
32	#define USB_MAXENDPOINTS 16	32	#define USB_MAXENDPOINTS 16
33	#define USB_MAXCHILDREN 8 /* This is arbitrary */	33	#define USB_MAXCHILDREN 8 /* This is arbitrary */
34	#define USB_MAX_HUB 16	34	#define USB_MAX_HUB 16
35		35
36	#define USB_CNTL_TIMEOUT 100 /* 100ms timeout */	36	#define USB_CNTL_TIMEOUT 100 /* 100ms timeout */
37		37
38	/*	38	/*
39	* This is the timeout to allow for submitting an urb in ms. We allow more	39	* This is the timeout to allow for submitting an urb in ms. We allow more
40	* time for a BULK device to react - some are slow.	40	* time for a BULK device to react - some are slow.
41	*/	41	*/
42	#define USB_TIMEOUT_MS(pipe) (usb_pipebulk(pipe) ? 5000 : 1000)	42	#define USB_TIMEOUT_MS(pipe) (usb_pipebulk(pipe) ? 5000 : 1000)
43		43
44	/* device request (setup) */	44	/* device request (setup) */
45	struct devrequest {	45	struct devrequest {
46	unsigned char requesttype;	46	unsigned char requesttype;
47	unsigned char request;	47	unsigned char request;
48	unsigned short value;	48	unsigned short value;
49	unsigned short index;	49	unsigned short index;
50	unsigned short length;	50	unsigned short length;
51	} __attribute__ ((packed));	51	} __attribute__ ((packed));
52		52
53	/* Interface */	53	/* Interface */
54	struct usb_interface {	54	struct usb_interface {
55	struct usb_interface_descriptor desc;	55	struct usb_interface_descriptor desc;
56		56
57	unsigned char no_of_ep;	57	unsigned char no_of_ep;
58	unsigned char num_altsetting;	58	unsigned char num_altsetting;
59	unsigned char act_altsetting;	59	unsigned char act_altsetting;
60		60
61	struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS];	61	struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS];
62	/*	62	/*
63	* Super Speed Device will have Super Speed Endpoint	63	* Super Speed Device will have Super Speed Endpoint
64	* Companion Descriptor (section 9.6.7 of usb 3.0 spec)	64	* Companion Descriptor (section 9.6.7 of usb 3.0 spec)
65	* Revision 1.0 June 6th 2011	65	* Revision 1.0 June 6th 2011
66	*/	66	*/
67	struct usb_ss_ep_comp_descriptor ss_ep_comp_desc[USB_MAXENDPOINTS];	67	struct usb_ss_ep_comp_descriptor ss_ep_comp_desc[USB_MAXENDPOINTS];
68	} __attribute__ ((packed));	68	} __attribute__ ((packed));
69		69
70	/* Configuration information.. */	70	/* Configuration information.. */
71	struct usb_config {	71	struct usb_config {
72	struct usb_config_descriptor desc;	72	struct usb_config_descriptor desc;
73		73
74	unsigned char no_of_if; /* number of interfaces */	74	unsigned char no_of_if; /* number of interfaces */
75	struct usb_interface if_desc[USB_MAXINTERFACES];	75	struct usb_interface if_desc[USB_MAXINTERFACES];
76	} __attribute__ ((packed));	76	} __attribute__ ((packed));
77		77
78	enum {	78	enum {
79	/* Maximum packet size; encoded as 0,1,2,3 = 8,16,32,64 */	79	/* Maximum packet size; encoded as 0,1,2,3 = 8,16,32,64 */
80	PACKET_SIZE_8 = 0,	80	PACKET_SIZE_8 = 0,
81	PACKET_SIZE_16 = 1,	81	PACKET_SIZE_16 = 1,
82	PACKET_SIZE_32 = 2,	82	PACKET_SIZE_32 = 2,
83	PACKET_SIZE_64 = 3,	83	PACKET_SIZE_64 = 3,
84	};	84	};
85		85
86	struct usb_device {	86	struct usb_device {
87	int devnum; /* Device number on USB bus */	87	int devnum; /* Device number on USB bus */
88	int speed; /* full/low/high */	88	int speed; /* full/low/high */
89	char mf[32]; /* manufacturer */	89	char mf[32]; /* manufacturer */
90	char prod[32]; /* product */	90	char prod[32]; /* product */
91	char serial[32]; /* serial number */	91	char serial[32]; /* serial number */
92		92
93	/* Maximum packet size; one of: PACKET_SIZE_* */	93	/* Maximum packet size; one of: PACKET_SIZE_* */
94	int maxpacketsize;	94	int maxpacketsize;
95	/* one bit for each endpoint ([0] = IN, [1] = OUT) */	95	/* one bit for each endpoint ([0] = IN, [1] = OUT) */
96	unsigned int toggle[2];	96	unsigned int toggle[2];
97	/* endpoint halts; one bit per endpoint # & direction;	97	/* endpoint halts; one bit per endpoint # & direction;
98	* [0] = IN, [1] = OUT	98	* [0] = IN, [1] = OUT
99	*/	99	*/
100	unsigned int halted[2];	100	unsigned int halted[2];
101	int epmaxpacketin[16]; /* INput endpoint specific maximums */	101	int epmaxpacketin[16]; /* INput endpoint specific maximums */
102	int epmaxpacketout[16]; /* OUTput endpoint specific maximums */	102	int epmaxpacketout[16]; /* OUTput endpoint specific maximums */
103		103
104	int configno; /* selected config number */	104	int configno; /* selected config number */
105	/* Device Descriptor */	105	/* Device Descriptor */
106	struct usb_device_descriptor descriptor	106	struct usb_device_descriptor descriptor
107	__attribute__((aligned(ARCH_DMA_MINALIGN)));	107	__attribute__((aligned(ARCH_DMA_MINALIGN)));
108	struct usb_config config; /* config descriptor */	108	struct usb_config config; /* config descriptor */
109		109
110	int have_langid; /* whether string_langid is valid yet */	110	int have_langid; /* whether string_langid is valid yet */
111	int string_langid; /* language ID for strings */	111	int string_langid; /* language ID for strings */
112	int (irq_handle)(struct usb_device dev);	112	int (irq_handle)(struct usb_device dev);
113	unsigned long irq_status;	113	unsigned long irq_status;
114	int irq_act_len; /* transfered bytes */	114	int irq_act_len; /* transfered bytes */
115	void *privptr;	115	void *privptr;
116	/*	116	/*
117	* Child devices - if this is a hub device	117	* Child devices - if this is a hub device
118	* Each instance needs its own set of data structures.	118	* Each instance needs its own set of data structures.
119	*/	119	*/
120	unsigned long status;	120	unsigned long status;
121	int act_len; /* transfered bytes */	121	int act_len; /* transfered bytes */
122	int maxchild; /* Number of ports if hub */	122	int maxchild; /* Number of ports if hub */
123	int portnr;	123	int portnr;
124	struct usb_device *parent;	124	struct usb_device *parent;
125	struct usb_device *children[USB_MAXCHILDREN];	125	struct usb_device *children[USB_MAXCHILDREN];
126		126
127	void controller; / hardware controller private data */	127	void controller; / hardware controller private data */
128	/* slot_id - for xHCI enabled devices */	128	/* slot_id - for xHCI enabled devices */
129	unsigned int slot_id;	129	unsigned int slot_id;
130	};	130	};
131		131
132	/*	132	/*
133	* You can initialize platform's USB host or device	133	* You can initialize platform's USB host or device
134	* ports by passing this enum as an argument to	134	* ports by passing this enum as an argument to
135	* board_usb_init().	135	* board_usb_init().
136	*/	136	*/
137	enum usb_init_type {	137	enum usb_init_type {
138	USB_INIT_HOST,	138	USB_INIT_HOST,
139	USB_INIT_DEVICE	139	USB_INIT_DEVICE
140	};	140	};
141		141
142	/**********************************************************************	142	/**********************************************************************
143	* this is how the lowlevel part communicate with the outer world	143	* this is how the lowlevel part communicate with the outer world
144	*/	144	*/
145		145
146	#if defined(CONFIG_USB_UHCI) \|\| defined(CONFIG_USB_OHCI) \|\| \	146	#if defined(CONFIG_USB_UHCI) \|\| defined(CONFIG_USB_OHCI) \|\| \
147	defined(CONFIG_USB_EHCI) \|\| defined(CONFIG_USB_OHCI_NEW) \|\| \	147	defined(CONFIG_USB_EHCI) \|\| defined(CONFIG_USB_OHCI_NEW) \|\| \
148	defined(CONFIG_USB_SL811HS) \|\| defined(CONFIG_USB_ISP116X_HCD) \|\| \	148	defined(CONFIG_USB_SL811HS) \|\| defined(CONFIG_USB_ISP116X_HCD) \|\| \
149	defined(CONFIG_USB_R8A66597_HCD) \|\| defined(CONFIG_USB_DAVINCI) \|\| \	149	defined(CONFIG_USB_R8A66597_HCD) \|\| defined(CONFIG_USB_DAVINCI) \|\| \
150	defined(CONFIG_USB_OMAP3) \|\| defined(CONFIG_USB_DA8XX) \|\| \	150	defined(CONFIG_USB_OMAP3) \|\| defined(CONFIG_USB_DA8XX) \|\| \
151	defined(CONFIG_USB_BLACKFIN) \|\| defined(CONFIG_USB_AM35X) \|\| \	151	defined(CONFIG_USB_BLACKFIN) \|\| defined(CONFIG_USB_AM35X) \|\| \
152	defined(CONFIG_USB_MUSB_DSPS) \|\| defined(CONFIG_USB_MUSB_AM35X) \|\| \	152	defined(CONFIG_USB_MUSB_DSPS) \|\| defined(CONFIG_USB_MUSB_AM35X) \|\| \
153	defined(CONFIG_USB_MUSB_OMAP2PLUS) \|\| defined(CONFIG_USB_XHCI)	153	defined(CONFIG_USB_MUSB_OMAP2PLUS) \|\| defined(CONFIG_USB_XHCI)
154		154
155	int usb_lowlevel_init(int index, enum usb_init_type init, void **controller);	155	int usb_lowlevel_init(int index, enum usb_init_type init, void **controller);
156	int usb_lowlevel_stop(int index);	156	int usb_lowlevel_stop(int index);
157		157
158	int submit_bulk_msg(struct usb_device *dev, unsigned long pipe,	158	int submit_bulk_msg(struct usb_device *dev, unsigned long pipe,
159	void *buffer, int transfer_len);	159	void *buffer, int transfer_len);
160	int submit_control_msg(struct usb_device dev, unsigned long pipe, void buffer,	160	int submit_control_msg(struct usb_device dev, unsigned long pipe, void buffer,
161	int transfer_len, struct devrequest *setup);	161	int transfer_len, struct devrequest *setup);
162	int submit_int_msg(struct usb_device dev, unsigned long pipe, void buffer,	162	int submit_int_msg(struct usb_device dev, unsigned long pipe, void buffer,
163	int transfer_len, int interval);	163	int transfer_len, int interval);
164		164
165	/* Defines */	165	/* Defines */
166	#define USB_UHCI_VEND_ID 0x8086	166	#define USB_UHCI_VEND_ID 0x8086
167	#define USB_UHCI_DEV_ID 0x7112	167	#define USB_UHCI_DEV_ID 0x7112
168		168
169	/*	169	/*
170	* PXA25x can only act as USB device. There are drivers	170	* PXA25x can only act as USB device. There are drivers
171	* which works with USB CDC gadgets implementations.	171	* which works with USB CDC gadgets implementations.
172	* Some of them have common routines which can be used	172	* Some of them have common routines which can be used
173	* in boards init functions e.g. udc_disconnect() used for	173	* in boards init functions e.g. udc_disconnect() used for
174	* forced device disconnection from host.	174	* forced device disconnection from host.
175	*/	175	*/
176	#elif defined(CONFIG_USB_GADGET_PXA2XX)	176	#elif defined(CONFIG_USB_GADGET_PXA2XX)
177		177
178	extern void udc_disconnect(void);	178	extern void udc_disconnect(void);
179		179
180	#endif	180	#endif
181		181
182	/*	182	/*
183	* board-specific hardware initialization, called by	183	* board-specific hardware initialization, called by
184	* usb drivers and u-boot commands	184	* usb drivers and u-boot commands
185	*	185	*
186	* @param index USB controller number	186	* @param index USB controller number
187	* @param init initializes controller as USB host or device	187	* @param init initializes controller as USB host or device
188	*/	188	*/
189	int board_usb_init(int index, enum usb_init_type init);	189	int board_usb_init(int index, enum usb_init_type init);
190		190
191	/*	191	/*
192	* can be used to clean up after failed USB initialization attempt	192	* can be used to clean up after failed USB initialization attempt
193	* vide: board_usb_init()	193	* vide: board_usb_init()
194	*	194	*
195	* @param index USB controller number for selective cleanup	195	* @param index USB controller number for selective cleanup
196	* @param init usb_init_type passed to board_usb_init()	196	* @param init usb_init_type passed to board_usb_init()
197	*/	197	*/
198	int board_usb_cleanup(int index, enum usb_init_type init);	198	int board_usb_cleanup(int index, enum usb_init_type init);
199		199
200	#ifdef CONFIG_USB_STORAGE	200	#ifdef CONFIG_USB_STORAGE
201		201
202	#define USB_MAX_STOR_DEV 5	202	#define USB_MAX_STOR_DEV 5
203	block_dev_desc_t *usb_stor_get_dev(int index);	203	block_dev_desc_t *usb_stor_get_dev(int index);
204	int usb_stor_scan(int mode);	204	int usb_stor_scan(int mode);
205	int usb_stor_info(void);	205	int usb_stor_info(void);
206		206
207	#endif	207	#endif
208		208
209	#ifdef CONFIG_USB_HOST_ETHER	209	#ifdef CONFIG_USB_HOST_ETHER
210		210
211	#define USB_MAX_ETH_DEV 5	211	#define USB_MAX_ETH_DEV 5
212	int usb_host_eth_scan(int mode);	212	int usb_host_eth_scan(int mode);
213		213
214	#endif	214	#endif
215		215
216	#ifdef CONFIG_USB_KEYBOARD	216	#ifdef CONFIG_USB_KEYBOARD
217		217
218	int drv_usb_kbd_init(void);	218	int drv_usb_kbd_init(void);
219	int usb_kbd_deregister(void);	219	int usb_kbd_deregister(int force);
220		220
221	#endif	221	#endif
222	/* routines */	222	/* routines */
223	int usb_init(void); /* initialize the USB Controller */	223	int usb_init(void); /* initialize the USB Controller */
224	int usb_stop(void); /* stop the USB Controller */	224	int usb_stop(void); /* stop the USB Controller */
225		225
226		226
227	int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol);	227	int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol);
228	int usb_set_idle(struct usb_device *dev, int ifnum, int duration,	228	int usb_set_idle(struct usb_device *dev, int ifnum, int duration,
229	int report_id);	229	int report_id);
230	struct usb_device *usb_get_dev_index(int index);	230	struct usb_device *usb_get_dev_index(int index);
231	int usb_control_msg(struct usb_device *dev, unsigned int pipe,	231	int usb_control_msg(struct usb_device *dev, unsigned int pipe,
232	unsigned char request, unsigned char requesttype,	232	unsigned char request, unsigned char requesttype,
233	unsigned short value, unsigned short index,	233	unsigned short value, unsigned short index,
234	void *data, unsigned short size, int timeout);	234	void *data, unsigned short size, int timeout);
235	int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,	235	int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
236	void data, int len, int actual_length, int timeout);	236	void data, int len, int actual_length, int timeout);
237	int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe,	237	int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe,
238	void *buffer, int transfer_len, int interval);	238	void *buffer, int transfer_len, int interval);
239	int usb_disable_asynch(int disable);	239	int usb_disable_asynch(int disable);
240	int usb_maxpacket(struct usb_device *dev, unsigned long pipe);	240	int usb_maxpacket(struct usb_device *dev, unsigned long pipe);
241	int usb_get_configuration_no(struct usb_device dev, unsigned char buffer,	241	int usb_get_configuration_no(struct usb_device dev, unsigned char buffer,
242	int cfgno);	242	int cfgno);
243	int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type,	243	int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type,
244	unsigned char id, void *buf, int size);	244	unsigned char id, void *buf, int size);
245	int usb_get_class_descriptor(struct usb_device *dev, int ifnum,	245	int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
246	unsigned char type, unsigned char id, void *buf,	246	unsigned char type, unsigned char id, void *buf,
247	int size);	247	int size);
248	int usb_clear_halt(struct usb_device *dev, int pipe);	248	int usb_clear_halt(struct usb_device *dev, int pipe);
249	int usb_string(struct usb_device dev, int index, char buf, size_t size);	249	int usb_string(struct usb_device dev, int index, char buf, size_t size);
250	int usb_set_interface(struct usb_device *dev, int interface, int alternate);	250	int usb_set_interface(struct usb_device *dev, int interface, int alternate);
251		251
252	/* big endian -> little endian conversion */	252	/* big endian -> little endian conversion */
253	/* some CPUs are already little endian e.g. the ARM920T */	253	/* some CPUs are already little endian e.g. the ARM920T */
254	#define __swap_16(x) \	254	#define __swap_16(x) \
255	({ unsigned short x_ = (unsigned short)x; \	255	({ unsigned short x_ = (unsigned short)x; \
256	(unsigned short)( \	256	(unsigned short)( \
257	((x_ & 0x00FFU) << 8) \| ((x_ & 0xFF00U) >> 8)); \	257	((x_ & 0x00FFU) << 8) \| ((x_ & 0xFF00U) >> 8)); \
258	})	258	})
259	#define __swap_32(x) \	259	#define __swap_32(x) \
260	({ unsigned long x_ = (unsigned long)x; \	260	({ unsigned long x_ = (unsigned long)x; \
261	(unsigned long)( \	261	(unsigned long)( \
262	((x_ & 0x000000FFUL) << 24) \| \	262	((x_ & 0x000000FFUL) << 24) \| \
263	((x_ & 0x0000FF00UL) << 8) \| \	263	((x_ & 0x0000FF00UL) << 8) \| \
264	((x_ & 0x00FF0000UL) >> 8) \| \	264	((x_ & 0x00FF0000UL) >> 8) \| \
265	((x_ & 0xFF000000UL) >> 24)); \	265	((x_ & 0xFF000000UL) >> 24)); \
266	})	266	})
267		267
268	#ifdef __LITTLE_ENDIAN	268	#ifdef __LITTLE_ENDIAN
269	# define swap_16(x) (x)	269	# define swap_16(x) (x)
270	# define swap_32(x) (x)	270	# define swap_32(x) (x)
271	#else	271	#else
272	# define swap_16(x) __swap_16(x)	272	# define swap_16(x) __swap_16(x)
273	# define swap_32(x) __swap_32(x)	273	# define swap_32(x) __swap_32(x)
274	#endif	274	#endif
275		275
276	/*	276	/*
277	* Calling this entity a "pipe" is glorifying it. A USB pipe	277	* Calling this entity a "pipe" is glorifying it. A USB pipe
278	* is something embarrassingly simple: it basically consists	278	* is something embarrassingly simple: it basically consists
279	* of the following information:	279	* of the following information:
280	* - device number (7 bits)	280	* - device number (7 bits)
281	* - endpoint number (4 bits)	281	* - endpoint number (4 bits)
282	* - current Data0/1 state (1 bit)	282	* - current Data0/1 state (1 bit)
283	* - direction (1 bit)	283	* - direction (1 bit)
284	* - speed (2 bits)	284	* - speed (2 bits)
285	* - max packet size (2 bits: 8, 16, 32 or 64)	285	* - max packet size (2 bits: 8, 16, 32 or 64)
286	* - pipe type (2 bits: control, interrupt, bulk, isochronous)	286	* - pipe type (2 bits: control, interrupt, bulk, isochronous)
287	*	287	*
288	* That's 18 bits. Really. Nothing more. And the USB people have	288	* That's 18 bits. Really. Nothing more. And the USB people have
289	* documented these eighteen bits as some kind of glorious	289	* documented these eighteen bits as some kind of glorious
290	* virtual data structure.	290	* virtual data structure.
291	*	291	*
292	* Let's not fall in that trap. We'll just encode it as a simple	292	* Let's not fall in that trap. We'll just encode it as a simple
293	* unsigned int. The encoding is:	293	* unsigned int. The encoding is:
294	*	294	*
295	* - max size: bits 0-1 (00 = 8, 01 = 16, 10 = 32, 11 = 64)	295	* - max size: bits 0-1 (00 = 8, 01 = 16, 10 = 32, 11 = 64)
296	* - direction: bit 7 (0 = Host-to-Device [Out],	296	* - direction: bit 7 (0 = Host-to-Device [Out],
297	* (1 = Device-to-Host [In])	297	* (1 = Device-to-Host [In])
298	* - device: bits 8-14	298	* - device: bits 8-14
299	* - endpoint: bits 15-18	299	* - endpoint: bits 15-18
300	* - Data0/1: bit 19	300	* - Data0/1: bit 19
301	* - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt,	301	* - pipe type: bits 30-31 (00 = isochronous, 01 = interrupt,
302	* 10 = control, 11 = bulk)	302	* 10 = control, 11 = bulk)
303	*	303	*
304	* Why? Because it's arbitrary, and whatever encoding we select is really	304	* Why? Because it's arbitrary, and whatever encoding we select is really
305	* up to us. This one happens to share a lot of bit positions with the UHCI	305	* up to us. This one happens to share a lot of bit positions with the UHCI
306	* specification, so that much of the uhci driver can just mask the bits	306	* specification, so that much of the uhci driver can just mask the bits
307	* appropriately.	307	* appropriately.
308	*/	308	*/
309	/* Create various pipes... */	309	/* Create various pipes... */
310	#define create_pipe(dev,endpoint) \	310	#define create_pipe(dev,endpoint) \
311	(((dev)->devnum << 8) \| ((endpoint) << 15) \| \	311	(((dev)->devnum << 8) \| ((endpoint) << 15) \| \
312	(dev)->maxpacketsize)	312	(dev)->maxpacketsize)
313	#define default_pipe(dev) ((dev)->speed << 26)	313	#define default_pipe(dev) ((dev)->speed << 26)
314		314
315	#define usb_sndctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) \| \	315	#define usb_sndctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) \| \
316	create_pipe(dev, endpoint))	316	create_pipe(dev, endpoint))
317	#define usb_rcvctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) \| \	317	#define usb_rcvctrlpipe(dev, endpoint) ((PIPE_CONTROL << 30) \| \
318	create_pipe(dev, endpoint) \| \	318	create_pipe(dev, endpoint) \| \
319	USB_DIR_IN)	319	USB_DIR_IN)
320	#define usb_sndisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) \| \	320	#define usb_sndisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) \| \
321	create_pipe(dev, endpoint))	321	create_pipe(dev, endpoint))
322	#define usb_rcvisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) \| \	322	#define usb_rcvisocpipe(dev, endpoint) ((PIPE_ISOCHRONOUS << 30) \| \
323	create_pipe(dev, endpoint) \| \	323	create_pipe(dev, endpoint) \| \
324	USB_DIR_IN)	324	USB_DIR_IN)
325	#define usb_sndbulkpipe(dev, endpoint) ((PIPE_BULK << 30) \| \	325	#define usb_sndbulkpipe(dev, endpoint) ((PIPE_BULK << 30) \| \
326	create_pipe(dev, endpoint))	326	create_pipe(dev, endpoint))
327	#define usb_rcvbulkpipe(dev, endpoint) ((PIPE_BULK << 30) \| \	327	#define usb_rcvbulkpipe(dev, endpoint) ((PIPE_BULK << 30) \| \
328	create_pipe(dev, endpoint) \| \	328	create_pipe(dev, endpoint) \| \
329	USB_DIR_IN)	329	USB_DIR_IN)
330	#define usb_sndintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) \| \	330	#define usb_sndintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) \| \
331	create_pipe(dev, endpoint))	331	create_pipe(dev, endpoint))
332	#define usb_rcvintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) \| \	332	#define usb_rcvintpipe(dev, endpoint) ((PIPE_INTERRUPT << 30) \| \
333	create_pipe(dev, endpoint) \| \	333	create_pipe(dev, endpoint) \| \
334	USB_DIR_IN)	334	USB_DIR_IN)
335	#define usb_snddefctrl(dev) ((PIPE_CONTROL << 30) \| \	335	#define usb_snddefctrl(dev) ((PIPE_CONTROL << 30) \| \
336	default_pipe(dev))	336	default_pipe(dev))
337	#define usb_rcvdefctrl(dev) ((PIPE_CONTROL << 30) \| \	337	#define usb_rcvdefctrl(dev) ((PIPE_CONTROL << 30) \| \
338	default_pipe(dev) \| \	338	default_pipe(dev) \| \
339	USB_DIR_IN)	339	USB_DIR_IN)
340		340
341	/* The D0/D1 toggle bits */	341	/* The D0/D1 toggle bits */
342	#define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> ep) & 1)	342	#define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> ep) & 1)
343	#define usb_dotoggle(dev, ep, out) ((dev)->toggle[out] ^= (1 << ep))	343	#define usb_dotoggle(dev, ep, out) ((dev)->toggle[out] ^= (1 << ep))
344	#define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = \	344	#define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = \
345	((dev)->toggle[out] & \	345	((dev)->toggle[out] & \
346	~(1 << ep)) \| ((bit) << ep))	346	~(1 << ep)) \| ((bit) << ep))
347		347
348	/* Endpoint halt control/status */	348	/* Endpoint halt control/status */
349	#define usb_endpoint_out(ep_dir) (((ep_dir >> 7) & 1) ^ 1)	349	#define usb_endpoint_out(ep_dir) (((ep_dir >> 7) & 1) ^ 1)
350	#define usb_endpoint_halt(dev, ep, out) ((dev)->halted[out] \|= (1 << (ep)))	350	#define usb_endpoint_halt(dev, ep, out) ((dev)->halted[out] \|= (1 << (ep)))
351	#define usb_endpoint_running(dev, ep, out) ((dev)->halted[out] &= ~(1 << (ep)))	351	#define usb_endpoint_running(dev, ep, out) ((dev)->halted[out] &= ~(1 << (ep)))
352	#define usb_endpoint_halted(dev, ep, out) ((dev)->halted[out] & (1 << (ep)))	352	#define usb_endpoint_halted(dev, ep, out) ((dev)->halted[out] & (1 << (ep)))
353		353
354	#define usb_packetid(pipe) (((pipe) & USB_DIR_IN) ? USB_PID_IN : \	354	#define usb_packetid(pipe) (((pipe) & USB_DIR_IN) ? USB_PID_IN : \
355	USB_PID_OUT)	355	USB_PID_OUT)
356		356
357	#define usb_pipeout(pipe) ((((pipe) >> 7) & 1) ^ 1)	357	#define usb_pipeout(pipe) ((((pipe) >> 7) & 1) ^ 1)
358	#define usb_pipein(pipe) (((pipe) >> 7) & 1)	358	#define usb_pipein(pipe) (((pipe) >> 7) & 1)
359	#define usb_pipedevice(pipe) (((pipe) >> 8) & 0x7f)	359	#define usb_pipedevice(pipe) (((pipe) >> 8) & 0x7f)
360	#define usb_pipe_endpdev(pipe) (((pipe) >> 8) & 0x7ff)	360	#define usb_pipe_endpdev(pipe) (((pipe) >> 8) & 0x7ff)
361	#define usb_pipeendpoint(pipe) (((pipe) >> 15) & 0xf)	361	#define usb_pipeendpoint(pipe) (((pipe) >> 15) & 0xf)
362	#define usb_pipedata(pipe) (((pipe) >> 19) & 1)	362	#define usb_pipedata(pipe) (((pipe) >> 19) & 1)
363	#define usb_pipetype(pipe) (((pipe) >> 30) & 3)	363	#define usb_pipetype(pipe) (((pipe) >> 30) & 3)
364	#define usb_pipeisoc(pipe) (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS)	364	#define usb_pipeisoc(pipe) (usb_pipetype((pipe)) == PIPE_ISOCHRONOUS)
365	#define usb_pipeint(pipe) (usb_pipetype((pipe)) == PIPE_INTERRUPT)	365	#define usb_pipeint(pipe) (usb_pipetype((pipe)) == PIPE_INTERRUPT)
366	#define usb_pipecontrol(pipe) (usb_pipetype((pipe)) == PIPE_CONTROL)	366	#define usb_pipecontrol(pipe) (usb_pipetype((pipe)) == PIPE_CONTROL)
367	#define usb_pipebulk(pipe) (usb_pipetype((pipe)) == PIPE_BULK)	367	#define usb_pipebulk(pipe) (usb_pipetype((pipe)) == PIPE_BULK)
368		368
369	#define usb_pipe_ep_index(pipe) \	369	#define usb_pipe_ep_index(pipe) \
370	usb_pipecontrol(pipe) ? (usb_pipeendpoint(pipe) * 2) : \	370	usb_pipecontrol(pipe) ? (usb_pipeendpoint(pipe) * 2) : \
371	((usb_pipeendpoint(pipe) * 2) - \	371	((usb_pipeendpoint(pipe) * 2) - \
372	(usb_pipein(pipe) ? 0 : 1))	372	(usb_pipein(pipe) ? 0 : 1))
373		373
374	/*************************************************************************	374	/*************************************************************************
375	* Hub Stuff	375	* Hub Stuff
376	*/	376	*/
377	struct usb_port_status {	377	struct usb_port_status {
378	unsigned short wPortStatus;	378	unsigned short wPortStatus;
379	unsigned short wPortChange;	379	unsigned short wPortChange;
380	} __attribute__ ((packed));	380	} __attribute__ ((packed));
381		381
382	struct usb_hub_status {	382	struct usb_hub_status {
383	unsigned short wHubStatus;	383	unsigned short wHubStatus;
384	unsigned short wHubChange;	384	unsigned short wHubChange;
385	} __attribute__ ((packed));	385	} __attribute__ ((packed));
386		386
387		387
388	/* Hub descriptor */	388	/* Hub descriptor */
389	struct usb_hub_descriptor {	389	struct usb_hub_descriptor {
390	unsigned char bLength;	390	unsigned char bLength;
391	unsigned char bDescriptorType;	391	unsigned char bDescriptorType;
392	unsigned char bNbrPorts;	392	unsigned char bNbrPorts;
393	unsigned short wHubCharacteristics;	393	unsigned short wHubCharacteristics;
394	unsigned char bPwrOn2PwrGood;	394	unsigned char bPwrOn2PwrGood;
395	unsigned char bHubContrCurrent;	395	unsigned char bHubContrCurrent;
396	unsigned char DeviceRemovable[(USB_MAXCHILDREN+1+7)/8];	396	unsigned char DeviceRemovable[(USB_MAXCHILDREN+1+7)/8];
397	unsigned char PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8];	397	unsigned char PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8];
398	/* DeviceRemovable and PortPwrCtrlMask want to be variable-length	398	/* DeviceRemovable and PortPwrCtrlMask want to be variable-length
399	bitmaps that hold max 255 entries. (bit0 is ignored) */	399	bitmaps that hold max 255 entries. (bit0 is ignored) */
400	} __attribute__ ((packed));	400	} __attribute__ ((packed));
401		401
402		402
403	struct usb_hub_device {	403	struct usb_hub_device {
404	struct usb_device *pusb_dev;	404	struct usb_device *pusb_dev;
405	struct usb_hub_descriptor desc;	405	struct usb_hub_descriptor desc;
406	};	406	};
407		407
408	int usb_hub_probe(struct usb_device *dev, int ifnum);	408	int usb_hub_probe(struct usb_device *dev, int ifnum);
409	void usb_hub_reset(void);	409	void usb_hub_reset(void);
410	int hub_port_reset(struct usb_device *dev, int port,	410	int hub_port_reset(struct usb_device *dev, int port,
411	unsigned short *portstat);	411	unsigned short *portstat);
412		412
413	struct usb_device usb_alloc_new_device(void controller);	413	struct usb_device usb_alloc_new_device(void controller);
414		414
415	int usb_new_device(struct usb_device *dev);	415	int usb_new_device(struct usb_device *dev);
416	void usb_free_device(void);	416	void usb_free_device(void);
417	int usb_alloc_device(struct usb_device *dev);	417	int usb_alloc_device(struct usb_device *dev);
418		418
419	#endif /_USB_H_ /	419	#endif /_USB_H_ /
420		420

1	/*	1	/*
2	* Copyright (c) 2011 The Chromium OS Authors.	2	* Copyright (c) 2011 The Chromium OS Authors.
3	* Copyright (c) 2009-2013 NVIDIA Corporation	3	* Copyright (c) 2009-2013 NVIDIA Corporation
4	* Copyright (c) 2013 Lucas Stach	4	* Copyright (c) 2013 Lucas Stach
5	*	5	*
6	* SPDX-License-Identifier: GPL-2.0+	6	* SPDX-License-Identifier: GPL-2.0+
7	*/	7	*/
8		8
9	#include <common.h>	9	#include <common.h>
10	#include <asm/errno.h>	10	#include <asm/errno.h>
11	#include <asm/io.h>	11	#include <asm/io.h>
12	#include <asm-generic/gpio.h>	12	#include <asm-generic/gpio.h>
13	#include <asm/arch/clock.h>	13	#include <asm/arch/clock.h>
14	#include <asm/arch-tegra/usb.h>	14	#include <asm/arch-tegra/usb.h>
15	#include <asm/arch-tegra/clk_rst.h>	15	#include <asm/arch-tegra/clk_rst.h>
16	#include <usb.h>	16	#include <usb.h>
17	#include <usb/ulpi.h>	17	#include <usb/ulpi.h>
18	#include <libfdt.h>	18	#include <libfdt.h>
19	#include <fdtdec.h>	19	#include <fdtdec.h>
20		20
21	#include "ehci.h"	21	#include "ehci.h"
22		22
23	#define USB1_ADDR_MASK 0xFFFF0000	23	#define USB1_ADDR_MASK 0xFFFF0000
24		24
25	#define HOSTPC1_DEVLC 0x84	25	#define HOSTPC1_DEVLC 0x84
26	#define HOSTPC1_PSPD(x) (((x) >> 25) & 0x3)	26	#define HOSTPC1_PSPD(x) (((x) >> 25) & 0x3)
27		27
28	#ifdef CONFIG_USB_ULPI	28	#ifdef CONFIG_USB_ULPI
29	#ifndef CONFIG_USB_ULPI_VIEWPORT	29	#ifndef CONFIG_USB_ULPI_VIEWPORT
30	#error "To use CONFIG_USB_ULPI on Tegra Boards you have to also \	30	#error "To use CONFIG_USB_ULPI on Tegra Boards you have to also \
31	define CONFIG_USB_ULPI_VIEWPORT"	31	define CONFIG_USB_ULPI_VIEWPORT"
32	#endif	32	#endif
33	#endif	33	#endif
34		34
35	enum {	35	enum {
36	USB_PORTS_MAX = 3, /* Maximum ports we allow */	36	USB_PORTS_MAX = 3, /* Maximum ports we allow */
37	};	37	};
38		38
39	/* Parameters we need for USB */	39	/* Parameters we need for USB */
40	enum {	40	enum {