Merge git://git.denx.de/u-boot-usb

Tom Rini
2 parents a1b341989b c01c418717
Showing 13 changed files Side-by-side Diff
board/samsung/common/board.c
board/samsung/common/misc.c
board/samsung/odroid/odroid.c
common/cmd_fastboot.c
common/fb_mmc.c
doc/README.android-fastboot
drivers/dfu/dfu.c
drivers/usb/gadget/f_fastboot.c
drivers/usb/host/xhci-exynos5.c
drivers/usb/musb-new/omap2430.c
include/dfu.h
include/fb_mmc.h
include/samsung/misc.h
@@ -338,9 +338,6 @@
 #ifdef CONFIG_MISC_INIT_R
 int misc_init_r(void)
 {
-#ifdef CONFIG_SET_DFU_ALT_INFO
-	set_dfu_alt_info();
-#endif
 #ifdef CONFIG_ENV_VARS_UBOOT_RUNTIME_CONFIG
 	set_board_info();
 #endif
@@ -22,7 +22,7 @@
 DECLARE_GLOBAL_DATA_PTR;
  
 #ifdef CONFIG_SET_DFU_ALT_INFO
-void set_dfu_alt_info(void)
+void set_dfu_alt_info(char *interface, char *devstr)
 {
 	size_t buf_size = CONFIG_SET_DFU_ALT_BUF_LEN;
 	ALLOC_CACHE_ALIGN_BUFFER(char, buf, buf_size);
  
@@ -34,13 +34,13 @@
  
 	puts("DFU alt info setting: ");
  
-	alt_setting = get_dfu_alt_boot();
+	alt_setting = get_dfu_alt_boot(interface, devstr);
 	if (alt_setting) {
 		setenv("dfu_alt_boot", alt_setting);
 		offset = snprintf(buf, buf_size, "%s", alt_setting);
 	}
  
-	alt_setting = get_dfu_alt_system();
+	alt_setting = get_dfu_alt_system(interface, devstr);
 	if (alt_setting) {
 		if (offset)
 			alt_sep = ";";
@@ -15,6 +15,7 @@
 #include <power/pmic.h>
 #include <power/max77686_pmic.h>
 #include <errno.h>
+#include <mmc.h>
 #include <usb.h>
 #include <usb/s3c_udc.h>
 #include <samsung/misc.h>
  
  
  
  
@@ -61,27 +62,29 @@
 #endif
  
 #ifdef CONFIG_SET_DFU_ALT_INFO
-char *get_dfu_alt_system(void)
+char *get_dfu_alt_system(char *interface, char *devstr)
 {
 	return getenv("dfu_alt_system");
 }
  
-char *get_dfu_alt_boot(void)
+char *get_dfu_alt_boot(char *interface, char *devstr)
 {
+	struct mmc *mmc;
 	char *alt_boot;
+	int dev_num;
  
-	switch (get_boot_mode()) {
-	case BOOT_MODE_SD:
-		alt_boot = CONFIG_DFU_ALT_BOOT_SD;
-		break;
-	case BOOT_MODE_EMMC:
-	case BOOT_MODE_EMMC_SD:
-		alt_boot = CONFIG_DFU_ALT_BOOT_EMMC;
-		break;
-	default:
-		alt_boot = NULL;
-		break;
-	}
+	dev_num = simple_strtoul(devstr, NULL, 10);
+
+	mmc = find_mmc_device(dev_num);
+	if (!mmc)
+		return NULL;
+
+	if (mmc_init(mmc))
+		return NULL;
+
+	alt_boot = IS_SD(mmc) ? CONFIG_DFU_ALT_BOOT_SD :
+				CONFIG_DFU_ALT_BOOT_EMMC;
+
 	return alt_boot;
 }
 #endif
@@ -20,6 +20,12 @@
 	if (ret)
 		return ret;
  
+	if (!g_dnl_board_usb_cable_connected()) {
+		puts("\rUSB cable not detected.\n" \
+		     "Command exit.\n");
+		return CMD_RET_FAILURE;
+	}
+
 	while (1) {
 		if (g_dnl_detach())
 			break;
@@ -10,6 +10,7 @@
 #include <part.h>
 #include <aboot.h>
 #include <sparse_format.h>
+#include <mmc.h>
  
 #ifndef CONFIG_FASTBOOT_GPT_NAME
 #define CONFIG_FASTBOOT_GPT_NAME GPT_ENTRY_NAME
  
@@ -22,13 +23,13 @@
  
 void fastboot_fail(const char *s)
 {
-	strncpy(response_str, "FAIL", 4);
+	strncpy(response_str, "FAIL\0", 5);
 	strncat(response_str, s, RESPONSE_LEN - 4 - 1);
 }
  
 void fastboot_okay(const char *s)
 {
-	strncpy(response_str, "OKAY", 4);
+	strncpy(response_str, "OKAY\0", 5);
 	strncat(response_str, s, RESPONSE_LEN - 4 - 1);
 }
  
@@ -109,5 +110,60 @@
 	else
 		write_raw_image(dev_desc, &info, cmd, download_buffer,
 				download_bytes);
+}
+
+void fb_mmc_erase(const char *cmd, char *response)
+{
+	int ret;
+	block_dev_desc_t *dev_desc;
+	disk_partition_t info;
+	lbaint_t blks, blks_start, blks_size, grp_size;
+	struct mmc *mmc = find_mmc_device(CONFIG_FASTBOOT_FLASH_MMC_DEV);
+
+	if (mmc == NULL) {
+		error("invalid mmc device");
+		fastboot_fail("invalid mmc device");
+		return;
+	}
+
+	/* initialize the response buffer */
+	response_str = response;
+
+	dev_desc = get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
+	if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
+		error("invalid mmc device");
+		fastboot_fail("invalid mmc device");
+		return;
+	}
+
+	ret = get_partition_info_efi_by_name(dev_desc, cmd, &info);
+	if (ret) {
+		error("cannot find partition: '%s'", cmd);
+		fastboot_fail("cannot find partition");
+		return;
+	}
+
+	/* Align blocks to erase group size to avoid erasing other partitions */
+	grp_size = mmc->erase_grp_size;
+	blks_start = (info.start + grp_size - 1) & ~(grp_size - 1);
+	if (info.size >= grp_size)
+		blks_size = (info.size - (blks_start - info.start)) &
+				(~(grp_size - 1));
+	else
+		blks_size = 0;
+
+	printf("Erasing blocks " LBAFU " to " LBAFU " due to alignment\n",
+	       blks_start, blks_start + blks_size);
+
+	blks = dev_desc->block_erase(dev_desc->dev, blks_start, blks_size);
+	if (blks != blks_size) {
+		error("failed erasing from device %d", dev_desc->dev);
+		fastboot_fail("failed erasing from device");
+		return;
+	}
+
+	printf("........ erased " LBAFU " bytes from '%s'\n",
+	       blks_size * info.blksz, cmd);
+	fastboot_okay("");
 }
@@ -6,9 +6,8 @@
 The protocol that is used over USB is described in
 README.android-fastboot-protocol in same directory.
  
-The current implementation does not yet support the erase command or the
-"oem format" command, and there is minimal support for the flash command;
-it only supports eMMC devices.
+The current implementation is a minimal support of the erase command,the
+"oem format" command and flash command;it only supports eMMC devices.
  
 Client installation
 ===================
@@ -55,6 +55,9 @@
 	char *env_bkp;
 	int ret;
  
+#ifdef CONFIG_SET_DFU_ALT_INFO
+	set_dfu_alt_info(interface, devstr);
+#endif
 	str_env = getenv("dfu_alt_info");
 	if (!str_env) {
 		error("\"dfu_alt_info\" env variable not defined!\n");
@@ -55,6 +55,7 @@
 static struct f_fastboot *fastboot_func;
 static unsigned int download_size;
 static unsigned int download_bytes;
+static bool is_high_speed;
  
 static struct usb_endpoint_descriptor fs_ep_in = {
 	.bLength            = USB_DT_ENDPOINT_SIZE,
@@ -136,6 +137,7 @@
 	int id;
 	struct usb_gadget *gadget = c->cdev->gadget;
 	struct f_fastboot *f_fb = func_to_fastboot(f);
+	const char *s;
  
 	/* DYNAMIC interface numbers assignments */
 	id = usb_interface_id(c, f);
@@ -161,6 +163,10 @@
  
 	hs_ep_out.bEndpointAddress = fs_ep_out.bEndpointAddress;
  
+	s = getenv("serial#");
+	if (s)
+		g_dnl_set_serialnumber((char *)s);
+
 	return 0;
 }
  
  
  
@@ -219,10 +225,13 @@
 	      __func__, f->name, interface, alt);
  
 	/* make sure we don't enable the ep twice */
-	if (gadget->speed == USB_SPEED_HIGH)
+	if (gadget->speed == USB_SPEED_HIGH) {
 		ret = usb_ep_enable(f_fb->out_ep, &hs_ep_out);
-	else
+		is_high_speed = true;
+	} else {
 		ret = usb_ep_enable(f_fb->out_ep, &fs_ep_out);
+		is_high_speed = false;
+	}
 	if (ret) {
 		puts("failed to enable out ep\n");
 		return ret;
  
  
@@ -370,13 +379,20 @@
 	fastboot_tx_write_str(response);
 }
  
-static unsigned int rx_bytes_expected(void)
+static unsigned int rx_bytes_expected(unsigned int maxpacket)
 {
 	int rx_remain = download_size - download_bytes;
+	int rem = 0;
 	if (rx_remain < 0)
 		return 0;
 	if (rx_remain > EP_BUFFER_SIZE)
 		return EP_BUFFER_SIZE;
+	if (rx_remain < maxpacket) {
+		rx_remain = maxpacket;
+	} else if (rx_remain % maxpacket != 0) {
+		rem = rx_remain % maxpacket;
+		rx_remain = rx_remain + (maxpacket - rem);
+	}
 	return rx_remain;
 }
  
@@ -388,6 +404,7 @@
 	const unsigned char *buffer = req->buf;
 	unsigned int buffer_size = req->actual;
 	unsigned int pre_dot_num, now_dot_num;
+	unsigned int max;
  
 	if (req->status != 0) {
 		printf("Bad status: %d\n", req->status);
@@ -425,7 +442,9 @@
  
 		printf("\ndownloading of %d bytes finished\n", download_bytes);
 	} else {
-		req->length = rx_bytes_expected();
+		max = is_high_speed ? hs_ep_out.wMaxPacketSize :
+				fs_ep_out.wMaxPacketSize;
+		req->length = rx_bytes_expected(max);
 		if (req->length < ep->maxpacket)
 			req->length = ep->maxpacket;
 	}
@@ -438,6 +457,7 @@
 {
 	char *cmd = req->buf;
 	char response[RESPONSE_LEN];
+	unsigned int max;
  
 	strsep(&cmd, ":");
 	download_size = simple_strtoul(cmd, NULL, 16);
@@ -453,7 +473,9 @@
 	} else {
 		sprintf(response, "DATA%08x", download_size);
 		req->complete = rx_handler_dl_image;
-		req->length = rx_bytes_expected();
+		max = is_high_speed ? hs_ep_out.wMaxPacketSize :
+			fs_ep_out.wMaxPacketSize;
+		req->length = rx_bytes_expected(max);
 		if (req->length < ep->maxpacket)
 			req->length = ep->maxpacket;
 	}
@@ -513,6 +535,50 @@
 }
 #endif
  
+static void cb_oem(struct usb_ep *ep, struct usb_request *req)
+{
+	char *cmd = req->buf;
+#ifdef CONFIG_FASTBOOT_FLASH
+	if (strncmp("format", cmd + 4, 6) == 0) {
+		char cmdbuf[32];
+                sprintf(cmdbuf, "gpt write mmc %x $partitions",
+			CONFIG_FASTBOOT_FLASH_MMC_DEV);
+                if (run_command(cmdbuf, 0))
+			fastboot_tx_write_str("FAIL");
+                else
+			fastboot_tx_write_str("OKAY");
+	} else
+#endif
+	if (strncmp("unlock", cmd + 4, 8) == 0) {
+		fastboot_tx_write_str("FAILnot implemented");
+	}
+	else {
+		fastboot_tx_write_str("FAILunknown oem command");
+	}
+}
+
+#ifdef CONFIG_FASTBOOT_FLASH
+static void cb_erase(struct usb_ep *ep, struct usb_request *req)
+{
+	char *cmd = req->buf;
+	char response[RESPONSE_LEN];
+
+	strsep(&cmd, ":");
+	if (!cmd) {
+		error("missing partition name");
+		fastboot_tx_write_str("FAILmissing partition name");
+		return;
+	}
+
+	strcpy(response, "FAILno flash device defined");
+
+#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
+	fb_mmc_erase(cmd, response);
+#endif
+	fastboot_tx_write_str(response);
+}
+#endif
+
 struct cmd_dispatch_info {
 	char *cmd;
 	void (*cb)(struct usb_ep *ep, struct usb_request *req);
  
@@ -539,8 +605,15 @@
 	{
 		.cmd = "flash",
 		.cb = cb_flash,
+	}, {
+		.cmd = "erase",
+		.cb = cb_erase,
 	},
 #endif
+	{
+		.cmd = "oem",
+		.cb = cb_oem,
+	},
 };
  
 static void rx_handler_command(struct usb_ep *ep, struct usb_request *req)
@@ -182,7 +182,7 @@
 	set_usbdrd_phy_ctrl(POWER_USB_DRD_PHY_CTRL_DISABLE);
 }
  
