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

Tom Rini
2 parents 52fded7b94 af41d6b4cb
Showing 40 changed files Side-by-side Diff
README
arch/arm/include/asm/arch-rmobile/ehci-rmobile.h
board/samsung/common/ums.c
board/samsung/origen/origen.c
board/samsung/trats/trats.c
board/samsung/trats2/trats2.c
board/samsung/universal_c210/universal.c
common/cmd_dfu.c
common/cmd_thordown.c
common/cmd_usb_mass_storage.c
common/usb_kbd.c
drivers/dfu/dfu.c
drivers/dfu/dfu_mmc.c
drivers/usb/gadget/Makefile
drivers/usb/gadget/ci_udc.c
drivers/usb/gadget/ci_udc.h
drivers/usb/gadget/f_dfu.c
drivers/usb/gadget/f_mass_storage.c
drivers/usb/gadget/f_thor.c
drivers/usb/gadget/g_dnl.c
@@ -1484,13 +1484,6 @@
 			for your device
 			- CONFIG_USBD_PRODUCTID 0xFFFF
  
-		Some USB device drivers may need to check USB cable attachment.
-		In this case you can enable following config in BoardName.h:
-			CONFIG_USB_CABLE_CHECK
-			This enables function definition:
-			- usb_cable_connected() in include/usb.h
-			Implementation of this function is board-specific.
-
 - ULPI Layer Support:
 		The ULPI (UTMI Low Pin (count) Interface) PHYs are supported via
 		the generic ULPI layer. The generic layer accesses the ULPI PHY
+/*
+ *  Copyright (C) 2013,2014 Renesas Electronics Corporation
+ *  Copyright (C) 2014 Nobuhiro Iwamatsu <nobuhiro.iwamatsu.yj@renesas.com>
+ *
+ *  SPDX-License-Identifier:     GPL-2.0
+ */
+
+#ifndef __EHCI_RMOBILE_H__
+#define __EHCI_RMOBILE_H__
+
+/* Register offset */
+#define OHCI_OFFSET	0x00
+#define OHCI_SIZE	0x1000
+#define EHCI_OFFSET	0x1000
+#define EHCI_SIZE	0x1000
+
+#define EHCI_USBCMD	(EHCI_OFFSET + 0x0020)
+
+/* USBCTR */
+#define DIRPD		(1 << 8)
+#define PLL_RST		(1 << 2)
+#define PCICLK_MASK	(1 << 1)
+#define USBH_RST	(1 << 0)
+
+/* CMND_STS */
+#define SERREN		(1 << 8)
+#define PERREN		(1 << 6)
+#define MASTEREN	(1 << 2)
+#define MEMEN		(1 << 1)
+
+/* PCIAHB_WIN1_CTR and PCIAHB_WIN2_CTR */
+#define PCIAHB_WIN_PREFETCH	((1 << 1)|(1 << 0))
+
+/* AHBPCI_WIN1_CTR */
+#define PCIWIN1_PCICMD		((1 << 3)|(1 << 1))
+#define AHB_CFG_AHBPCI		0x40000000
+#define AHB_CFG_HOST		0x80000000
+
+/* AHBPCI_WIN2_CTR */
+#define PCIWIN2_PCICMD		((1 << 2)|(1 << 1))
+
+/* PCI_INT_ENABLE */
+#define USBH_PMEEN		(1 << 19)
+#define USBH_INTBEN		(1 << 17)
+#define USBH_INTAEN		(1 << 16)
+
+/* AHB_BUS_CTR */
+#define SMODE_READY_CTR		(1 << 17)
+#define SMODE_READ_BURST	(1 << 16)
+#define MMODE_HBUSREQ		(1 << 7)
+#define MMODE_BOUNDARY		((1 << 6)|(1 << 5))
+#define MMODE_BURST_WIDTH	((1 << 4)|(1 << 3))
+#define MMODE_SINGLE_MODE	((1 << 4)|(1 << 3))
+#define MMODE_WR_INCR		(1 << 2)
+#define MMODE_BYTE_BURST	(1 << 1)
+#define MMODE_HTRANS		(1 << 0)
+
+/* PCI_ARBITER_CTR */
+#define PCIBUS_PARK_TIMER       0x00FF0000
+#define PCIBUS_PARK_TIMER_SET   0x00070000
+#define PCIBP_MODE		(1 << 12)
+#define PCIREQ7                 (1 << 7)
+#define PCIREQ6                 (1 << 6)
+#define PCIREQ5                 (1 << 5)
+#define PCIREQ4                 (1 << 4)
+#define PCIREQ3                 (1 << 3)
+#define PCIREQ2                 (1 << 2)
+#define PCIREQ1                 (1 << 1)
+#define PCIREQ0                 (1 << 0)
+
+#define SMSTPCR7        0xE615014C
+#define SMSTPCR703      (1 << 3)
+
+/* Init AHB master and slave functions of the host logic */
+#define AHB_BUS_CTR_INIT \
+	(SMODE_READY_CTR | MMODE_HBUSREQ | MMODE_WR_INCR | \
+	 MMODE_BYTE_BURST | MMODE_HTRANS)
+
+#define USBCTR_WIN_SIZE_1GB	0x800
+
+/* PCI Configuration Registers */
+#define PCI_CONF_OHCI_OFFSET	0x10000
+#define PCI_CONF_EHCI_OFFSET	0x10100
+struct ahb_pciconf {
+	u32 vid_did;
+	u32 cmnd_sts;
+	u32 rev;
+	u32 cache_line;
+	u32 basead;
+};
+
+/* PCI Configuration Registers for AHB-PCI Bridge Registers */
+#define PCI_CONF_AHBPCI_OFFSET	0x10000
+struct ahbconf_pci_bridge {
+	u32 vid_did;		/* 0x00 */
+	u32 cmnd_sts;
+	u32 revid_cc;
+	u32 cls_lt_ht_bist;
+	u32 basead;		/* 0x10 */
+	u32 win1_basead;
+	u32 win2_basead;
+	u32 dummy0[5];
+	u32 ssvdi_ssid;		/* 0x2C */
+	u32 dummy1[4];
+	u32 intr_line_pin;
+};
+
+/* AHB-PCI Bridge PCI Communication Registers */
+#define AHBPCI_OFFSET	0x10800
+struct ahbcom_pci_bridge {
+	u32 pciahb_win1_ctr;	/* 0x00 */
+	u32 pciahb_win2_ctr;
+	u32 pciahb_dct_ctr;
+	u32 dummy0;
+	u32 ahbpci_win1_ctr;	/* 0x10 */
+	u32 ahbpci_win2_ctr;
+	u32 dummy1;
+	u32 ahbpci_dct_ctr;
+	u32 pci_int_enable;	/* 0x20 */
+	u32 pci_int_status;
+	u32 dummy2[2];
+	u32 ahb_bus_ctr;	/* 0x30 */
+	u32 usbctr;
+	u32 dummy3[2];
+	u32 pci_arbiter_ctr;	/* 0x40 */
+	u32 dummy4;
+	u32 pci_unit_rev;	/* 0x48 */
+};
+
+struct rmobile_ehci_reg {
+	u32 hciversion;		/* hciversion/caplength */
+	u32 hcsparams;		/* hcsparams */
+	u32 hccparams;		/* hccparams */
+	u32 hcsp_portroute;	/* hcsp_portroute */
+	u32 usbcmd;		/* usbcmd */
+	u32 usbsts;		/* usbsts */
+	u32 usbintr;		/* usbintr */
+	u32 frindex;		/* frindex */
+	u32 ctrldssegment;	/* ctrldssegment */
+	u32 periodiclistbase;	/* periodiclistbase */
+	u32 asynclistaddr;	/* asynclistaddr */
+	u32 dummy[9];
+	u32 configflag;		/* configflag */
+	u32 portsc;		/* portsc */
+};
+
+#endif /* __EHCI_RMOBILE_H__ */
@@ -66,12 +66,10 @@
  
 struct ums *ums_init(unsigned int dev_num)
 {
-	struct mmc *mmc = NULL;
+	struct mmc *mmc = find_mmc_device(dev_num);
  
-	mmc = find_mmc_device(dev_num);
-	if (!mmc)
+	if (!mmc || mmc_init(mmc))
 		return NULL;
-
 	return ums_disk_init(mmc);
 }
@@ -30,13 +30,6 @@
 	return 0;
 }
  
-#ifdef CONFIG_USB_CABLE_CHECK
-int usb_cable_connected(void)
-{
-	return 0;
-}
-#endif
-
 #ifdef CONFIG_BOARD_EARLY_INIT_F
 int exynos_early_init_f(void)
 {
@@ -430,8 +430,7 @@
 	return s3c_udc_probe(&s5pc210_otg_data);
 }
  
-#ifdef CONFIG_USB_CABLE_CHECK
-int usb_cable_connected(void)
+int g_dnl_board_usb_cable_connected(void)
 {
 	struct pmic *muic = pmic_get("MAX8997_MUIC");
 	if (!muic)
@@ -439,7 +438,6 @@
  
 	return !!muic->chrg->chrg_type(muic);
 }
-#endif
 #endif
  
 static void pmic_reset(void)
@@ -312,8 +312,7 @@
 	return s3c_udc_probe(&s5pc210_otg_data);
 }
  