-void dwc3_set_mode(struct dwc3 *dwc3_reg, u32 mode)
+static void dwc3_set_mode(struct dwc3 *dwc3_reg, u32 mode)
 {
 	clrsetbits_le32(&dwc3_reg->g_ctl,
 			DWC3_GCTL_PRTCAPDIR(DWC3_GCTL_PRTCAP_OTG),
@@ -321,6 +321,7 @@
 {
 	u32 l;
 	int status = 0;
+	unsigned long int start;
 #ifndef __UBOOT__
 	struct device *dev = musb->controller;
 	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
@@ -331,6 +332,21 @@
 		(struct omap_musb_board_data *)musb->controller;
 #endif
  
+	/* Reset the controller */
+	musb_writel(musb->mregs, OTG_SYSCONFIG, SOFTRST);
+
+	start = get_timer(0);
+
+	while (1) {
+		l = musb_readl(musb->mregs, OTG_SYSCONFIG);
+		if ((l & SOFTRST) == 0)
+			break;
+
+		if (get_timer(start) > (CONFIG_SYS_HZ / 1000)) {
+			dev_err(musb->controller, "MUSB reset is taking too long\n");
+			return -ENODEV;
+		}
+	}
  
 #ifndef __UBOOT__
 	/* We require some kind of external transceiver, hooked
@@ -140,6 +140,9 @@
 	unsigned int inited:1;
 };
  
+#ifdef CONFIG_SET_DFU_ALT_INFO
+void set_dfu_alt_info(char *interface, char *devstr);
+#endif
 int dfu_config_entities(char *s, char *interface, char *devstr);
 void dfu_free_entities(void);
 void dfu_show_entities(void);
@@ -6,4 +6,5 @@
  
 void fb_mmc_flash_write(const char *cmd, void *download_buffer,
 			unsigned int download_bytes, char *response);
+void fb_mmc_erase(const char *cmd, char *response);
@@ -29,9 +29,8 @@
 #endif
  
 #ifdef CONFIG_SET_DFU_ALT_INFO
-char *get_dfu_alt_system(void);
-char *get_dfu_alt_boot(void);
-void set_dfu_alt_info(void);
+char *get_dfu_alt_system(char *interface, char *devstr);
+char *get_dfu_alt_boot(char *interface, char *devstr);
 #endif
 #ifdef CONFIG_BOARD_TYPES
 void set_board_type(void);
...	...	@@ -338,9 +338,6 @@
338	338	#ifdef CONFIG_MISC_INIT_R
339	339	int misc_init_r(void)
340	340	{
341		-#ifdef CONFIG_SET_DFU_ALT_INFO
342		- set_dfu_alt_info();
343		-#endif
344	341	#ifdef CONFIG_ENV_VARS_UBOOT_RUNTIME_CONFIG
345	342	set_board_info();
346	343	#endif
...	...	@@ -22,7 +22,7 @@
22	22	DECLARE_GLOBAL_DATA_PTR;
23	23
24	24	#ifdef CONFIG_SET_DFU_ALT_INFO
25		-void set_dfu_alt_info(void)
	25	+void set_dfu_alt_info(char interface, char devstr)
26	26	{
27	27	size_t buf_size = CONFIG_SET_DFU_ALT_BUF_LEN;
28	28	ALLOC_CACHE_ALIGN_BUFFER(char, buf, buf_size);
29	29
...	...	@@ -34,13 +34,13 @@
34	34
35	35	puts("DFU alt info setting: ");
36	36
37		- alt_setting = get_dfu_alt_boot();
	37	+ alt_setting = get_dfu_alt_boot(interface, devstr);
38	38	if (alt_setting) {
39	39	setenv("dfu_alt_boot", alt_setting);
40	40	offset = snprintf(buf, buf_size, "%s", alt_setting);
41	41	}
42	42
43		- alt_setting = get_dfu_alt_system();
	43	+ alt_setting = get_dfu_alt_system(interface, devstr);
44	44	if (alt_setting) {
45	45	if (offset)
46	46	alt_sep = ";";
...	...	@@ -15,6 +15,7 @@
15	15	#include <power/pmic.h>
16	16	#include <power/max77686_pmic.h>
17	17	#include <errno.h>
	18	+#include <mmc.h>
18	19	#include <usb.h>
19	20	#include <usb/s3c_udc.h>
20	21	#include <samsung/misc.h>
21	22
22	23
23	24
24	25
...	...	@@ -61,27 +62,29 @@
61	62	#endif
62	63
63	64	#ifdef CONFIG_SET_DFU_ALT_INFO
64		-char *get_dfu_alt_system(void)
	65	+char get_dfu_alt_system(char interface, char *devstr)
65	66	{
66	67	return getenv("dfu_alt_system");
67	68	}
68	69
69		-char *get_dfu_alt_boot(void)
	70	+char get_dfu_alt_boot(char interface, char *devstr)
70	71	{
	72	+ struct mmc *mmc;
71	73	char *alt_boot;
	74	+ int dev_num;
72	75
73		- switch (get_boot_mode()) {
74		- case BOOT_MODE_SD:
75		- alt_boot = CONFIG_DFU_ALT_BOOT_SD;
76		- break;
77		- case BOOT_MODE_EMMC:
78		- case BOOT_MODE_EMMC_SD:
79		- alt_boot = CONFIG_DFU_ALT_BOOT_EMMC;
80		- break;
81		- default:
82		- alt_boot = NULL;
83		- break;
84		- }
	76	+ dev_num = simple_strtoul(devstr, NULL, 10);
	77	+
	78	+ mmc = find_mmc_device(dev_num);
	79	+ if (!mmc)
	80	+ return NULL;
	81	+
	82	+ if (mmc_init(mmc))
	83	+ return NULL;
	84	+
	85	+ alt_boot = IS_SD(mmc) ? CONFIG_DFU_ALT_BOOT_SD :
	86	+ CONFIG_DFU_ALT_BOOT_EMMC;
	87	+
85	88	return alt_boot;
86	89	}
87	90	#endif
...	...	@@ -20,6 +20,12 @@
20	20	if (ret)
21	21	return ret;
22	22
	23	+ if (!g_dnl_board_usb_cable_connected()) {
	24	+ puts("\rUSB cable not detected.\n" \
	25	+ "Command exit.\n");
	26	+ return CMD_RET_FAILURE;
	27	+ }
	28	+
23	29	while (1) {
24	30	if (g_dnl_detach())
25	31	break;
...	...	@@ -10,6 +10,7 @@
10	10	#include <part.h>
11	11	#include <aboot.h>
12	12	#include <sparse_format.h>
	13	+#include <mmc.h>
13	14
14	15	#ifndef CONFIG_FASTBOOT_GPT_NAME
15	16	#define CONFIG_FASTBOOT_GPT_NAME GPT_ENTRY_NAME
16	17
...	...	@@ -22,13 +23,13 @@
22	23
23	24	void fastboot_fail(const char *s)
24	25	{
25		- strncpy(response_str, "FAIL", 4);
	26	+ strncpy(response_str, "FAIL\0", 5);
26	27	strncat(response_str, s, RESPONSE_LEN - 4 - 1);
27	28	}
28	29
29	30	void fastboot_okay(const char *s)
30	31	{
31		- strncpy(response_str, "OKAY", 4);
	32	+ strncpy(response_str, "OKAY\0", 5);
32	33	strncat(response_str, s, RESPONSE_LEN - 4 - 1);
33	34	}
34	35
...	...	@@ -109,5 +110,60 @@
109	110	else
110	111	write_raw_image(dev_desc, &info, cmd, download_buffer,
111	112	download_bytes);
	113	+}
	114	+
	115	+void fb_mmc_erase(const char cmd, char response)
	116	+{
	117	+ int ret;
	118	+ block_dev_desc_t *dev_desc;
	119	+ disk_partition_t info;
	120	+ lbaint_t blks, blks_start, blks_size, grp_size;
	121	+ struct mmc *mmc = find_mmc_device(CONFIG_FASTBOOT_FLASH_MMC_DEV);
	122	+
	123	+ if (mmc == NULL) {
	124	+ error("invalid mmc device");
	125	+ fastboot_fail("invalid mmc device");
	126	+ return;
	127	+ }
	128	+
	129	+ /* initialize the response buffer */
	130	+ response_str = response;
	131	+
	132	+ dev_desc = get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
	133	+ if (!dev_desc \|\| dev_desc->type == DEV_TYPE_UNKNOWN) {
	134	+ error("invalid mmc device");
	135	+ fastboot_fail("invalid mmc device");
	136	+ return;
	137	+ }
	138	+
	139	+ ret = get_partition_info_efi_by_name(dev_desc, cmd, &info);
	140	+ if (ret) {
	141	+ error("cannot find partition: '%s'", cmd);
	142	+ fastboot_fail("cannot find partition");
	143	+ return;
	144	+ }
	145	+
	146	+ /* Align blocks to erase group size to avoid erasing other partitions */
	147	+ grp_size = mmc->erase_grp_size;
	148	+ blks_start = (info.start + grp_size - 1) & ~(grp_size - 1);
	149	+ if (info.size >= grp_size)
	150	+ blks_size = (info.size - (blks_start - info.start)) &
	151	+ (~(grp_size - 1));
	152	+ else
	153	+ blks_size = 0;
	154	+
	155	+ printf("Erasing blocks " LBAFU " to " LBAFU " due to alignment\n",
	156	+ blks_start, blks_start + blks_size);
	157	+
	158	+ blks = dev_desc->block_erase(dev_desc->dev, blks_start, blks_size);
	159	+ if (blks != blks_size) {
	160	+ error("failed erasing from device %d", dev_desc->dev);
	161	+ fastboot_fail("failed erasing from device");
	162	+ return;
	163	+ }
	164	+
	165	+ printf("........ erased " LBAFU " bytes from '%s'\n",
	166	+ blks_size * info.blksz, cmd);
	167	+ fastboot_okay("");
112	168	}
...	...	@@ -6,9 +6,8 @@
6	6	The protocol that is used over USB is described in
7	7	README.android-fastboot-protocol in same directory.
8	8
9		-The current implementation does not yet support the erase command or the
10		-"oem format" command, and there is minimal support for the flash command;
11		-it only supports eMMC devices.
	9	+The current implementation is a minimal support of the erase command,the
	10	+"oem format" command and flash command;it only supports eMMC devices.
12	11
13	12	Client installation
14	13	===================
...	...	@@ -55,6 +55,9 @@
55	55	char *env_bkp;
56	56	int ret;
57	57
	58	+#ifdef CONFIG_SET_DFU_ALT_INFO
	59	+ set_dfu_alt_info(interface, devstr);
	60	+#endif
58	61	str_env = getenv("dfu_alt_info");
59	62	if (!str_env) {
60	63	error("\"dfu_alt_info\" env variable not defined!\n");
...	...	@@ -55,6 +55,7 @@
55	55	static struct f_fastboot *fastboot_func;
56	56	static unsigned int download_size;
57	57	static unsigned int download_bytes;
	58	+static bool is_high_speed;
58	59
59	60	static struct usb_endpoint_descriptor fs_ep_in = {
60	61	.bLength = USB_DT_ENDPOINT_SIZE,
...	...	@@ -136,6 +137,7 @@
136	137	int id;
137	138	struct usb_gadget *gadget = c->cdev->gadget;
138	139	struct f_fastboot *f_fb = func_to_fastboot(f);
	140	+ const char *s;
139	141
140	142	/* DYNAMIC interface numbers assignments */
141	143	id = usb_interface_id(c, f);
...	...	@@ -161,6 +163,10 @@
161	163
162	164	hs_ep_out.bEndpointAddress = fs_ep_out.bEndpointAddress;
163	165
	166	+ s = getenv("serial#");
	167	+ if (s)
	168	+ g_dnl_set_serialnumber((char *)s);
	169	+
164	170	return 0;
165	171	}
166	172
167	173
168	174
...	...	@@ -219,10 +225,13 @@
219	225	__func__, f->name, interface, alt);
220	226
221	227	/* make sure we don't enable the ep twice */
222		- if (gadget->speed == USB_SPEED_HIGH)
	228	+ if (gadget->speed == USB_SPEED_HIGH) {
223	229	ret = usb_ep_enable(f_fb->out_ep, &hs_ep_out);
224		- else
	230	+ is_high_speed = true;
	231	+ } else {
225	232	ret = usb_ep_enable(f_fb->out_ep, &fs_ep_out);
	233	+ is_high_speed = false;
	234	+ }
226	235	if (ret) {
227	236	puts("failed to enable out ep\n");
228	237	return ret;
229	238
230	239
...	...	@@ -370,13 +379,20 @@
370	379	fastboot_tx_write_str(response);
371	380	}
372	381
373		-static unsigned int rx_bytes_expected(void)
	382	+static unsigned int rx_bytes_expected(unsigned int maxpacket)
374	383	{
375	384	int rx_remain = download_size - download_bytes;
	385	+ int rem = 0;
376	386	if (rx_remain < 0)
377	387	return 0;
378	388	if (rx_remain > EP_BUFFER_SIZE)
379	389	return EP_BUFFER_SIZE;
	390	+ if (rx_remain < maxpacket) {
	391	+ rx_remain = maxpacket;
	392	+ } else if (rx_remain % maxpacket != 0) {
	393	+ rem = rx_remain % maxpacket;
	394	+ rx_remain = rx_remain + (maxpacket - rem);
	395	+ }
380	396	return rx_remain;
381	397	}
382	398
...	...	@@ -388,6 +404,7 @@
388	404	const unsigned char *buffer = req->buf;
389	405	unsigned int buffer_size = req->actual;
390	406	unsigned int pre_dot_num, now_dot_num;
	407	+ unsigned int max;
391	408
392	409	if (req->status != 0) {
393	410	printf("Bad status: %d\n", req->status);
...	...	@@ -425,7 +442,9 @@
425	442
426	443	printf("\ndownloading of %d bytes finished\n", download_bytes);
427	444	} else {
428		- req->length = rx_bytes_expected();
	445	+ max = is_high_speed ? hs_ep_out.wMaxPacketSize :
	446	+ fs_ep_out.wMaxPacketSize;
	447	+ req->length = rx_bytes_expected(max);
429	448	if (req->length < ep->maxpacket)
430	449	req->length = ep->maxpacket;
431	450	}
...	...	@@ -438,6 +457,7 @@
438	457	{
439	458	char *cmd = req->buf;
440	459	char response[RESPONSE_LEN];
	460	+ unsigned int max;
441	461
442	462	strsep(&cmd, ":");
443	463	download_size = simple_strtoul(cmd, NULL, 16);
...	...	@@ -453,7 +473,9 @@
453	473	} else {
454	474	sprintf(response, "DATA%08x", download_size);
455	475	req->complete = rx_handler_dl_image;
456		- req->length = rx_bytes_expected();
	476	+ max = is_high_speed ? hs_ep_out.wMaxPacketSize :
	477	+ fs_ep_out.wMaxPacketSize;
	478	+ req->length = rx_bytes_expected(max);
457	479	if (req->length < ep->maxpacket)
458	480	req->length = ep->maxpacket;
459	481	}
...	...	@@ -513,6 +535,50 @@
513	535	}
514	536	#endif
515	537
	538	+static void cb_oem(struct usb_ep ep, struct usb_request req)
	539	+{
	540	+ char *cmd = req->buf;
	541	+#ifdef CONFIG_FASTBOOT_FLASH
	542	+ if (strncmp("format", cmd + 4, 6) == 0) {
	543	+ char cmdbuf[32];
	544	+ sprintf(cmdbuf, "gpt write mmc %x $partitions",
	545	+ CONFIG_FASTBOOT_FLASH_MMC_DEV);
	546	+ if (run_command(cmdbuf, 0))
	547	+ fastboot_tx_write_str("FAIL");
	548	+ else
	549	+ fastboot_tx_write_str("OKAY");
	550	+ } else
	551	+#endif
	552	+ if (strncmp("unlock", cmd + 4, 8) == 0) {
	553	+ fastboot_tx_write_str("FAILnot implemented");
	554	+ }
	555	+ else {
	556	+ fastboot_tx_write_str("FAILunknown oem command");
	557	+ }
	558	+}
	559	+
	560	+#ifdef CONFIG_FASTBOOT_FLASH
	561	+static void cb_erase(struct usb_ep ep, struct usb_request req)
	562	+{
	563	+ char *cmd = req->buf;
	564	+ char response[RESPONSE_LEN];
	565	+
	566	+ strsep(&cmd, ":");
	567	+ if (!cmd) {
	568	+ error("missing partition name");
	569	+ fastboot_tx_write_str("FAILmissing partition name");
	570	+ return;
	571	+ }
	572	+
	573	+ strcpy(response, "FAILno flash device defined");
	574	+
	575	+#ifdef CONFIG_FASTBOOT_FLASH_MMC_DEV
	576	+ fb_mmc_erase(cmd, response);
	577	+#endif
	578	+ fastboot_tx_write_str(response);
	579	+}
	580	+#endif
	581	+
516	582	struct cmd_dispatch_info {
517	583	char *cmd;
518	584	void (cb)(struct usb_ep ep, struct usb_request *req);
519	585
...	...	@@ -539,8 +605,15 @@
539	605	{
540	606	.cmd = "flash",
541	607	.cb = cb_flash,
	608	+ }, {
	609	+ .cmd = "erase",
	610	+ .cb = cb_erase,
542	611	},
543	612	#endif
	613	+ {
	614	+ .cmd = "oem",
	615	+ .cb = cb_oem,
	616	+ },
544	617	};
545	618
546	619	static void rx_handler_command(struct usb_ep ep, struct usb_request req)
...	...	@@ -182,7 +182,7 @@
182	182	set_usbdrd_phy_ctrl(POWER_USB_DRD_PHY_CTRL_DISABLE);
183	183	}
184	184
185		-void dwc3_set_mode(struct dwc3 *dwc3_reg, u32 mode)
	185	+static void dwc3_set_mode(struct dwc3 *dwc3_reg, u32 mode)
186	186	{
187	187	clrsetbits_le32(&dwc3_reg->g_ctl,
188	188	DWC3_GCTL_PRTCAPDIR(DWC3_GCTL_PRTCAP_OTG),
...	...	@@ -321,6 +321,7 @@
321	321	{
322	322	u32 l;
323	323	int status = 0;
	324	+ unsigned long int start;
324	325	#ifndef __UBOOT__
325	326	struct device *dev = musb->controller;
326	327	struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
...	...	@@ -331,6 +332,21 @@
331	332	(struct omap_musb_board_data *)musb->controller;
332	333	#endif
333	334
	335	+ /* Reset the controller */
	336	+ musb_writel(musb->mregs, OTG_SYSCONFIG, SOFTRST);
	337	+
	338	+ start = get_timer(0);
	339	+
	340	+ while (1) {
	341	+ l = musb_readl(musb->mregs, OTG_SYSCONFIG);
	342	+ if ((l & SOFTRST) == 0)
	343	+ break;
	344	+
	345	+ if (get_timer(start) > (CONFIG_SYS_HZ / 1000)) {
	346	+ dev_err(musb->controller, "MUSB reset is taking too long\n");
	347	+ return -ENODEV;
	348	+ }
	349	+ }
334	350
335	351	#ifndef __UBOOT__
336	352	/* We require some kind of external transceiver, hooked