-#ifdef CONFIG_USB_CABLE_CHECK
-int usb_cable_connected(void)
+int g_dnl_board_usb_cable_connected(void)
 {
 	struct pmic *muic = pmic_get("MAX77693_MUIC");
 	if (!muic)
@@ -321,7 +320,6 @@
  
 	return !!muic->chrg->chrg_type(muic);
 }
-#endif
 #endif
  
 static int pmic_init_max77686(void)
@@ -197,13 +197,6 @@
 	return s3c_udc_probe(&s5pc210_otg_data);
 }
  
-#ifdef CONFIG_USB_CABLE_CHECK
-int usb_cable_connected(void)
-{
-	return 0;
-}
-#endif
-
 int exynos_early_init_f(void)
 {
 	wdt_stop();
@@ -22,7 +22,6 @@
 	char *interface = argv[2];
 	char *devstring = argv[3];
  
-	char *s = "dfu";
 	int ret, i = 0;
  
 	ret = dfu_init_env_entities(interface, simple_strtoul(devstring,
@@ -38,7 +37,7 @@
 	int controller_index = simple_strtoul(usb_controller, NULL, 0);
 	board_usb_init(controller_index, USB_INIT_DEVICE);
  
-	g_dnl_register(s);
+	g_dnl_register("usb_dnl_dfu");
 	while (1) {
 		if (dfu_reset())
 			/*
@@ -22,7 +22,6 @@
 	char *interface = argv[2];
 	char *devstring = argv[3];
  
-	const char *s = "thor";
 	int ret;
  
 	puts("TIZEN \"THOR\" Downloader\n");
@@ -40,7 +39,7 @@
 		goto exit;
 	}
  
-	g_dnl_register(s);
+	g_dnl_register("usb_dnl_thor");
  
 	ret = thor_init();
 	if (ret) {
@@ -40,15 +40,19 @@
 		return CMD_RET_FAILURE;
 	}
  
-	g_dnl_register("ums");
+	g_dnl_register("usb_dnl_ums");
  
 	/* Timeout unit: seconds */
 	int cable_ready_timeout = UMS_CABLE_READY_TIMEOUT;
  
-	if (!usb_cable_connected()) {
+	if (!g_dnl_board_usb_cable_connected()) {
+		/*
+		 * Won't execute if we don't know whether the cable is
+		 * connected.
+		 */
 		puts("Please connect USB cable.\n");
  
-		while (!usb_cable_connected()) {
+		while (!g_dnl_board_usb_cable_connected()) {
 			if (ctrlc()) {
 				puts("\rCTRL+C - Operation aborted.\n");
 				goto exit;
@@ -91,6 +91,12 @@
 #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;
  
@@ -99,7 +105,7 @@
 	uint8_t		usb_kbd_buffer[USB_KBD_BUFFER_LEN];
  
 	uint8_t		*new;
-	uint8_t		old[8];
+	uint8_t		old[USB_KBD_BOOT_REPORT_SIZE];
  
 	uint8_t		flags;
 };
@@ -131,7 +137,8 @@
 	/* Submit a interrupt transfer request */
 	maxp = usb_maxpacket(usb_kbd_dev, pipe);
 	usb_submit_int_msg(usb_kbd_dev, pipe, data->new,
-			maxp > 8 ? 8 : maxp, ep->bInterval);
+		min(maxp, USB_KBD_BOOT_REPORT_SIZE),
+		ep->bInterval);
 }
  
 /* Puts character in the queue and sets up the in and out pointer. */
  
@@ -266,8 +273,11 @@
 		old = data->old;
 	}
  
-	if ((old[i] > 3) && (memscan(new + 2, old[i], 6) == new + 8))
+	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;
 }
@@ -285,7 +295,7 @@
 	else if ((data->new[0] == LEFT_CNTR) || (data->new[0] == RIGHT_CNTR))
 		data->flags |= USB_KBD_CTRL;
  
-	for (i = 2; i < 8; i++) {
+	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);
 	}
@@ -297,7 +307,7 @@
 	if (res == 1)
 		usb_kbd_setled(dev);
  
-	memcpy(data->old, data->new, 8);
+	memcpy(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE);
  
 	return 1;
 }
@@ -305,7 +315,8 @@
 /* Keyboard interrupt handler */
 static int usb_kbd_irq(struct usb_device *dev)
 {
-	if ((dev->irq_status != 0) || (dev->irq_act_len != 8)) {
+	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;
@@ -333,7 +344,8 @@
 	/* Submit a interrupt transfer request */
 	maxp = usb_maxpacket(dev, pipe);
 	usb_submit_int_msg(dev, pipe, &data->new[0],
-			maxp > 8 ? 8 : maxp, ep->bInterval);
+		min(maxp, USB_KBD_BOOT_REPORT_SIZE),
+		ep->bInterval);
  
 	usb_kbd_irq_worker(dev);
 #elif	defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
@@ -341,8 +353,8 @@
 	struct usb_kbd_pdata *data = dev->privptr;
 	iface = &dev->config.if_desc[0];
 	usb_get_report(dev, iface->desc.bInterfaceNumber,
-			1, 0, data->new, sizeof(data->new));
-	if (memcmp(data->old, data->new, sizeof(data->new)))
+		       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
 }
@@ -441,7 +453,8 @@
 	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(8, USB_DMA_MINALIGN));
+	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;
@@ -459,7 +472,8 @@
 	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, maxp > 8 ? 8 : maxp,
+	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);
@@ -219,7 +219,7 @@
 			ret = tret;
 	}
  
-	return ret = 0 ? size : ret;
+	return ret;
 }
  
 static int dfu_read_buffer_fill(struct dfu_entity *dfu, void *buf, int size)
@@ -184,66 +184,95 @@
 	return ret;
 }
  
+/*
+ * @param s Parameter string containing space-separated arguments:
+ *	1st:
+ *		raw	(raw read/write)
+ *		fat	(files)
+ *		ext4	(^)
+ *		part	(partition image)
+ *	2nd and 3rd:
+ *		lba_start and lba_size, for raw write
+ *		mmc_dev and mmc_part, for filesystems and part
+ */
 int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *s)
 {
-	int dev, part;
+	const char *entity_type;
+	size_t second_arg;
+	size_t third_arg;
+
 	struct mmc *mmc;
-	block_dev_desc_t *blk_dev;
-	disk_partition_t partinfo;
-	char *st;
  
-	dfu->dev_type = DFU_DEV_MMC;
-	st = strsep(&s, " ");
-	if (!strcmp(st, "mmc")) {
-		dfu->layout = DFU_RAW_ADDR;
-		dfu->data.mmc.lba_start = simple_strtoul(s, &s, 16);
-		dfu->data.mmc.lba_size = simple_strtoul(++s, &s, 16);
-		dfu->data.mmc.lba_blk_size = get_mmc_blk_size(dfu->dev_num);
-	} else if (!strcmp(st, "fat")) {
-		dfu->layout = DFU_FS_FAT;
-	} else if (!strcmp(st, "ext4")) {
-		dfu->layout = DFU_FS_EXT4;
-	} else if (!strcmp(st, "part")) {
+	const char *argv[3];
+	const char **parg = argv;
  
-		dfu->layout = DFU_RAW_ADDR;
-
-		dev = simple_strtoul(s, &s, 10);
-		s++;
-		part = simple_strtoul(s, &s, 10);
-
-		mmc = find_mmc_device(dev);
-		if (mmc == NULL || mmc_init(mmc)) {
-			printf("%s: could not find mmc device #%d!\n",
-			       __func__, dev);
+	for (; parg < argv + sizeof(argv) / sizeof(*argv); ++parg) {
+		*parg = strsep(&s, " ");
+		if (*parg == NULL) {
+			error("Invalid number of arguments.\n");
 			return -ENODEV;
 		}
+	}
  
-		blk_dev = &mmc->block_dev;
-		if (get_partition_info(blk_dev, part, &partinfo) != 0) {
-			printf("%s: could not find partition #%d on mmc device #%d!\n",
-			       __func__, part, dev);
+	entity_type = argv[0];
+	/*
+	 * Base 0 means we'll accept (prefixed with 0x or 0) base 16, 8,
+	 * with default 10.
+	 */
+	second_arg = simple_strtoul(argv[1], NULL, 0);
+	third_arg = simple_strtoul(argv[2], NULL, 0);
+
+	mmc = find_mmc_device(dfu->dev_num);
+	if (mmc == NULL) {
+		error("Couldn't find MMC device no. %d.\n", dfu->dev_num);
+		return -ENODEV;
+	}
+
+	if (mmc_init(mmc)) {
+		error("Couldn't init MMC device.\n");
+		return -ENODEV;
+	}
+
+	if (!strcmp(entity_type, "raw")) {
+		dfu->layout			= DFU_RAW_ADDR;
+		dfu->data.mmc.lba_start		= second_arg;
+		dfu->data.mmc.lba_size		= third_arg;
+		dfu->data.mmc.lba_blk_size	= mmc->read_bl_len;
+	} else if (!strcmp(entity_type, "part")) {
+		disk_partition_t partinfo;
+		block_dev_desc_t *blk_dev = &mmc->block_dev;
+		int mmcdev = second_arg;
+		int mmcpart = third_arg;
+
+		if (get_partition_info(blk_dev, mmcpart, &partinfo) != 0) {
+			error("Couldn't find part #%d on mmc device #%d\n",
+			      mmcpart, mmcdev);
 			return -ENODEV;
 		}
  
-		dfu->data.mmc.lba_start = partinfo.start;
-		dfu->data.mmc.lba_size = partinfo.size;
-		dfu->data.mmc.lba_blk_size = partinfo.blksz;
-
+		dfu->layout			= DFU_RAW_ADDR;
+		dfu->data.mmc.lba_start		= partinfo.start;
+		dfu->data.mmc.lba_size		= partinfo.size;
+		dfu->data.mmc.lba_blk_size	= partinfo.blksz;
+	} else if (!strcmp(entity_type, "fat")) {
+		dfu->layout = DFU_FS_FAT;
+	} else if (!strcmp(entity_type, "ext4")) {
+		dfu->layout = DFU_FS_EXT4;
 	} else {
-		printf("%s: Memory layout (%s) not supported!\n", __func__, st);
+		error("Memory layout (%s) not supported!\n", entity_type);
 		return -ENODEV;
 	}
  
-	if (dfu->layout == DFU_FS_EXT4 || dfu->layout == DFU_FS_FAT) {
-		dfu->data.mmc.dev = simple_strtoul(s, &s, 10);
-		dfu->data.mmc.part = simple_strtoul(++s, &s, 10);
+	/* if it's NOT a raw write */
+	if (strcmp(entity_type, "raw")) {
+		dfu->data.mmc.dev = second_arg;
+		dfu->data.mmc.part = third_arg;
 	}
  
+	dfu->dev_type = DFU_DEV_MMC;
 	dfu->read_medium = dfu_read_medium_mmc;
 	dfu->write_medium = dfu_write_medium_mmc;
 	dfu->flush_medium = dfu_flush_medium_mmc;
-
-	/* initial state */
 	dfu->inited = 0;
  
 	return 0;
@@ -13,6 +13,7 @@
 obj-$(CONFIG_USB_GADGET_ATMEL_USBA) += atmel_usba_udc.o
 obj-$(CONFIG_USB_GADGET_S3C_UDC_OTG) += s3c_udc_otg.o
 obj-$(CONFIG_USB_GADGET_FOTG210) += fotg210.o
+obj-$(CONFIG_CI_UDC)	+= ci_udc.o
 obj-$(CONFIG_THOR_FUNCTION) += f_thor.o
 obj-$(CONFIG_USBDOWNLOAD_GADGET) += g_dnl.o
 obj-$(CONFIG_DFU_FUNCTION) += f_dfu.o
@@ -321,7 +321,7 @@
 	if (addr == ba)
 		return;		/* not a bounce */
  
-	memcpy(ep->req.buf, ep->b_buf, ep->req.length);
+	memcpy(ep->req.buf, ep->b_buf, ep->req.actual);
 free:
 	/* Large payloads use allocated buffer, free it. */
 	if (ep->b_buf != ep->b_fast)
@@ -350,6 +350,9 @@
 	item->info = INFO_BYTES(len) | INFO_IOC | INFO_ACTIVE;
 	item->page0 = (uint32_t)ci_ep->b_buf;
 	item->page1 = ((uint32_t)ci_ep->b_buf & 0xfffff000) + 0x1000;
+	item->page2 = ((uint32_t)ci_ep->b_buf & 0xfffff000) + 0x2000;
+	item->page3 = ((uint32_t)ci_ep->b_buf & 0xfffff000) + 0x3000;
+	item->page4 = ((uint32_t)ci_ep->b_buf & 0xfffff000) + 0x4000;
 	ci_flush_qtd(num);
  
 	head->next = (unsigned) item;
@@ -385,7 +388,7 @@
 		       num, in ? "in" : "out", item->info, item->page0);
  
 	len = (item->info >> 16) & 0x7fff;
-	ep->req.length -= len;
+	ep->req.actual = ep->req.length - len;
 	ci_debounce(ep, in);
  
 	DBG("ept%d %s complete %x\n",
  
@@ -413,7 +416,11 @@
  
 	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\n", reqname(r.bRequest),
 	    r.bRequestType, r.bRequest, r.wIndex, r.wValue);
  
@@ -480,6 +487,9 @@
 	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);
  
  
@@ -521,7 +531,11 @@
 		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;
  
@@ -538,7 +552,11 @@
 		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();
  
@@ -699,7 +717,6 @@
  
 int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 {
-	struct ci_udc *udc;
 	int ret;
  
 	if (!driver)
  
  
@@ -714,12 +731,18 @@
 		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) {
-		udc = (struct ci_udc *)controller.ctrl->hcor;
+		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) {
@@ -8,45 +8,74 @@
  
 #define NUM_ENDPOINTS		6
  
+#ifdef CONFIG_CI_UDC_HAS_HOSTPC
 struct ci_udc {
-#define MICRO_8FRAME	0x8
-#define USBCMD_ITC(x)	((((x) > 0xff) ? 0xff : x) << 16)
-#define USBCMD_FS2	(1 << 15)
-#define USBCMD_RST	(1 << 1)
-#define USBCMD_RUN	(1)
+	u32 usbcmd;		/* 0x130 */
+	u32 usbsts;		/* 0x134 */
+	u32 pad1[3];
+	u32 devaddr;		/* 0x144 */
+	u32 epinitaddr;		/* 0x148 */
+	u32 pad2[10];
+	u32 portsc;		/* 0x174 */
+	u32 pad178[(0x1b4 - (0x174 + 4)) / 4];
+	u32 hostpc1_devlc;	/* 0x1b4 */
+	u32 pad1b8[(0x1f8 - (0x1b4 + 4)) / 4];
+	u32 usbmode;		/* 0x1f8 */
+	u32 pad1fc[(0x208 - (0x1f8 + 4)) / 4];
+	u32 epsetupstat;	/* 0x208 */
+	u32 epprime;		/* 0x20c */
+	u32 epflush;		/* 0x210 */
+	u32 epstat;		/* 0x214 */
+	u32 epcomp;		/* 0x218 */
+	u32 epctrl[16];		/* 0x21c */
+};
+#else
+struct ci_udc {
 	u32 usbcmd;		/* 0x140 */
-#define STS_SLI		(1 << 8)
-#define STS_URI		(1 << 6)
-#define STS_PCI		(1 << 2)
-#define STS_UEI		(1 << 1)
-#define STS_UI		(1 << 0)
 	u32 usbsts;		/* 0x144 */
 	u32 pad1[3];
 	u32 devaddr;		/* 0x154 */
 	u32 epinitaddr;		/* 0x158 */
 	u32 pad2[10];
-#define PTS_ENABLE	2
-#define PTS(x)		(((x) & 0x3) << 30)
-#define PFSC		(1 << 24)
 	u32 portsc;		/* 0x184 */
 	u32 pad3[8];
-#define USBMODE_DEVICE	2
 	u32 usbmode;		/* 0x1a8 */
 	u32 epstat;		/* 0x1ac */
-#define EPT_TX(x)	(1 << (((x) & 0xffff) + 16))
-#define EPT_RX(x)	(1 << ((x) & 0xffff))
 	u32 epprime;		/* 0x1b0 */
 	u32 epflush;		/* 0x1b4 */
 	u32 pad4;
 	u32 epcomp;		/* 0x1bc */
+	u32 epctrl[16];		/* 0x1c0 */
+};
+
+#define PTS_ENABLE	2
+#define PTS(x)		(((x) & 0x3) << 30)
+#define PFSC		(1 << 24)
+#endif
+
+#define MICRO_8FRAME	0x8
+#define USBCMD_ITC(x)	((((x) > 0xff) ? 0xff : x) << 16)
+#define USBCMD_FS2	(1 << 15)
+#define USBCMD_RST	(1 << 1)
+#define USBCMD_RUN	(1)
+
+#define STS_SLI		(1 << 8)
+#define STS_URI		(1 << 6)
+#define STS_PCI		(1 << 2)
+#define STS_UEI		(1 << 1)
+#define STS_UI		(1 << 0)
+
+#define USBMODE_DEVICE	2
+
+#define EPT_TX(x)	(1 << (((x) & 0xffff) + 16))
+#define EPT_RX(x)	(1 << ((x) & 0xffff))
+
 #define CTRL_TXE	(1 << 23)
 #define CTRL_TXR	(1 << 22)
 #define CTRL_RXE	(1 << 7)
 #define CTRL_RXR	(1 << 6)
 #define CTRL_TXT_BULK	(2 << 18)
 #define CTRL_RXT_BULK	(2 << 2)
-	u32 epctrl[16];		/* 0x1c0 */
-};
  
 struct ci_ep {
 	struct usb_ep ep;
@@ -24,6 +24,7 @@
 #include <linux/usb/composite.h>
  
 #include <dfu.h>
+#include <g_dnl.h>
 #include "f_dfu.h"
  
 struct f_dfu {
@@ -817,4 +818,6 @@
  
 	return dfu_bind_config(c);
 }
+
+DECLARE_GADGET_BIND_CALLBACK(usb_dnl_dfu, dfu_add);
@@ -243,7 +243,7 @@
 #include <config.h>
 #include <malloc.h>
 #include <common.h>
-#include <usb.h>
+#include <g_dnl.h>
  
 #include <linux/err.h>
 #include <linux/usb/ch9.h>
@@ -255,6 +255,7 @@
 #include <linux/usb/gadget.h>
 #include <linux/usb/composite.h>
 #include <usb/lin_gadget_compat.h>
+#include <g_dnl.h>
  
 /*------------------------------------------------------------------------*/
  
  
  
@@ -680,11 +681,11 @@
 			/* Handle CTRL+C */
 			if (ctrlc())
 				return -EPIPE;
-#ifdef CONFIG_USB_CABLE_CHECK
+
 			/* Check cable connection */
-			if (!usb_cable_connected())
+			if (!g_dnl_board_usb_cable_connected())
 				return -EIO;
-#endif
+
 			k = 0;
 		}
  
@@ -2778,4 +2779,6 @@
  
 	return 0;
 }
+
+DECLARE_GADGET_BIND_CALLBACK(usb_dnl_ums, fsg_add);
@@ -204,14 +204,14 @@
  
 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();
 	int ret;
  
 	debug("%s: left: %llu cnt: %d\n", __func__, left, cnt);
  
 	if (left) {
-		ret = dfu_write(dfu_get_entity(alt_setting_num),
-				transfer_buffer, left, cnt++);
+		ret = dfu_write(dfu_entity, transfer_buffer, left, cnt++);
 		if (ret) {
 			error("DFU write failed [%d]: left: %llu", ret, left);
 			return ret;
  
@@ -225,11 +225,16 @@
 	 * This also frees memory malloc'ed by dfu_get_buf(), so no explicit
 	 * need fo call dfu_free_buf() is needed.
 	 */
-	ret = dfu_write(dfu_get_entity(alt_setting_num),
-			transfer_buffer, 0, cnt);
+	ret = dfu_write(dfu_entity, transfer_buffer, 0, cnt);
 	if (ret)
 		error("DFU write failed [%d] cnt: %d", ret, cnt);
  
+	ret = dfu_flush(dfu_entity, transfer_buffer, 0, cnt);
+	if (ret) {
+		error("DFU flush failed!");
+		return ret;
+	}
+
 	return ret;
 }
  
@@ -999,4 +1004,6 @@
 	debug("%s:\n", __func__);
 	return thor_func_init(c);
 }
+
+DECLARE_GADGET_BIND_CALLBACK(usb_dnl_thor, thor_add);
@@ -41,7 +41,6 @@
  
 #define DRIVER_VERSION		"usb_dnl 2.0"
  
-static const char shortname[] = "usb_dnl_";
 static const char product[] = "USB download gadget";
 static char g_dnl_serial[MAX_STRING_SERIAL];
 static const char manufacturer[] = CONFIG_G_DNL_MANUFACTURER;
  
  
  
@@ -96,29 +95,36 @@
 	free(cdev->config);
 	cdev->config = NULL;
 	debug("%s: calling usb_gadget_disconnect for "
-			"controller '%s'\n", shortname, gadget->name);
+			"controller '%s'\n", __func__, gadget->name);
 	usb_gadget_disconnect(gadget);
  
 	return 0;
 }
  
+static inline struct g_dnl_bind_callback *g_dnl_bind_callback_first(void)
+{
+	return ll_entry_start(struct g_dnl_bind_callback,
+				g_dnl_bind_callbacks);
+}
+
+static inline struct g_dnl_bind_callback *g_dnl_bind_callback_end(void)
+{
+	return ll_entry_end(struct g_dnl_bind_callback,
+				g_dnl_bind_callbacks);
+}
+
 static int g_dnl_do_config(struct usb_configuration *c)
 {
 	const char *s = c->cdev->driver->name;
-	int ret = -1;
+	struct g_dnl_bind_callback *callback = g_dnl_bind_callback_first();
  
 	debug("%s: configuration: 0x%p composite dev: 0x%p\n",
 	      __func__, c, c->cdev);
  
-	printf("GADGET DRIVER: %s\n", s);
-	if (!strcmp(s, "usb_dnl_dfu"))
-		ret = dfu_add(c);
-	else if (!strcmp(s, "usb_dnl_ums"))
-		ret = fsg_add(c);
-	else if (!strcmp(s, "usb_dnl_thor"))
-		ret = thor_add(c);
-
-	return ret;
+	for (; callback != g_dnl_bind_callback_end(); callback++)
+		if (!strcmp(s, callback->usb_function_name))
+			return callback->fptr(c);
+	return -ENODEV;
 }
  
 static int g_dnl_config_register(struct usb_composite_dev *cdev)
@@ -152,6 +158,11 @@
 	return gcnum;
 }
  
+__weak int g_dnl_board_usb_cable_connected(void)
+{
+	return -EOPNOTSUPP;
+}
+
 static int g_dnl_get_bcd_device_number(struct usb_composite_dev *cdev)
 {
 	struct usb_gadget *gadget = cdev->gadget;
  
@@ -203,12 +214,12 @@
 		device_desc.bcdDevice = cpu_to_le16(gcnum);
 	else {
 		debug("%s: controller '%s' not recognized\n",
-			shortname, gadget->name);
+			__func__, gadget->name);
 		device_desc.bcdDevice = __constant_cpu_to_le16(0x9999);
 	}
  
 	debug("%s: calling usb_gadget_connect for "
-			"controller '%s'\n", shortname, gadget->name);
+			"controller '%s'\n", __func__, gadget->name);
 	usb_gadget_connect(gadget);
  
 	return 0;
  
  
  
  
  
@@ -227,36 +238,23 @@
 	.unbind = g_dnl_unbind,
 };
  
-int g_dnl_register(const char *type)
+/*
+ * NOTICE:
+ * Registering via USB function name won't be necessary after rewriting
+ * g_dnl to support multiple USB functions.
+ */
+int g_dnl_register(const char *name)
 {
-	/* The largest function name is 4 */
-	static char name[sizeof(shortname) + 4];
 	int ret;
  
-	if (!strcmp(type, "dfu")) {
-		strcpy(name, shortname);
-		strcat(name, type);
-	} else if (!strcmp(type, "ums")) {
-		strcpy(name, shortname);
-		strcat(name, type);
-	} else if (!strcmp(type, "thor")) {
-		strcpy(name, shortname);
-		strcat(name, type);
-	} else {
-		printf("%s: unknown command: %s\n", __func__, type);
-		return -EINVAL;
-	}
-
+	debug("%s: g_dnl_driver.name = %s\n", __func__, name);
 	g_dnl_driver.name = name;
  
-	debug("%s: g_dnl_driver.name: %s\n", __func__, g_dnl_driver.name);
 	ret = usb_composite_register(&g_dnl_driver);
-
 	if (ret) {
 		printf("%s: failed!, error: %d\n", __func__, ret);
 		return ret;
 	}
-
 	return 0;
 }
  
@@ -311,7 +311,11 @@
 #define DELAYED_STATUS	(EP0_BUFSIZE + 999)	/* An impossibly large value */
  
 /* Number of buffers we will use.  2 is enough for double-buffering */
+#ifndef CONFIG_CI_UDC
 #define FSG_NUM_BUFFERS	2
+#else
+#define FSG_NUM_BUFFERS	1 /* ci_udc only allows 1 req per ep at present */
+#endif
  
 /* Default size of buffer length. */
 #define FSG_BUFLEN	((u32)16384)
@@ -108,6 +108,9 @@
 	struct usb_string	*s;
 	int			len;
  
+	if (!table)
+		return -EINVAL;
+
 	/* descriptor 0 has the language id */
 	if (id == 0) {
 		buf[0] = 4;
@@ -36,6 +36,7 @@
 obj-$(CONFIG_USB_EHCI_SPEAR) += ehci-spear.o
 obj-$(CONFIG_USB_EHCI_TEGRA) += ehci-tegra.o
 obj-$(CONFIG_USB_EHCI_VCT) += ehci-vct.o
+obj-$(CONFIG_USB_EHCI_RMOBILE) += ehci-rmobile.o
  
 # xhci
 obj-$(CONFIG_USB_XHCI) += xhci.o xhci-mem.o xhci-ring.o
@@ -197,7 +197,8 @@
  
 #ifdef CONFIG_OF_CONTROL
 	/* setup the Vbus gpio here */
-	if (!fdtdec_setup_gpio(&ctx->vbus_gpio))
+	if (fdt_gpio_isvalid(&ctx->vbus_gpio) &&
+	    !fdtdec_setup_gpio(&ctx->vbus_gpio))
 		gpio_direction_output(ctx->vbus_gpio.gpio, 1);
 #endif
  
@@ -998,8 +998,8 @@
 	if (!ehcic[index].periodic_list)
 		return -ENOMEM;
 	for (i = 0; i < 1024; i++) {
-		ehcic[index].periodic_list[i] = (uint32_t)periodic
-						| QH_LINK_TYPE_QH;
+		ehcic[index].periodic_list[i] = cpu_to_hc32((uint32_t)periodic
+						| QH_LINK_TYPE_QH);
 	}
  
 	flush_dcache_range((uint32_t)ehcic[index].periodic_list,
@@ -1089,7 +1089,7 @@
 	struct qTD *tds;
 };
  
-#define NEXT_QH(qh) (struct QH *)((qh)->qh_link & ~0x1f)
+#define NEXT_QH(qh) (struct QH *)(hc32_to_cpu((qh)->qh_link) & ~0x1f)
  
 static int
 enable_periodic(struct ehci_ctrl *ctrl)
  
  
  
  
  
  
  
  
@@ -1184,41 +1184,47 @@
 		struct qTD *td = result->tds + i;
 		void **buf = &qh->buffer;
  
-		qh->qh_link = (uint32_t)(qh+1) | QH_LINK_TYPE_QH;
+		qh->qh_link = cpu_to_hc32((uint32_t)(qh+1) | QH_LINK_TYPE_QH);
 		if (i == queuesize - 1)
-			qh->qh_link = QH_LINK_TERMINATE;
+			qh->qh_link = cpu_to_hc32(QH_LINK_TERMINATE);
  
-		qh->qh_overlay.qt_next = (uint32_t)td;
-		qh->qh_overlay.qt_altnext = QT_NEXT_TERMINATE;
-		qh->qh_endpt1 = (0 << 28) | /* No NAK reload (ehci 4.9) */
+		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 = (1 << 30) | /* 1 Tx per mframe */
-			(1 << 0); /* S-mask: microframe 0 */
+			(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",
 				dev->portnr, dev->parent->devnum);
-			qh->qh_endpt2 |= (dev->portnr << 23) |
+			qh->qh_endpt2 |= cpu_to_hc32((dev->portnr << 23) |
 				(dev->parent->devnum << 16) |
-				(0x1c << 8); /* C-mask: microframes 2-4 */
+				(0x1c << 8)); /* C-mask: microframes 2-4 */
 		}
  
-		td->qt_next = QT_NEXT_TERMINATE;
-		td->qt_altnext = QT_NEXT_TERMINATE;
+		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 = (elementsize << 16) |
+		td->qt_token = cpu_to_hc32((elementsize << 16) |
 			((usb_pipein(pipe) ? 1 : 0) << 8) | /* IN/OUT token */
-			0x80; /* active */
-		td->qt_buffer[0] = (uint32_t)buffer + i * elementsize;
-		td->qt_buffer[1] = (td->qt_buffer[0] + 0x1000) & ~0xfff;
-		td->qt_buffer[2] = (td->qt_buffer[0] + 0x2000) & ~0xfff;
-		td->qt_buffer[3] = (td->qt_buffer[0] + 0x3000) & ~0xfff;
-		td->qt_buffer[4] = (td->qt_buffer[0] + 0x4000) & ~0xfff;
+			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;
 	}
@@ -1241,7 +1247,7 @@
 	/* hook up to periodic list */
 	struct QH *list = &ctrl->periodic_queue;
 	result->last->qh_link = list->qh_link;
-	list->qh_link = (uint32_t)result->first | QH_LINK_TYPE_QH;
+	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));
@@ -1280,7 +1286,7 @@
 	/* still active */
 	invalidate_dcache_range((uint32_t)cur,
 				ALIGN_END_ADDR(struct QH, cur, 1));
-	if (cur->qh_overlay.qt_token & 0x80) {
+	if (cur->qh_overlay.qt_token & cpu_to_hc32(0x80)) {
 		debug("Exit poll_int_queue with no completed intr transfer. "
 		      "token is %x\n", cur->qh_overlay.qt_token);
 		return NULL;
@@ -1311,7 +1317,7 @@
  
 	struct QH *cur = &ctrl->periodic_queue;
 	timeout = get_timer(0) + 500; /* abort after 500ms */
-	while (!(cur->qh_link & QH_LINK_TERMINATE)) {
+	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");
+/*
+ *  EHCI HCD (Host Controller Driver) for USB.
+ *
+ *  Copyright (C) 2013,2014 Renesas Electronics Corporation
+ *  Copyright (C) 2014 Nobuhiro Iwamatsu <nobuhiro.iwamatsu.yj@renesas.com>
+ *
+ *  SPDX-License-Identifier:     GPL-2.0
+ */
+
+#include <common.h>
+#include <asm/io.h>
+#include <asm/arch/ehci-rmobile.h>
+#include "ehci.h"
+
+#if defined(CONFIG_R8A7740)
+static u32 usb_base_address[CONFIG_USB_MAX_CONTROLLER_COUNT] = {
+	0xC6700000
+};
+#elif defined(CONFIG_R8A7790)
+static u32 usb_base_address[CONFIG_USB_MAX_CONTROLLER_COUNT] = {
+	0xEE080000,	/* USB0 (EHCI) */
+	0xEE0A0000,	/* USB1 */
+	0xEE0C0000,	/* USB2 */
+	0xEE000000	/* USB3 (USB3.0 Host)*/
+};
+#elif defined(CONFIG_R8A7791)
+static u32 usb_base_address[CONFIG_USB_MAX_CONTROLLER_COUNT] = {
+	0xEE080000,	/* USB0 (EHCI) */
+	0xEE0C0000,	/* USB1 */
+	0xEE000000	/* USB3 (USB3.0 Host)*/
+};
+#else
+#error rmobile EHCI USB driver not supported on this platform
+#endif
+
+int ehci_hcd_stop(int index)
+{
+	int i;
+	u32 base;
+	struct ahbcom_pci_bridge *ahbcom_pci;
+
+	base = usb_base_address[index];
+	ahbcom_pci = (struct ahbcom_pci_bridge *)(base + AHBPCI_OFFSET);
+	writel(0, &ahbcom_pci->ahb_bus_ctr);
+
+	/* reset ehci */
+	setbits_le32(base + EHCI_USBCMD, CMD_RESET);
+	for (i = 100; i > 0; i--) {
+		if (!(readl(base + EHCI_USBCMD) & CMD_RESET))
+			break;
+		udelay(100);
+	}
+
+	if (!i)
+		printf("error : ehci(%d) reset failed.\n", index);
+
+	if (index == (CONFIG_USB_MAX_CONTROLLER_COUNT - 1))
+		setbits_le32(SMSTPCR7, SMSTPCR703);
+
+	return 0;
+}
+
+int ehci_hcd_init(int index, enum usb_init_type init,
+	struct ehci_hccr **hccr, struct ehci_hcor **hcor)
+{
+	u32 base;
+	u32 phys_base;
+	struct rmobile_ehci_reg *rehci;
+	struct ahbcom_pci_bridge *ahbcom_pci;
+	struct ahbconf_pci_bridge *ahbconf_pci;
+	struct ahb_pciconf *ahb_pciconf_ohci;
+	struct ahb_pciconf *ahb_pciconf_ehci;
+	uint32_t cap_base;
+
+	base = usb_base_address[index];
+	phys_base = base;
+	if (index == 0)
+		clrbits_le32(SMSTPCR7, SMSTPCR703);
+
+	rehci = (struct rmobile_ehci_reg *)(base + EHCI_OFFSET);
+	ahbcom_pci = (struct ahbcom_pci_bridge *)(base + AHBPCI_OFFSET);
+	ahbconf_pci =
+		(struct ahbconf_pci_bridge *)(base + PCI_CONF_AHBPCI_OFFSET);
+	ahb_pciconf_ohci = (struct ahb_pciconf *)(base + PCI_CONF_OHCI_OFFSET);
+	ahb_pciconf_ehci = (struct ahb_pciconf *)(base + PCI_CONF_EHCI_OFFSET);
+
+	/* Clock & Reset & Direct Power Down */
+	clrsetbits_le32(&ahbcom_pci->usbctr,
+			(DIRPD | PCICLK_MASK | USBH_RST), USBCTR_WIN_SIZE_1GB);
+	clrbits_le32(&ahbcom_pci->usbctr, PLL_RST);
+
+	/* AHB-PCI Bridge Communication Registers */
+	writel(AHB_BUS_CTR_INIT, &ahbcom_pci->ahb_bus_ctr);
+	writel((CONFIG_SYS_SDRAM_BASE & 0xf0000000) | PCIAHB_WIN_PREFETCH,
+	       &ahbcom_pci->pciahb_win1_ctr);
+	writel(0xf0000000 | PCIAHB_WIN_PREFETCH,
+	       &ahbcom_pci->pciahb_win2_ctr);
+	writel(phys_base | PCIWIN2_PCICMD, &ahbcom_pci->ahbpci_win2_ctr);
+
+	setbits_le32(&ahbcom_pci->pci_arbiter_ctr,
+		     PCIBP_MODE | PCIREQ1 | PCIREQ0);
+
+	/* PCI Configuration Registers for AHBPCI */
+	writel(PCIWIN1_PCICMD | AHB_CFG_AHBPCI,
+	       &ahbcom_pci->ahbpci_win1_ctr);
+	writel(phys_base + AHBPCI_OFFSET, &ahbconf_pci->basead);
+	writel(CONFIG_SYS_SDRAM_BASE & 0xf0000000, &ahbconf_pci->win1_basead);
+	writel(0xf0000000, &ahbconf_pci->win2_basead);
+	writel(SERREN | PERREN | MASTEREN | MEMEN,
+	       &ahbconf_pci->cmnd_sts);
+
+	/* PCI Configuration Registers for EHCI */
+	writel(PCIWIN1_PCICMD | AHB_CFG_HOST, &ahbcom_pci->ahbpci_win1_ctr);
+	writel(phys_base + OHCI_OFFSET, &ahb_pciconf_ohci->basead);
+	writel(phys_base + EHCI_OFFSET, &ahb_pciconf_ehci->basead);
+	writel(SERREN | PERREN | MASTEREN | MEMEN,
+	       &ahb_pciconf_ohci->cmnd_sts);
+	writel(SERREN | PERREN | MASTEREN | MEMEN,
+	       &ahb_pciconf_ehci->cmnd_sts);
+
+	/* Enable PCI interrupt */
+	setbits_le32(&ahbcom_pci->pci_int_enable,
+		     USBH_PMEEN | USBH_INTBEN | USBH_INTAEN);
+
+	*hccr = (struct ehci_hccr *)((uint32_t)&rehci->hciversion);
+	cap_base = ehci_readl(&(*hccr)->cr_capbase);
+	*hcor = (struct ehci_hcor *)((uint32_t)*hccr + HC_LENGTH(cap_base));
+
+	return 0;
+}
@@ -298,7 +298,8 @@
  
 #ifdef CONFIG_OF_CONTROL
 	/* setup the Vbus gpio here */
-	if (!fdtdec_setup_gpio(&ctx->vbus_gpio))
+	if (fdt_gpio_isvalid(&ctx->vbus_gpio) &&
+	    !fdtdec_setup_gpio(&ctx->vbus_gpio))
 		gpio_direction_output(ctx->vbus_gpio.gpio, 1);
 #endif
  
@@ -204,7 +204,10 @@
  
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
-	/* TODO: implement me */
+	if (driver->disconnect)
+		driver->disconnect(&gadget->g);
+	if (driver->unbind)
+		driver->unbind(&gadget->g);
 	return 0;
 }
 #endif /* CONFIG_MUSB_GADGET */
@@ -312,6 +312,7 @@
 #endif
  
 /* USB Device Firmware Update support */
+#ifndef CONFIG_SPL_BUILD
 #define CONFIG_DFU_FUNCTION
 #define CONFIG_DFU_MMC
 #define CONFIG_CMD_DFU
@@ -320,10 +321,10 @@
 	"boot part 0 1;" \
 	"rootfs part 0 2;" \
 	"MLO fat 0 1;" \
-	"MLO.raw mmc 100 100;" \
-	"u-boot.img.raw mmc 300 400;" \
-	"spl-os-args.raw mmc 80 80;" \
-	"spl-os-image.raw mmc 900 2000;" \
+	"MLO.raw mmc 0x100 0x100;" \
+	"u-boot.img.raw mmc 0x300 0x400;" \
+	"spl-os-args.raw mmc 0x80 0x80;" \
+	"spl-os-image.raw mmc 0x900 0x2000;" \
 	"spl-os-args fat 0 1;" \
 	"spl-os-image fat 0 1;" \
 	"u-boot.img fat 0 1;" \
@@ -354,6 +355,7 @@
 	DFU_ALT_INFO_MMC \
 	DFU_ALT_INFO_RAM \
 	DFU_ALT_INFO_NAND
+#endif
  
 /*
  * Default to using SPI for environment, etc.
@@ -127,7 +127,6 @@
 #define CONFIG_USB_GADGET_S3C_UDC_OTG
 #define CONFIG_USB_GADGET_DUALSPEED
 #define CONFIG_USB_GADGET_VBUS_DRAW	2
-#define CONFIG_USB_CABLE_CHECK
  
 #define CONFIG_CMD_USB_MASS_STORAGE
 #define CONFIG_USB_GADGET_MASS_STORAGE
@@ -101,7 +101,7 @@
 	"name="PARTS_UMS",size=-,uuid=${uuid_gpt_"PARTS_UMS"}\0" \
  
 #define CONFIG_DFU_ALT \
-	"u-boot mmc 80 400;" \
+	"u-boot raw 0x80 0x400;" \
 	"uImage ext4 0 2;" \
 	"modem.bin ext4 0 2;" \
 	"exynos4210-trats.dtb ext4 0 2;" \
@@ -112,7 +112,7 @@
 	""PARTS_ROOT" part 0 5;" \
 	""PARTS_DATA" part 0 6;" \
 	""PARTS_UMS" part 0 7;" \
-	"params.bin mmc 0x38 0x8 0x38 0x8\0""
+	"params.bin raw 0x38 0x8 0x38 0x8\0""
  
 #define CONFIG_EXTRA_ENV_SETTINGS \
 	"bootk=" \
@@ -91,7 +91,7 @@
 	"name="PARTS_UMS",size=-,uuid=${uuid_gpt_"PARTS_UMS"}\0" \
  
 #define CONFIG_DFU_ALT \
-	"u-boot mmc 80 800;" \
+	"u-boot raw 0x80 0x800;" \
 	"uImage ext4 0 2;" \
 	"modem.bin ext4 0 2;" \
 	"exynos4412-trats2.dtb ext4 0 2;" \
@@ -102,7 +102,7 @@
 	""PARTS_ROOT" part 0 5;" \
 	""PARTS_DATA" part 0 6;" \
 	""PARTS_UMS" part 0 7;" \
-	"params.bin mmc 0x38 0x8 0x38 0x8\0""
+	"params.bin raw 0x38 0x8 0x38 0x8\0""
  
 #define CONFIG_EXTRA_ENV_SETTINGS \
 	"bootk=" \
@@ -64,11 +64,6 @@
 	unsigned int	size;
 };
  
-static inline unsigned int get_mmc_blk_size(int dev)
-{
-	return find_mmc_device(dev)->read_bl_len;
-}
-
 #define DFU_NAME_SIZE			32
 #define DFU_CMD_BUF_SIZE		128
 #ifndef CONFIG_SYS_DFU_DATA_BUF_SIZE
  
@@ -173,13 +168,6 @@
 }
 #endif
  
-#ifdef CONFIG_DFU_FUNCTION
 int dfu_add(struct usb_configuration *c);
-#else
-int dfu_add(struct usb_configuration *c)
-{
-	return 0;
-}
-#endif
 #endif /* __DFU_ENTITY_H_ */
@@ -10,7 +10,31 @@
  
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/composite.h>
+#include <linker_lists.h>
+
+/*
+ * @usb_fname: unescaped USB function name
+ * @callback_ptr: bind callback, one per function name
+ */
+#define DECLARE_GADGET_BIND_CALLBACK(usb_fname, callback_ptr) \
+	ll_entry_declare(struct g_dnl_bind_callback, \
+			__usb_function_name_##usb_fname, \
+			g_dnl_bind_callbacks) = { \
+				.usb_function_name = #usb_fname, \
+				.fptr = callback_ptr \
+			}
+
+typedef int (*g_dnl_bind_callback_f)(struct usb_configuration *);
+
+/* used in Gadget downloader callback linker list */
+struct g_dnl_bind_callback {
+	const char *usb_function_name;
+	g_dnl_bind_callback_f fptr;
+};
+
 int g_dnl_bind_fixup(struct usb_device_descriptor *, const char *);
+int g_dnl_board_usb_cable_connected(void);
 int g_dnl_register(const char *s);
 void g_dnl_unregister(void);
 void g_dnl_set_serialnumber(char *);
@@ -228,7 +228,7 @@
  * and it's name.
  *
  * Example:
- * ll_entry_declare(struct my_sub_cmd, my_sub_cmd, cmd_sub, cmd.sub) = {
+ * ll_entry_declare(struct my_sub_cmd, my_sub_cmd, cmd_sub) = {
  *         .x = 3,
  *         .y = 4,
  * };
@@ -12,6 +12,7 @@
  
 #include <linux/list.h>
 #include <linux/compiler.h>
+#include <part.h>
  
 #define SD_VERSION_SD	0x20000
 #define SD_VERSION_3	(SD_VERSION_SD | 0x300)
@@ -8,6 +8,7 @@
 #define _PART_H
  
 #include <ide.h>
+#include <common.h>
  
 typedef struct block_dev_desc {
 	int		if_type;	/* type of the interface */
@@ -15,14 +15,6 @@
  
 int thor_handle(void);
 int thor_init(void);
-
-#ifdef CONFIG_THOR_FUNCTION
 int thor_add(struct usb_configuration *c);
-#else
-int thor_add(struct usb_configuration *c)
-{
-	return 0;
-}
-#endif
 #endif /* __THOR_H_ */
@@ -197,16 +197,6 @@
  */
 int board_usb_cleanup(int index, enum usb_init_type init);
  
-/*
- * If CONFIG_USB_CABLE_CHECK is set then this function
- * should be defined in board file.
- *
- * @return 1 if cable is connected and 0 otherwise.
- */
-#ifdef CONFIG_USB_CABLE_CHECK
-int usb_cable_connected(void);
-#endif
-
 #ifdef CONFIG_USB_STORAGE
  
 #define USB_MAX_STOR_DEV 5
@@ -40,14 +40,6 @@
 void fsg_cleanup(void);
 struct ums *ums_init(unsigned int);
 int fsg_main_thread(void *);
-
-#ifdef CONFIG_USB_GADGET_MASS_STORAGE
 int fsg_add(struct usb_configuration *c);
-#else
-int fsg_add(struct usb_configuration *c)
-{
-	return 0;
-}
-#endif
 #endif /* __USB_MASS_STORAGE_H__ */
...	...	@@ -1484,13 +1484,6 @@
1484	1484	for your device
1485	1485	- CONFIG_USBD_PRODUCTID 0xFFFF
1486	1486
1487		- Some USB device drivers may need to check USB cable attachment.
1488		- In this case you can enable following config in BoardName.h:
1489		- CONFIG_USB_CABLE_CHECK
1490		- This enables function definition:
1491		- - usb_cable_connected() in include/usb.h
1492		- Implementation of this function is board-specific.
1493		-
1494	1487	- ULPI Layer Support:
1495	1488	The ULPI (UTMI Low Pin (count) Interface) PHYs are supported via
1496	1489	the generic ULPI layer. The generic layer accesses the ULPI PHY
	1	+/*
	2	+ * Copyright (C) 2013,2014 Renesas Electronics Corporation
	3	+ * Copyright (C) 2014 Nobuhiro Iwamatsu <nobuhiro.iwamatsu.yj@renesas.com>
	4	+ *
	5	+ * SPDX-License-Identifier: GPL-2.0
	6	+ */
	7	+
	8	+#ifndef __EHCI_RMOBILE_H__
	9	+#define __EHCI_RMOBILE_H__
	10	+
	11	+/* Register offset */
	12	+#define OHCI_OFFSET 0x00
	13	+#define OHCI_SIZE 0x1000
	14	+#define EHCI_OFFSET 0x1000
	15	+#define EHCI_SIZE 0x1000
	16	+
	17	+#define EHCI_USBCMD (EHCI_OFFSET + 0x0020)
	18	+
	19	+/* USBCTR */
	20	+#define DIRPD (1 << 8)
	21	+#define PLL_RST (1 << 2)
	22	+#define PCICLK_MASK (1 << 1)
	23	+#define USBH_RST (1 << 0)
	24	+
	25	+/* CMND_STS */
	26	+#define SERREN (1 << 8)
	27	+#define PERREN (1 << 6)
	28	+#define MASTEREN (1 << 2)
	29	+#define MEMEN (1 << 1)
	30	+
	31	+/* PCIAHB_WIN1_CTR and PCIAHB_WIN2_CTR */
	32	+#define PCIAHB_WIN_PREFETCH ((1 << 1)\|(1 << 0))
	33	+
	34	+/* AHBPCI_WIN1_CTR */
	35	+#define PCIWIN1_PCICMD ((1 << 3)\|(1 << 1))
	36	+#define AHB_CFG_AHBPCI 0x40000000
	37	+#define AHB_CFG_HOST 0x80000000
	38	+
	39	+/* AHBPCI_WIN2_CTR */
	40	+#define PCIWIN2_PCICMD ((1 << 2)\|(1 << 1))
	41	+
	42	+/* PCI_INT_ENABLE */
	43	+#define USBH_PMEEN (1 << 19)
	44	+#define USBH_INTBEN (1 << 17)
	45	+#define USBH_INTAEN (1 << 16)
	46	+
	47	+/* AHB_BUS_CTR */
	48	+#define SMODE_READY_CTR (1 << 17)
	49	+#define SMODE_READ_BURST (1 << 16)
	50	+#define MMODE_HBUSREQ (1 << 7)
	51	+#define MMODE_BOUNDARY ((1 << 6)\|(1 << 5))
	52	+#define MMODE_BURST_WIDTH ((1 << 4)\|(1 << 3))
	53	+#define MMODE_SINGLE_MODE ((1 << 4)\|(1 << 3))
	54	+#define MMODE_WR_INCR (1 << 2)
	55	+#define MMODE_BYTE_BURST (1 << 1)
	56	+#define MMODE_HTRANS (1 << 0)
	57	+
	58	+/* PCI_ARBITER_CTR */
	59	+#define PCIBUS_PARK_TIMER 0x00FF0000
	60	+#define PCIBUS_PARK_TIMER_SET 0x00070000
	61	+#define PCIBP_MODE (1 << 12)
	62	+#define PCIREQ7 (1 << 7)
	63	+#define PCIREQ6 (1 << 6)
	64	+#define PCIREQ5 (1 << 5)
	65	+#define PCIREQ4 (1 << 4)
	66	+#define PCIREQ3 (1 << 3)
	67	+#define PCIREQ2 (1 << 2)
	68	+#define PCIREQ1 (1 << 1)
	69	+#define PCIREQ0 (1 << 0)
	70	+
	71	+#define SMSTPCR7 0xE615014C
	72	+#define SMSTPCR703 (1 << 3)
	73	+
	74	+/* Init AHB master and slave functions of the host logic */
	75	+#define AHB_BUS_CTR_INIT \
	76	+ (SMODE_READY_CTR \| MMODE_HBUSREQ \| MMODE_WR_INCR \| \
	77	+ MMODE_BYTE_BURST \| MMODE_HTRANS)
	78	+
	79	+#define USBCTR_WIN_SIZE_1GB 0x800
	80	+
	81	+/* PCI Configuration Registers */
	82	+#define PCI_CONF_OHCI_OFFSET 0x10000
	83	+#define PCI_CONF_EHCI_OFFSET 0x10100
	84	+struct ahb_pciconf {
	85	+ u32 vid_did;
	86	+ u32 cmnd_sts;
	87	+ u32 rev;
	88	+ u32 cache_line;
	89	+ u32 basead;
	90	+};
	91	+
	92	+/* PCI Configuration Registers for AHB-PCI Bridge Registers */
	93	+#define PCI_CONF_AHBPCI_OFFSET 0x10000
	94	+struct ahbconf_pci_bridge {
	95	+ u32 vid_did; /* 0x00 */
	96	+ u32 cmnd_sts;
	97	+ u32 revid_cc;
	98	+ u32 cls_lt_ht_bist;
	99	+ u32 basead; /* 0x10 */
	100	+ u32 win1_basead;
	101	+ u32 win2_basead;
	102	+ u32 dummy0[5];
	103	+ u32 ssvdi_ssid; /* 0x2C */
	104	+ u32 dummy1[4];
	105	+ u32 intr_line_pin;
	106	+};
	107	+
	108	+/* AHB-PCI Bridge PCI Communication Registers */
	109	+#define AHBPCI_OFFSET 0x10800
	110	+struct ahbcom_pci_bridge {
	111	+ u32 pciahb_win1_ctr; /* 0x00 */
	112	+ u32 pciahb_win2_ctr;
	113	+ u32 pciahb_dct_ctr;
	114	+ u32 dummy0;
	115	+ u32 ahbpci_win1_ctr; /* 0x10 */
	116	+ u32 ahbpci_win2_ctr;
	117	+ u32 dummy1;
	118	+ u32 ahbpci_dct_ctr;
	119	+ u32 pci_int_enable; /* 0x20 */
	120	+ u32 pci_int_status;
	121	+ u32 dummy2[2];
	122	+ u32 ahb_bus_ctr; /* 0x30 */
	123	+ u32 usbctr;
	124	+ u32 dummy3[2];
	125	+ u32 pci_arbiter_ctr; /* 0x40 */
	126	+ u32 dummy4;
	127	+ u32 pci_unit_rev; /* 0x48 */
	128	+};
	129	+
	130	+struct rmobile_ehci_reg {
	131	+ u32 hciversion; /* hciversion/caplength */
	132	+ u32 hcsparams; /* hcsparams */
	133	+ u32 hccparams; /* hccparams */
	134	+ u32 hcsp_portroute; /* hcsp_portroute */
	135	+ u32 usbcmd; /* usbcmd */
	136	+ u32 usbsts; /* usbsts */
	137	+ u32 usbintr; /* usbintr */
	138	+ u32 frindex; /* frindex */
	139	+ u32 ctrldssegment; /* ctrldssegment */
	140	+ u32 periodiclistbase; /* periodiclistbase */
	141	+ u32 asynclistaddr; /* asynclistaddr */
	142	+ u32 dummy[9];
	143	+ u32 configflag; /* configflag */
	144	+ u32 portsc; /* portsc */
	145	+};
	146	+
	147	+#endif /* __EHCI_RMOBILE_H__ */
...	...	@@ -66,12 +66,10 @@
66	66
67	67	struct ums *ums_init(unsigned int dev_num)
68	68	{
69		- struct mmc *mmc = NULL;
	69	+ struct mmc *mmc = find_mmc_device(dev_num);
70	70
71		- mmc = find_mmc_device(dev_num);
72		- if (!mmc)
	71	+ if (!mmc \|\| mmc_init(mmc))
73	72	return NULL;
74		-
75	73	return ums_disk_init(mmc);
76	74	}
...	...	@@ -30,13 +30,6 @@
30	30	return 0;
31	31	}
32	32
33		-#ifdef CONFIG_USB_CABLE_CHECK
34		-int usb_cable_connected(void)
35		-{
36		- return 0;
37		-}
38		-#endif
39		-
40	33	#ifdef CONFIG_BOARD_EARLY_INIT_F
41	34	int exynos_early_init_f(void)
42	35	{
...	...	@@ -430,8 +430,7 @@
430	430	return s3c_udc_probe(&s5pc210_otg_data);
431	431	}
432	432
433		-#ifdef CONFIG_USB_CABLE_CHECK
434		-int usb_cable_connected(void)
	433	+int g_dnl_board_usb_cable_connected(void)
435	434	{
436	435	struct pmic *muic = pmic_get("MAX8997_MUIC");
437	436	if (!muic)
...	...	@@ -439,7 +438,6 @@
439	438
440	439	return !!muic->chrg->chrg_type(muic);
441	440	}
442		-#endif
443	441	#endif
444	442
445	443	static void pmic_reset(void)
...	...	@@ -312,8 +312,7 @@
312	312	return s3c_udc_probe(&s5pc210_otg_data);
313	313	}
314	314
315		-#ifdef CONFIG_USB_CABLE_CHECK
316		-int usb_cable_connected(void)
	315	+int g_dnl_board_usb_cable_connected(void)
317	316	{
318	317	struct pmic *muic = pmic_get("MAX77693_MUIC");
319	318	if (!muic)
...	...	@@ -321,7 +320,6 @@
321	320
322	321	return !!muic->chrg->chrg_type(muic);
323	322	}
324		-#endif
325	323	#endif
326	324
327	325	static int pmic_init_max77686(void)
...	...	@@ -197,13 +197,6 @@
197	197	return s3c_udc_probe(&s5pc210_otg_data);
198	198	}
199	199
200		-#ifdef CONFIG_USB_CABLE_CHECK
201		-int usb_cable_connected(void)
202		-{
203		- return 0;
204		-}
205		-#endif
206		-
207	200	int exynos_early_init_f(void)
208	201	{
209	202	wdt_stop();
...	...	@@ -22,7 +22,6 @@
22	22	char *interface = argv[2];
23	23	char *devstring = argv[3];
24	24
25		- char *s = "dfu";
26	25	int ret, i = 0;
27	26
28	27	ret = dfu_init_env_entities(interface, simple_strtoul(devstring,
...	...	@@ -38,7 +37,7 @@
38	37	int controller_index = simple_strtoul(usb_controller, NULL, 0);
39	38	board_usb_init(controller_index, USB_INIT_DEVICE);
40	39
41		- g_dnl_register(s);
	40	+ g_dnl_register("usb_dnl_dfu");
42	41	while (1) {
43	42	if (dfu_reset())
44	43	/*
...	...	@@ -40,15 +40,19 @@
40	40	return CMD_RET_FAILURE;
41	41	}
42	42
43		- g_dnl_register("ums");
	43	+ g_dnl_register("usb_dnl_ums");
44	44
45	45	/* Timeout unit: seconds */
46	46	int cable_ready_timeout = UMS_CABLE_READY_TIMEOUT;
47	47
48		- if (!usb_cable_connected()) {
	48	+ if (!g_dnl_board_usb_cable_connected()) {
	49	+ /*
	50	+ * Won't execute if we don't know whether the cable is
	51	+ * connected.
	52	+ */
49	53	puts("Please connect USB cable.\n");
50	54
51		- while (!usb_cable_connected()) {
	55	+ while (!g_dnl_board_usb_cable_connected()) {
52	56	if (ctrlc()) {
53	57	puts("\rCTRL+C - Operation aborted.\n");
54	58	goto exit;
...	...	@@ -91,6 +91,12 @@
91	91	#define USB_KBD_LEDMASK \
92	92	(USB_KBD_NUMLOCK \| USB_KBD_CAPSLOCK \| USB_KBD_SCROLLLOCK)
93	93
	94	+/*
	95	+ * USB Keyboard reports are 8 bytes in boot protocol.
	96	+ * Appendix B of HID Device Class Definition 1.11
	97	+ */
	98	+#define USB_KBD_BOOT_REPORT_SIZE 8
	99	+
94	100	struct usb_kbd_pdata {
95	101	uint32_t repeat_delay;
96	102
...	...	@@ -99,7 +105,7 @@
99	105	uint8_t usb_kbd_buffer[USB_KBD_BUFFER_LEN];
100	106
101	107	uint8_t *new;
102		- uint8_t old[8];
	108	+ uint8_t old[USB_KBD_BOOT_REPORT_SIZE];
103	109
104	110	uint8_t flags;
105	111	};
...	...	@@ -131,7 +137,8 @@
131	137	/* Submit a interrupt transfer request */
132	138	maxp = usb_maxpacket(usb_kbd_dev, pipe);
133	139	usb_submit_int_msg(usb_kbd_dev, pipe, data->new,
134		- maxp > 8 ? 8 : maxp, ep->bInterval);
	140	+ min(maxp, USB_KBD_BOOT_REPORT_SIZE),
	141	+ ep->bInterval);
135	142	}
136	143
137	144	/* Puts character in the queue and sets up the in and out pointer. */
138	145
...	...	@@ -266,8 +273,11 @@
266	273	old = data->old;
267	274	}
268	275
269		- if ((old[i] > 3) && (memscan(new + 2, old[i], 6) == new + 8))
	276	+ if ((old[i] > 3) &&
	277	+ (memscan(new + 2, old[i], USB_KBD_BOOT_REPORT_SIZE - 2) ==
	278	+ new + USB_KBD_BOOT_REPORT_SIZE)) {
270	279	res \|= usb_kbd_translate(data, old[i], data->new[0], up);
	280	+ }
271	281
272	282	return res;
273	283	}
...	...	@@ -285,7 +295,7 @@
285	295	else if ((data->new[0] == LEFT_CNTR) \|\| (data->new[0] == RIGHT_CNTR))
286	296	data->flags \|= USB_KBD_CTRL;
287	297
288		- for (i = 2; i < 8; i++) {
	298	+ for (i = 2; i < USB_KBD_BOOT_REPORT_SIZE; i++) {
289	299	res \|= usb_kbd_service_key(dev, i, 0);
290	300	res \|= usb_kbd_service_key(dev, i, 1);
291	301	}
...	...	@@ -297,7 +307,7 @@
297	307	if (res == 1)
298	308	usb_kbd_setled(dev);
299	309
300		- memcpy(data->old, data->new, 8);
	310	+ memcpy(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE);
301	311
302	312	return 1;
303	313	}
...	...	@@ -305,7 +315,8 @@
305	315	/* Keyboard interrupt handler */
306	316	static int usb_kbd_irq(struct usb_device *dev)
307	317	{
308		- if ((dev->irq_status != 0) \|\| (dev->irq_act_len != 8)) {
	318	+ if ((dev->irq_status != 0) \|\|
	319	+ (dev->irq_act_len != USB_KBD_BOOT_REPORT_SIZE)) {
309	320	debug("USB KBD: Error %lX, len %d\n",
310	321	dev->irq_status, dev->irq_act_len);
311	322	return 1;
...	...	@@ -333,7 +344,8 @@
333	344	/* Submit a interrupt transfer request */
334	345	maxp = usb_maxpacket(dev, pipe);
335	346	usb_submit_int_msg(dev, pipe, &data->new[0],
336		- maxp > 8 ? 8 : maxp, ep->bInterval);
	347	+ min(maxp, USB_KBD_BOOT_REPORT_SIZE),
	348	+ ep->bInterval);
337	349
338	350	usb_kbd_irq_worker(dev);
339	351	#elif defined(CONFIG_SYS_USB_EVENT_POLL_VIA_CONTROL_EP)
...	...	@@ -341,8 +353,8 @@
341	353	struct usb_kbd_pdata *data = dev->privptr;
342	354	iface = &dev->config.if_desc[0];
343	355	usb_get_report(dev, iface->desc.bInterfaceNumber,
344		- 1, 0, data->new, sizeof(data->new));
345		- if (memcmp(data->old, data->new, sizeof(data->new)))
	356	+ 1, 0, data->new, USB_KBD_BOOT_REPORT_SIZE);
	357	+ if (memcmp(data->old, data->new, USB_KBD_BOOT_REPORT_SIZE))
346	358	usb_kbd_irq_worker(dev);
347	359	#endif
348	360	}
...	...	@@ -441,7 +453,8 @@
441	453	memset(data, 0, sizeof(struct usb_kbd_pdata));
442	454
443	455	/* allocate input buffer aligned and sized to USB DMA alignment */
444		- data->new = memalign(USB_DMA_MINALIGN, roundup(8, USB_DMA_MINALIGN));
	456	+ data->new = memalign(USB_DMA_MINALIGN,
	457	+ roundup(USB_KBD_BOOT_REPORT_SIZE, USB_DMA_MINALIGN));
445	458
446	459	/* Insert private data into USB device structure */
447	460	dev->privptr = data;
...	...	@@ -459,7 +472,8 @@
459	472	usb_set_idle(dev, iface->desc.bInterfaceNumber, REPEAT_RATE, 0);
460	473
461	474	debug("USB KBD: enable interrupt pipe...\n");
462		- if (usb_submit_int_msg(dev, pipe, data->new, maxp > 8 ? 8 : maxp,
	475	+ if (usb_submit_int_msg(dev, pipe, data->new,
	476	+ min(maxp, USB_KBD_BOOT_REPORT_SIZE),
463	477	ep->bInterval) < 0) {
464	478	printf("Failed to get keyboard state from device %04x:%04x\n",
465	479	dev->descriptor.idVendor, dev->descriptor.idProduct);