more patches

author: Greg Kroah-Hartman <gregkh@suse.de> 2010-10-05 16:17:56 -0700
committer: Greg Kroah-Hartman <gregkh@suse.de> 2010-10-05 16:17:56 -0700
commit: eaaaa915fb5d26d4fbd71f1a9c9a5b9f07e6fef7 (patch)
tree: f840d84def75d831ae77b2740d39411573061102 /usb
parent: 8c5c1508efaea4a39c857735bf23707cbd88ac22 (diff)
download: patches-eaaaa915fb5d26d4fbd71f1a9c9a5b9f07e6fef7.tar.gz
21 files changed, 4212 insertions, 2 deletions
diff --git a/usb/usb-add-more-empty-functions-in-otg.h.patch b/usb/usb-add-more-empty-functions-in-otg.h.patch
new file mode 100644
index 00000000000000..5a4f51a46c14c2
--- /dev/null
+++ b/usb/usb-add-more-empty-functions-in-otg.h.patch
@@ -0,0 +1,43 @@
+From notasas@gmail.com  Tue Oct  5 15:34:42 2010
+From: Grazvydas Ignotas <notasas@gmail.com>
+To: Greg Kroah-Hartman <gregkh@suse.de>
+Cc: linux-usb@vger.kernel.org, Felipe Balbi <balbi@ti.com>,
+	Grazvydas Ignotas <notasas@gmail.com>
+Subject: USB: Add more empty functions in otg.h
+Date: Mon, 27 Sep 2010 15:17:18 +0300
+Message-Id: <1285589838-32539-1-git-send-email-notasas@gmail.com>
+
+Add empty functions for get/put transceiver functions too, so that
+drivers that optionally use them can call them without worrying that
+they might not exist, eliminating ifdefs.
+
+Signed-off-by: Grazvydas Ignotas <notasas@gmail.com>
+Acked-by: Felipe Balbi <balbi@ti.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ include/linux/usb/otg.h |   11 +++++++++++
+ 1 file changed, 11 insertions(+)
+
+--- a/include/linux/usb/otg.h
++++ b/include/linux/usb/otg.h
+@@ -164,8 +164,19 @@ otg_shutdown(struct otg_transceiver *otg
+ }
+ 
+ /* for usb host and peripheral controller drivers */
++#ifdef CONFIG_USB_OTG_UTILS
+ extern struct otg_transceiver *otg_get_transceiver(void);
+ extern void otg_put_transceiver(struct otg_transceiver *);
++#else
++static inline struct otg_transceiver *otg_get_transceiver(void)
++{
++	return NULL;
++}
++
++static inline void otg_put_transceiver(struct otg_transceiver *x)
++{
++}
++#endif
+ 
+ /* Context: can sleep */
+ static inline int
diff --git a/usb/usb-add-pid-for-ftdi-based-opendcc-hardware.patch b/usb/usb-add-pid-for-ftdi-based-opendcc-hardware.patch
new file mode 100644
index 00000000000000..83750969abe653
--- /dev/null
+++ b/usb/usb-add-pid-for-ftdi-based-opendcc-hardware.patch
@@ -0,0 +1,41 @@
+From mail@rainerkeller.de  Tue Oct  5 15:35:00 2010
+From: Rainer Keller <mail@rainerkeller.de>
+To: gregkh@suse.de
+Cc: Rainer Keller <mail@rainerkeller.de>
+Subject: USB: add PID for FTDI based OpenDCC hardware
+Date: Tue, 28 Sep 2010 12:27:43 +0200
+Message-Id: <1285669663-8832-1-git-send-email-mail@rainerkeller.de>
+
+The OpenDCC project is developing a new hardware. This patch adds its
+PID to the list of known FTDI devices. The PID can be found at
+http://www.opendcc.de/elektronik/usb/opendcc_usb.html
+
+Signed-off-by: Rainer Keller <mail@rainerkeller.de>
+Cc: stable <stable@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/serial/ftdi_sio.c     |    1 +
+ drivers/usb/serial/ftdi_sio_ids.h |    1 +
+ 2 files changed, 2 insertions(+)
+
+--- a/drivers/usb/serial/ftdi_sio.c
++++ b/drivers/usb/serial/ftdi_sio.c
+@@ -177,6 +177,7 @@ static struct usb_device_id id_table_com
+ 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_SNIFFER_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_THROTTLE_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GATEWAY_PID) },
++	{ USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GBM_PID) },
+ 	{ USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
+ 	{ USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_SPROG_II) },
+--- a/drivers/usb/serial/ftdi_sio_ids.h
++++ b/drivers/usb/serial/ftdi_sio_ids.h
+@@ -61,6 +61,7 @@
+ #define FTDI_OPENDCC_SNIFFER_PID	0xBFD9
+ #define FTDI_OPENDCC_THROTTLE_PID	0xBFDA
+ #define FTDI_OPENDCC_GATEWAY_PID	0xBFDB
++#define FTDI_OPENDCC_GBM_PID	0xBFDC
+ 
+ /*
+  * RR-CirKits LocoBuffer USB (http://www.rr-cirkits.com)
diff --git a/usb/usb-add-platform-glue-driver-for-fsl-usb-dr-controller.patch b/usb/usb-add-platform-glue-driver-for-fsl-usb-dr-controller.patch
new file mode 100644
index 00000000000000..652b67da79abfe
--- /dev/null
+++ b/usb/usb-add-platform-glue-driver-for-fsl-usb-dr-controller.patch
@@ -0,0 +1,466 @@
+From agust@denx.de  Tue Oct  5 15:35:43 2010
+From: Anatolij Gustschin <agust@denx.de>
+To: linux-usb@vger.kernel.org
+Cc: linuxppc-dev@ozlabs.org, Greg Kroah-Hartman <gregkh@suse.de>,
+	David Brownell <dbrownell@users.sourceforge.net>,
+	Grant Likely <grant.likely@secretlab.ca>,
+	Detlev Zundel <dzu@denx.de>, Wolfgang Denk <wd@denx.de>,
+	Anatolij Gustschin <agust@denx.de>,
+	Kumar Gala <galak@kernel.crashing.org>
+Subject: USB: add platform glue driver for FSL USB DR controller
+Date: Tue, 28 Sep 2010 20:55:20 +0200
+Message-Id: <1285700121-9991-2-git-send-email-agust@denx.de>
+
+Replace FSL USB platform code by simple platform driver for
+creation of FSL USB platform devices.
+
+The driver creates platform devices based on the information
+from USB nodes in the flat device tree. This is the replacement
+for old arch fsl_soc usb code removed by this patch. The driver
+uses usual of-style binding, available EHCI-HCD and UDC
+drivers can be bound to the created devices. The new of-style
+driver additionaly instantiates USB OTG platform device, as the
+appropriate USB OTG driver will be added soon.
+
+Signed-off-by: Anatolij Gustschin <agust@denx.de>
+Cc: Kumar Gala <galak@kernel.crashing.org>
+Cc: Grant Likely <grant.likely@secretlab.ca>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ arch/powerpc/sysdev/fsl_soc.c    |  163 -----------------------------
+ drivers/usb/gadget/Kconfig       |    1 
+ drivers/usb/host/Kconfig         |    4 
+ drivers/usb/host/Makefile        |    1 
+ drivers/usb/host/fsl-mph-dr-of.c |  219 +++++++++++++++++++++++++++++++++++++++
+ 5 files changed, 225 insertions(+), 163 deletions(-)
+
+--- a/arch/powerpc/sysdev/fsl_soc.c
++++ b/arch/powerpc/sysdev/fsl_soc.c
+@@ -209,169 +209,6 @@ static int __init of_add_fixed_phys(void
+ arch_initcall(of_add_fixed_phys);
+ #endif /* CONFIG_FIXED_PHY */
+ 
+-static enum fsl_usb2_phy_modes determine_usb_phy(const char *phy_type)
+-{
+-	if (!phy_type)
+-		return FSL_USB2_PHY_NONE;
+-	if (!strcasecmp(phy_type, "ulpi"))
+-		return FSL_USB2_PHY_ULPI;
+-	if (!strcasecmp(phy_type, "utmi"))
+-		return FSL_USB2_PHY_UTMI;
+-	if (!strcasecmp(phy_type, "utmi_wide"))
+-		return FSL_USB2_PHY_UTMI_WIDE;
+-	if (!strcasecmp(phy_type, "serial"))
+-		return FSL_USB2_PHY_SERIAL;
+-
+-	return FSL_USB2_PHY_NONE;
+-}
+-
+-static int __init fsl_usb_of_init(void)
+-{
+-	struct device_node *np;
+-	unsigned int i = 0;
+-	struct platform_device *usb_dev_mph = NULL, *usb_dev_dr_host = NULL,
+-		*usb_dev_dr_client = NULL;
+-	int ret;
+-
+-	for_each_compatible_node(np, NULL, "fsl-usb2-mph") {
+-		struct resource r[2];
+-		struct fsl_usb2_platform_data usb_data;
+-		const unsigned char *prop = NULL;
+-
+-		memset(&r, 0, sizeof(r));
+-		memset(&usb_data, 0, sizeof(usb_data));
+-
+-		ret = of_address_to_resource(np, 0, &r[0]);
+-		if (ret)
+-			goto err;
+-
+-		of_irq_to_resource(np, 0, &r[1]);
+-
+-		usb_dev_mph =
+-		    platform_device_register_simple("fsl-ehci", i, r, 2);
+-		if (IS_ERR(usb_dev_mph)) {
+-			ret = PTR_ERR(usb_dev_mph);
+-			goto err;
+-		}
+-
+-		usb_dev_mph->dev.coherent_dma_mask = 0xffffffffUL;
+-		usb_dev_mph->dev.dma_mask = &usb_dev_mph->dev.coherent_dma_mask;
+-
+-		usb_data.operating_mode = FSL_USB2_MPH_HOST;
+-
+-		prop = of_get_property(np, "port0", NULL);
+-		if (prop)
+-			usb_data.port_enables |= FSL_USB2_PORT0_ENABLED;
+-
+-		prop = of_get_property(np, "port1", NULL);
+-		if (prop)
+-			usb_data.port_enables |= FSL_USB2_PORT1_ENABLED;
+-
+-		prop = of_get_property(np, "phy_type", NULL);
+-		usb_data.phy_mode = determine_usb_phy(prop);
+-
+-		ret =
+-		    platform_device_add_data(usb_dev_mph, &usb_data,
+-					     sizeof(struct
+-						    fsl_usb2_platform_data));
+-		if (ret)
+-			goto unreg_mph;
+-		i++;
+-	}
+-
+-	for_each_compatible_node(np, NULL, "fsl-usb2-dr") {
+-		struct resource r[2];
+-		struct fsl_usb2_platform_data usb_data;
+-		const unsigned char *prop = NULL;
+-
+-		if (!of_device_is_available(np))
+-			continue;
+-
+-		memset(&r, 0, sizeof(r));
+-		memset(&usb_data, 0, sizeof(usb_data));
+-
+-		ret = of_address_to_resource(np, 0, &r[0]);
+-		if (ret)
+-			goto unreg_mph;
+-
+-		of_irq_to_resource(np, 0, &r[1]);
+-
+-		prop = of_get_property(np, "dr_mode", NULL);
+-
+-		if (!prop || !strcmp(prop, "host")) {
+-			usb_data.operating_mode = FSL_USB2_DR_HOST;
+-			usb_dev_dr_host = platform_device_register_simple(
+-					"fsl-ehci", i, r, 2);
+-			if (IS_ERR(usb_dev_dr_host)) {
+-				ret = PTR_ERR(usb_dev_dr_host);
+-				goto err;
+-			}
+-		} else if (prop && !strcmp(prop, "peripheral")) {
+-			usb_data.operating_mode = FSL_USB2_DR_DEVICE;
+-			usb_dev_dr_client = platform_device_register_simple(
+-					"fsl-usb2-udc", i, r, 2);
+-			if (IS_ERR(usb_dev_dr_client)) {
+-				ret = PTR_ERR(usb_dev_dr_client);
+-				goto err;
+-			}
+-		} else if (prop && !strcmp(prop, "otg")) {
+-			usb_data.operating_mode = FSL_USB2_DR_OTG;
+-			usb_dev_dr_host = platform_device_register_simple(
+-					"fsl-ehci", i, r, 2);
+-			if (IS_ERR(usb_dev_dr_host)) {
+-				ret = PTR_ERR(usb_dev_dr_host);
+-				goto err;
+-			}
+-			usb_dev_dr_client = platform_device_register_simple(
+-					"fsl-usb2-udc", i, r, 2);
+-			if (IS_ERR(usb_dev_dr_client)) {
+-				ret = PTR_ERR(usb_dev_dr_client);
+-				goto err;
+-			}
+-		} else {
+-			ret = -EINVAL;
+-			goto err;
+-		}
+-
+-		prop = of_get_property(np, "phy_type", NULL);
+-		usb_data.phy_mode = determine_usb_phy(prop);
+-
+-		if (usb_dev_dr_host) {
+-			usb_dev_dr_host->dev.coherent_dma_mask = 0xffffffffUL;
+-			usb_dev_dr_host->dev.dma_mask = &usb_dev_dr_host->
+-				dev.coherent_dma_mask;
+-			if ((ret = platform_device_add_data(usb_dev_dr_host,
+-						&usb_data, sizeof(struct
+-						fsl_usb2_platform_data))))
+-				goto unreg_dr;
+-		}
+-		if (usb_dev_dr_client) {
+-			usb_dev_dr_client->dev.coherent_dma_mask = 0xffffffffUL;
+-			usb_dev_dr_client->dev.dma_mask = &usb_dev_dr_client->
+-				dev.coherent_dma_mask;
+-			if ((ret = platform_device_add_data(usb_dev_dr_client,
+-						&usb_data, sizeof(struct
+-						fsl_usb2_platform_data))))
+-				goto unreg_dr;
+-		}
+-		i++;
+-	}
+-	return 0;
+-
+-unreg_dr:
+-	if (usb_dev_dr_host)
+-		platform_device_unregister(usb_dev_dr_host);
+-	if (usb_dev_dr_client)
+-		platform_device_unregister(usb_dev_dr_client);
+-unreg_mph:
+-	if (usb_dev_mph)
+-		platform_device_unregister(usb_dev_mph);
+-err:
+-	return ret;
+-}
+-
+-arch_initcall(fsl_usb_of_init);
+-
+ #if defined(CONFIG_FSL_SOC_BOOKE) || defined(CONFIG_PPC_86xx)
+ static __be32 __iomem *rstcr;
+ 
+--- a/drivers/usb/gadget/Kconfig
++++ b/drivers/usb/gadget/Kconfig
+@@ -158,6 +158,7 @@ config USB_GADGET_FSL_USB2
+ 	boolean "Freescale Highspeed USB DR Peripheral Controller"
+ 	depends on FSL_SOC || ARCH_MXC
+ 	select USB_GADGET_DUALSPEED
++	select USB_FSL_MPH_DR_OF
+ 	help
+ 	   Some of Freescale PowerPC processors have a High Speed
+ 	   Dual-Role(DR) USB controller, which supports device mode.
+--- a/drivers/usb/host/Kconfig
++++ b/drivers/usb/host/Kconfig
+@@ -112,10 +112,14 @@ config XPS_USB_HCD_XILINX
+ 		support both high speed and full speed devices, or high speed
+ 		devices only.
+ 
++config USB_FSL_MPH_DR_OF
++	tristate
++
+ config USB_EHCI_FSL
+ 	bool "Support for Freescale on-chip EHCI USB controller"
+ 	depends on USB_EHCI_HCD && FSL_SOC
+ 	select USB_EHCI_ROOT_HUB_TT
++	select USB_FSL_MPH_DR_OF
+ 	---help---
+ 	  Variation of ARC USB block used in some Freescale chips.
+ 
+--- a/drivers/usb/host/Makefile
++++ b/drivers/usb/host/Makefile
+@@ -31,4 +31,5 @@ obj-$(CONFIG_USB_R8A66597_HCD)	+= r8a665
+ obj-$(CONFIG_USB_ISP1760_HCD)	+= isp1760.o
+ obj-$(CONFIG_USB_HWA_HCD)	+= hwa-hc.o
+ obj-$(CONFIG_USB_IMX21_HCD)	+= imx21-hcd.o
++obj-$(CONFIG_USB_FSL_MPH_DR_OF)	+= fsl-mph-dr-of.o
+ 
+--- /dev/null
++++ b/drivers/usb/host/fsl-mph-dr-of.c
+@@ -0,0 +1,219 @@
++/*
++ * Setup platform devices needed by the Freescale multi-port host
++ * and/or dual-role USB controller modules based on the description
++ * in flat device tree.
++ *
++ * 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;  either version 2 of the  License, or (at your
++ * option) any later version.
++ */
++
++#include <linux/kernel.h>
++#include <linux/platform_device.h>
++#include <linux/fsl_devices.h>
++#include <linux/err.h>
++#include <linux/io.h>
++#include <linux/of_platform.h>
++
++struct fsl_usb2_dev_data {
++	char *dr_mode;		/* controller mode */
++	char *drivers[3];	/* drivers to instantiate for this mode */
++	enum fsl_usb2_operating_modes op_mode;	/* operating mode */
++};
++
++struct fsl_usb2_dev_data dr_mode_data[] __devinitdata = {
++	{
++		.dr_mode = "host",
++		.drivers = { "fsl-ehci", NULL, NULL, },
++		.op_mode = FSL_USB2_DR_HOST,
++	},
++	{
++		.dr_mode = "otg",
++		.drivers = { "fsl-usb2-otg", "fsl-ehci", "fsl-usb2-udc", },
++		.op_mode = FSL_USB2_DR_OTG,
++	},
++	{
++		.dr_mode = "peripheral",
++		.drivers = { "fsl-usb2-udc", NULL, NULL, },
++		.op_mode = FSL_USB2_DR_DEVICE,
++	},
++};
++
++struct fsl_usb2_dev_data * __devinit get_dr_mode_data(struct device_node *np)
++{
++	const unsigned char *prop;
++	int i;
++
++	prop = of_get_property(np, "dr_mode", NULL);
++	if (prop) {
++		for (i = 0; i < ARRAY_SIZE(dr_mode_data); i++) {
++			if (!strcmp(prop, dr_mode_data[i].dr_mode))
++				return &dr_mode_data[i];
++		}
++	}
++	pr_warn("%s: Invalid 'dr_mode' property, fallback to host mode\n",
++		np->full_name);
++	return &dr_mode_data[0]; /* mode not specified, use host */
++}
++
++static enum fsl_usb2_phy_modes __devinit determine_usb_phy(const char *phy_type)
++{
++	if (!phy_type)
++		return FSL_USB2_PHY_NONE;
++	if (!strcasecmp(phy_type, "ulpi"))
++		return FSL_USB2_PHY_ULPI;
++	if (!strcasecmp(phy_type, "utmi"))
++		return FSL_USB2_PHY_UTMI;
++	if (!strcasecmp(phy_type, "utmi_wide"))
++		return FSL_USB2_PHY_UTMI_WIDE;
++	if (!strcasecmp(phy_type, "serial"))
++		return FSL_USB2_PHY_SERIAL;
++
++	return FSL_USB2_PHY_NONE;
++}
++
++struct platform_device * __devinit fsl_usb2_device_register(
++					struct platform_device *ofdev,
++					struct fsl_usb2_platform_data *pdata,
++					const char *name, int id)
++{
++	struct platform_device *pdev;
++	const struct resource *res = ofdev->resource;
++	unsigned int num = ofdev->num_resources;
++	int retval;
++
++	pdev = platform_device_alloc(name, id);
++	if (!pdev) {
++		retval = -ENOMEM;
++		goto error;
++	}
++
++	pdev->dev.parent = &ofdev->dev;
++
++	pdev->dev.coherent_dma_mask = ofdev->dev.coherent_dma_mask;
++	pdev->dev.dma_mask = &pdev->archdata.dma_mask;
++	*pdev->dev.dma_mask = *ofdev->dev.dma_mask;
++
++	retval = platform_device_add_data(pdev, pdata, sizeof(*pdata));
++	if (retval)
++		goto error;
++
++	if (num) {
++		retval = platform_device_add_resources(pdev, res, num);
++		if (retval)
++			goto error;
++	}
++
++	retval = platform_device_add(pdev);
++	if (retval)
++		goto error;
++
++	return pdev;
++
++error:
++	platform_device_put(pdev);
++	return ERR_PTR(retval);
++}
++
++static const struct of_device_id fsl_usb2_mph_dr_of_match[];
++
++static int __devinit fsl_usb2_mph_dr_of_probe(struct platform_device *ofdev)
++{
++	struct device_node *np = ofdev->dev.of_node;
++	struct platform_device *usb_dev;
++	struct fsl_usb2_platform_data data, *pdata;
++	struct fsl_usb2_dev_data *dev_data;
++	const struct of_device_id *match;
++	const unsigned char *prop;
++	static unsigned int idx;
++	int i;
++
++	if (!of_device_is_available(np))
++		return -ENODEV;
++
++	match = of_match_device(fsl_usb2_mph_dr_of_match, &ofdev->dev);
++	if (!match)
++		return -ENODEV;
++
++	pdata = &data;
++	if (match->data)
++		memcpy(pdata, match->data, sizeof(data));
++	else
++		memset(pdata, 0, sizeof(data));
++
++	dev_data = get_dr_mode_data(np);
++
++	if (of_device_is_compatible(np, "fsl-usb2-mph")) {
++		if (of_get_property(np, "port0", NULL))
++			pdata->port_enables |= FSL_USB2_PORT0_ENABLED;
++
++		if (of_get_property(np, "port1", NULL))
++			pdata->port_enables |= FSL_USB2_PORT1_ENABLED;
++
++		pdata->operating_mode = FSL_USB2_MPH_HOST;
++	} else {
++		/* setup mode selected in the device tree */
++		pdata->operating_mode = dev_data->op_mode;
++	}
++
++	prop = of_get_property(np, "phy_type", NULL);
++	pdata->phy_mode = determine_usb_phy(prop);
++
++	for (i = 0; i < ARRAY_SIZE(dev_data->drivers); i++) {
++		if (!dev_data->drivers[i])
++			continue;
++		usb_dev = fsl_usb2_device_register(ofdev, pdata,
++					dev_data->drivers[i], idx);
++		if (IS_ERR(usb_dev)) {
++			dev_err(&ofdev->dev, "Can't register usb device\n");
++			return PTR_ERR(usb_dev);
++		}
++	}
++	idx++;
++	return 0;
++}
++
++static int __devexit __unregister_subdev(struct device *dev, void *d)
++{
++	platform_device_unregister(to_platform_device(dev));
++	return 0;
++}
++
++static int __devexit fsl_usb2_mph_dr_of_remove(struct platform_device *ofdev)
++{
++	device_for_each_child(&ofdev->dev, NULL, __unregister_subdev);
++	return 0;
++}
++
++static const struct of_device_id fsl_usb2_mph_dr_of_match[] = {
++	{ .compatible = "fsl-usb2-mph", },
++	{ .compatible = "fsl-usb2-dr", },
++	{},
++};
++
++static struct platform_driver fsl_usb2_mph_dr_driver = {
++	.driver = {
++		.name = "fsl-usb2-mph-dr",
++		.owner = THIS_MODULE,
++		.of_match_table = fsl_usb2_mph_dr_of_match,
++	},
++	.probe	= fsl_usb2_mph_dr_of_probe,
++	.remove	= __devexit_p(fsl_usb2_mph_dr_of_remove),
++};
++
++static int __init fsl_usb2_mph_dr_init(void)
++{
++	return platform_driver_register(&fsl_usb2_mph_dr_driver);
++}
++module_init(fsl_usb2_mph_dr_init);
++
++static void __exit fsl_usb2_mph_dr_exit(void)
++{
++	platform_driver_unregister(&fsl_usb2_mph_dr_driver);
++}
++module_exit(fsl_usb2_mph_dr_exit);
++
++MODULE_DESCRIPTION("FSL MPH DR OF devices driver");
++MODULE_AUTHOR("Anatolij Gustschin <agust@denx.de>");
++MODULE_LICENSE("GPL");
diff --git a/usb/usb-add-usb-ehci-support-for-mpc5121-soc.patch b/usb/usb-add-usb-ehci-support-for-mpc5121-soc.patch
new file mode 100644
index 00000000000000..ad17770028f564
--- /dev/null
+++ b/usb/usb-add-usb-ehci-support-for-mpc5121-soc.patch
@@ -0,0 +1,486 @@
+From agust@denx.de  Tue Oct  5 15:36:14 2010
+From: Anatolij Gustschin <agust@denx.de>
+To: linux-usb@vger.kernel.org
+Cc: linuxppc-dev@ozlabs.org, Greg Kroah-Hartman <gregkh@suse.de>,
+	David Brownell <dbrownell@users.sourceforge.net>,
+	Grant Likely <grant.likely@secretlab.ca>,
+	Detlev Zundel <dzu@denx.de>, Wolfgang Denk <wd@denx.de>,
+	Anatolij Gustschin <agust@denx.de>
+Subject: USB: add USB EHCI support for MPC5121 SoC
+Date: Tue, 28 Sep 2010 20:55:21 +0200
+Message-Id: <1285700121-9991-3-git-send-email-agust@denx.de>
+
+Extends FSL EHCI platform driver glue layer to support
+MPC5121 USB controllers. MPC5121 Rev 2.0 silicon EHCI
+registers are in big endian format. The appropriate flags
+are set using the information in the platform data structure.
+MPC83xx system interface registers are not available on
+MPC512x, so the access to these registers is isolated in
+MPC512x case. Furthermore the USB controller clocks
+must be enabled before 512x register accesses which is
+done by providing platform specific init callback.
+
+The MPC512x internal USB PHY doesn't provide supply voltage.
+For boards using different power switches allow specifying
+DRVVBUS and PWR_FAULT signal polarity of the MPC5121 internal
+PHY using "fsl,invert-drvvbus" and "fsl,invert-pwr-fault"
+properties in the device tree USB nodes. Adds documentation
+for this new device tree bindings.
+
+Signed-off-by: Anatolij Gustschin <agust@denx.de>
+Cc: Grant Likely <grant.likely@secretlab.ca>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ Documentation/powerpc/dts-bindings/fsl/usb.txt |   22 +++++
+ drivers/usb/Kconfig                            |    1 
+ drivers/usb/host/Kconfig                       |    6 -
+ drivers/usb/host/ehci-fsl.c                    |  101 +++++++++++++++++--------
+ drivers/usb/host/ehci-fsl.h                    |   13 ++-
+ drivers/usb/host/ehci-mem.c                    |    2 
+ drivers/usb/host/fsl-mph-dr-of.c               |   89 ++++++++++++++++++++++
+ include/linux/fsl_devices.h                    |   15 +++
+ 8 files changed, 216 insertions(+), 33 deletions(-)
+
+--- a/Documentation/powerpc/dts-bindings/fsl/usb.txt
++++ b/Documentation/powerpc/dts-bindings/fsl/usb.txt
+@@ -8,6 +8,7 @@ and additions :
+ Required properties :
+  - compatible : Should be "fsl-usb2-mph" for multi port host USB
+    controllers, or "fsl-usb2-dr" for dual role USB controllers
++   or "fsl,mpc5121-usb2-dr" for dual role USB controllers of MPC5121
+  - phy_type : For multi port host USB controllers, should be one of
+    "ulpi", or "serial". For dual role USB controllers, should be
+    one of "ulpi", "utmi", "utmi_wide", or "serial".
+@@ -33,6 +34,12 @@ Recommended properties :
+  - interrupt-parent : the phandle for the interrupt controller that
+    services interrupts for this device.
+ 
++Optional properties :
++ - fsl,invert-drvvbus : boolean; for MPC5121 USB0 only. Indicates the
++   port power polarity of internal PHY signal DRVVBUS is inverted.
++ - fsl,invert-pwr-fault : boolean; for MPC5121 USB0 only. Indicates
++   the PWR_FAULT signal polarity is inverted.
++
+ Example multi port host USB controller device node :
+ 	usb@22000 {
+ 		compatible = "fsl-usb2-mph";
+@@ -57,3 +64,18 @@ Example dual role USB controller device
+ 		dr_mode = "otg";
+ 		phy = "ulpi";
+ 	};
++
++Example dual role USB controller device node for MPC5121ADS:
++
++	usb@4000 {
++		compatible = "fsl,mpc5121-usb2-dr";
++		reg = <0x4000 0x1000>;
++		#address-cells = <1>;
++		#size-cells = <0>;
++		interrupt-parent = < &ipic >;
++		interrupts = <44 0x8>;
++		dr_mode = "otg";
++		phy_type = "utmi_wide";
++		fsl,invert-drvvbus;
++		fsl,invert-pwr-fault;
++	};
+--- a/drivers/usb/Kconfig
++++ b/drivers/usb/Kconfig
+@@ -59,6 +59,7 @@ config USB_ARCH_HAS_OHCI
+ config USB_ARCH_HAS_EHCI
+ 	boolean
+ 	default y if PPC_83xx
++	default y if PPC_MPC512x
+ 	default y if SOC_AU1200
+ 	default y if ARCH_IXP4XX
+ 	default y if ARCH_W90X900
+--- a/drivers/usb/host/Kconfig
++++ b/drivers/usb/host/Kconfig
+@@ -93,12 +93,14 @@ config USB_EHCI_TT_NEWSCHED
+ 
+ config USB_EHCI_BIG_ENDIAN_MMIO
+ 	bool
+-	depends on USB_EHCI_HCD && (PPC_CELLEB || PPC_PS3 || 440EPX || ARCH_IXP4XX || XPS_USB_HCD_XILINX)
++	depends on USB_EHCI_HCD && (PPC_CELLEB || PPC_PS3 || 440EPX || ARCH_IXP4XX || \
++				    XPS_USB_HCD_XILINX || PPC_MPC512x)
+ 	default y
+ 
+ config USB_EHCI_BIG_ENDIAN_DESC
+ 	bool
+-	depends on USB_EHCI_HCD && (440EPX || ARCH_IXP4XX || XPS_USB_HCD_XILINX)
++	depends on USB_EHCI_HCD && (440EPX || ARCH_IXP4XX || XPS_USB_HCD_XILINX || \
++				    PPC_MPC512x)
+ 	default y
+ 
+ config XPS_USB_HCD_XILINX
+--- a/drivers/usb/host/ehci-fsl.c
++++ b/drivers/usb/host/ehci-fsl.c
+@@ -116,13 +116,33 @@ static int usb_hcd_fsl_probe(const struc
+ 		goto err3;
+ 	}
+ 
+-	/* Enable USB controller */
+-	temp = in_be32(hcd->regs + 0x500);
+-	out_be32(hcd->regs + 0x500, temp | 0x4);
+-
+-	/* Set to Host mode */
+-	temp = in_le32(hcd->regs + 0x1a8);
+-	out_le32(hcd->regs + 0x1a8, temp | 0x3);
++	pdata->regs = hcd->regs;
++
++	/*
++	 * do platform specific init: check the clock, grab/config pins, etc.
++	 */
++	if (pdata->init && pdata->init(pdev)) {
++		retval = -ENODEV;
++		goto err3;
++	}
++
++	/*
++	 * Check if it is MPC5121 SoC, otherwise set pdata->have_sysif_regs
++	 * flag for 83xx or 8536 system interface registers.
++	 */
++	if (pdata->big_endian_mmio)
++		temp = in_be32(hcd->regs + FSL_SOC_USB_ID);
++	else
++		temp = in_le32(hcd->regs + FSL_SOC_USB_ID);
++
++	if ((temp & ID_MSK) != (~((temp & NID_MSK) >> 8) & ID_MSK))
++		pdata->have_sysif_regs = 1;
++
++	/* Enable USB controller, 83xx or 8536 */
++	if (pdata->have_sysif_regs)
++		setbits32(hcd->regs + FSL_SOC_USB_CTRL, 0x4);
++
++	/* Don't need to set host mode here. It will be done by tdi_reset() */
+ 
+ 	retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+ 	if (retval != 0)
+@@ -137,6 +157,8 @@ static int usb_hcd_fsl_probe(const struc
+ 	usb_put_hcd(hcd);
+       err1:
+ 	dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), retval);
++	if (pdata->exit)
++		pdata->exit(pdev);
+ 	return retval;
+ }
+ 
+@@ -154,17 +176,30 @@ static int usb_hcd_fsl_probe(const struc
+ static void usb_hcd_fsl_remove(struct usb_hcd *hcd,
+ 			       struct platform_device *pdev)
+ {
++	struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
++
+ 	usb_remove_hcd(hcd);
++
++	/*
++	 * do platform specific un-initialization:
++	 * release iomux pins, disable clock, etc.
++	 */
++	if (pdata->exit)
++		pdata->exit(pdev);
+ 	iounmap(hcd->regs);
+ 	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+ 	usb_put_hcd(hcd);
+ }
+ 
+-static void mpc83xx_setup_phy(struct ehci_hcd *ehci,
+-			      enum fsl_usb2_phy_modes phy_mode,
+-			      unsigned int port_offset)
++static void ehci_fsl_setup_phy(struct ehci_hcd *ehci,
++			       enum fsl_usb2_phy_modes phy_mode,
++			       unsigned int port_offset)
+ {
+-	u32 portsc = 0;
++	u32 portsc;
++
++	portsc = ehci_readl(ehci, &ehci->regs->port_status[port_offset]);
++	portsc &= ~(PORT_PTS_MSK | PORT_PTS_PTW);
++
+ 	switch (phy_mode) {
+ 	case FSL_USB2_PHY_ULPI:
+ 		portsc |= PORT_PTS_ULPI;
+@@ -184,20 +219,21 @@ static void mpc83xx_setup_phy(struct ehc
+ 	ehci_writel(ehci, portsc, &ehci->regs->port_status[port_offset]);
+ }
+ 
+-static void mpc83xx_usb_setup(struct usb_hcd *hcd)
++static void ehci_fsl_usb_setup(struct ehci_hcd *ehci)
+ {
+-	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
++	struct usb_hcd *hcd = ehci_to_hcd(ehci);
+ 	struct fsl_usb2_platform_data *pdata;
+ 	void __iomem *non_ehci = hcd->regs;
+ 	u32 temp;
+ 
+-	pdata =
+-	    (struct fsl_usb2_platform_data *)hcd->self.controller->
+-	    platform_data;
++	pdata = hcd->self.controller->platform_data;
++
+ 	/* Enable PHY interface in the control reg. */
+-	temp = in_be32(non_ehci + FSL_SOC_USB_CTRL);
+-	out_be32(non_ehci + FSL_SOC_USB_CTRL, temp | 0x00000004);
+-	out_be32(non_ehci + FSL_SOC_USB_SNOOP1, 0x0000001b);
++	if (pdata->have_sysif_regs) {
++		temp = in_be32(non_ehci + FSL_SOC_USB_CTRL);
++		out_be32(non_ehci + FSL_SOC_USB_CTRL, temp | 0x00000004);
++		out_be32(non_ehci + FSL_SOC_USB_SNOOP1, 0x0000001b);
++	}
+ 
+ #if defined(CONFIG_PPC32) && !defined(CONFIG_NOT_COHERENT_CACHE)
+ 	/*
+@@ -214,7 +250,7 @@ static void mpc83xx_usb_setup(struct usb
+ 
+ 	if ((pdata->operating_mode == FSL_USB2_DR_HOST) ||
+ 			(pdata->operating_mode == FSL_USB2_DR_OTG))
+-		mpc83xx_setup_phy(ehci, pdata->phy_mode, 0);
++		ehci_fsl_setup_phy(ehci, pdata->phy_mode, 0);
+ 
+ 	if (pdata->operating_mode == FSL_USB2_MPH_HOST) {
+ 		unsigned int chip, rev, svr;
+@@ -228,25 +264,27 @@ static void mpc83xx_usb_setup(struct usb
+ 			ehci->has_fsl_port_bug = 1;
+ 
+ 		if (pdata->port_enables & FSL_USB2_PORT0_ENABLED)
+-			mpc83xx_setup_phy(ehci, pdata->phy_mode, 0);
++			ehci_fsl_setup_phy(ehci, pdata->phy_mode, 0);
+ 		if (pdata->port_enables & FSL_USB2_PORT1_ENABLED)
+-			mpc83xx_setup_phy(ehci, pdata->phy_mode, 1);
++			ehci_fsl_setup_phy(ehci, pdata->phy_mode, 1);
+ 	}
+ 
++	if (pdata->have_sysif_regs) {
+ #ifdef CONFIG_PPC_85xx
+-	out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x00000008);
+-	out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000080);
++		out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x00000008);
++		out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000080);
+ #else
+-	out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x0000000c);
+-	out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000040);
++		out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x0000000c);
++		out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000040);
+ #endif
+-	out_be32(non_ehci + FSL_SOC_USB_SICTRL, 0x00000001);
++		out_be32(non_ehci + FSL_SOC_USB_SICTRL, 0x00000001);
++	}
+ }
+ 
+ /* called after powerup, by probe or system-pm "wakeup" */
+ static int ehci_fsl_reinit(struct ehci_hcd *ehci)
+ {
+-	mpc83xx_usb_setup(ehci_to_hcd(ehci));
++	ehci_fsl_usb_setup(ehci);
+ 	ehci_port_power(ehci, 0);
+ 
+ 	return 0;
+@@ -257,6 +295,11 @@ static int ehci_fsl_setup(struct usb_hcd
+ {
+ 	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+ 	int retval;
++	struct fsl_usb2_platform_data *pdata;
++
++	pdata = hcd->self.controller->platform_data;
++	ehci->big_endian_desc = pdata->big_endian_desc;
++	ehci->big_endian_mmio = pdata->big_endian_mmio;
+ 
+ 	/* EHCI registers start at offset 0x100 */
+ 	ehci->caps = hcd->regs + 0x100;
+@@ -370,7 +413,7 @@ static const struct hc_driver ehci_fsl_h
+ 	 * generic hardware linkage
+ 	 */
+ 	.irq = ehci_irq,
+-	.flags = HCD_USB2,
++	.flags = HCD_USB2 | HCD_MEMORY,
+ 
+ 	/*
+ 	 * basic lifecycle operations
+--- a/drivers/usb/host/ehci-fsl.h
++++ b/drivers/usb/host/ehci-fsl.h
+@@ -1,4 +1,4 @@
+-/* Copyright (c) 2005 freescale semiconductor
++/* Copyright (C) 2005-2010 Freescale Semiconductor, Inc.
+  * Copyright (c) 2005 MontaVista Software
+  *
+  * This program is free software; you can redistribute  it and/or modify it
+@@ -19,6 +19,9 @@
+ #define _EHCI_FSL_H
+ 
+ /* offsets for the non-ehci registers in the FSL SOC USB controller */
++#define FSL_SOC_USB_ID		0x0
++#define ID_MSK			0x3f
++#define NID_MSK			0x3f00
+ #define FSL_SOC_USB_ULPIVP	0x170
+ #define FSL_SOC_USB_PORTSC1	0x184
+ #define PORT_PTS_MSK		(3<<30)
+@@ -27,6 +30,14 @@
+ #define	PORT_PTS_SERIAL		(3<<30)
+ #define PORT_PTS_PTW		(1<<28)
+ #define FSL_SOC_USB_PORTSC2	0x188
++
++#define FSL_SOC_USB_USBGENCTRL	0x200
++#define USBGENCTRL_PPP		(1 << 3)
++#define USBGENCTRL_PFP		(1 << 2)
++#define FSL_SOC_USB_ISIPHYCTRL	0x204
++#define ISIPHYCTRL_PXE		(1)
++#define ISIPHYCTRL_PHYE		(1 << 4)
++
+ #define FSL_SOC_USB_SNOOP1	0x400	/* NOTE: big-endian */
+ #define FSL_SOC_USB_SNOOP2	0x404	/* NOTE: big-endian */
+ #define FSL_SOC_USB_AGECNTTHRSH	0x408	/* NOTE: big-endian */
+--- a/drivers/usb/host/ehci-mem.c
++++ b/drivers/usb/host/ehci-mem.c
+@@ -40,7 +40,7 @@ static inline void ehci_qtd_init(struct
+ {
+ 	memset (qtd, 0, sizeof *qtd);
+ 	qtd->qtd_dma = dma;
+-	qtd->hw_token = cpu_to_le32 (QTD_STS_HALT);
++	qtd->hw_token = cpu_to_hc32(ehci, QTD_STS_HALT);
+ 	qtd->hw_next = EHCI_LIST_END(ehci);
+ 	qtd->hw_alt_next = EHCI_LIST_END(ehci);
+ 	INIT_LIST_HEAD (&qtd->qtd_list);
+--- a/drivers/usb/host/fsl-mph-dr-of.c
++++ b/drivers/usb/host/fsl-mph-dr-of.c
+@@ -15,6 +15,7 @@
+ #include <linux/err.h>
+ #include <linux/io.h>
+ #include <linux/of_platform.h>
++#include <linux/clk.h>
+ 
+ struct fsl_usb2_dev_data {
+ 	char *dr_mode;		/* controller mode */
+@@ -153,6 +154,12 @@ static int __devinit fsl_usb2_mph_dr_of_
+ 
+ 		pdata->operating_mode = FSL_USB2_MPH_HOST;
+ 	} else {
++		if (of_get_property(np, "fsl,invert-drvvbus", NULL))
++			pdata->invert_drvvbus = 1;
++
++		if (of_get_property(np, "fsl,invert-pwr-fault", NULL))
++			pdata->invert_pwr_fault = 1;
++
+ 		/* setup mode selected in the device tree */
+ 		pdata->operating_mode = dev_data->op_mode;
+ 	}
+@@ -186,9 +193,91 @@ static int __devexit fsl_usb2_mph_dr_of_
+ 	return 0;
+ }
+ 
++#ifdef CONFIG_PPC_MPC512x
++
++#define USBGENCTRL		0x200		/* NOTE: big endian */
++#define GC_WU_INT_CLR		(1 << 5)	/* Wakeup int clear */
++#define GC_ULPI_SEL		(1 << 4)	/* ULPI i/f select (usb0 only)*/
++#define GC_PPP			(1 << 3)	/* Inv. Port Power Polarity */
++#define GC_PFP			(1 << 2)	/* Inv. Power Fault Polarity */
++#define GC_WU_ULPI_EN		(1 << 1)	/* Wakeup on ULPI event */
++#define GC_WU_IE		(1 << 1)	/* Wakeup interrupt enable */
++
++#define ISIPHYCTRL		0x204		/* NOTE: big endian */
++#define PHYCTRL_PHYE		(1 << 4)	/* On-chip UTMI PHY enable */
++#define PHYCTRL_BSENH		(1 << 3)	/* Bit Stuff Enable High */
++#define PHYCTRL_BSEN		(1 << 2)	/* Bit Stuff Enable */
++#define PHYCTRL_LSFE		(1 << 1)	/* Line State Filter Enable */
++#define PHYCTRL_PXE		(1 << 0)	/* PHY oscillator enable */
++
++int fsl_usb2_mpc5121_init(struct platform_device *pdev)
++{
++	struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
++	struct clk *clk;
++	char clk_name[10];
++	int base, clk_num;
++
++	base = pdev->resource->start & 0xf000;
++	if (base == 0x3000)
++		clk_num = 1;
++	else if (base == 0x4000)
++		clk_num = 2;
++	else
++		return -ENODEV;
++
++	snprintf(clk_name, sizeof(clk_name), "usb%d_clk", clk_num);
++	clk = clk_get(&pdev->dev, clk_name);
++	if (IS_ERR(clk)) {
++		dev_err(&pdev->dev, "failed to get clk\n");
++		return PTR_ERR(clk);
++	}
++
++	clk_enable(clk);
++	pdata->clk = clk;
++
++	if (pdata->phy_mode == FSL_USB2_PHY_UTMI_WIDE) {
++		u32 reg = 0;
++
++		if (pdata->invert_drvvbus)
++			reg |= GC_PPP;
++
++		if (pdata->invert_pwr_fault)
++			reg |= GC_PFP;
++
++		out_be32(pdata->regs + ISIPHYCTRL, PHYCTRL_PHYE | PHYCTRL_PXE);
++		out_be32(pdata->regs + USBGENCTRL, reg);
++	}
++	return 0;
++}
++
++static void fsl_usb2_mpc5121_exit(struct platform_device *pdev)
++{
++	struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
++
++	pdata->regs = NULL;
++
++	if (pdata->clk) {
++		clk_disable(pdata->clk);
++		clk_put(pdata->clk);
++	}
++}
++
++struct fsl_usb2_platform_data fsl_usb2_mpc5121_pd = {
++	.big_endian_desc = 1,
++	.big_endian_mmio = 1,
++	.es = 1,
++	.le_setup_buf = 1,
++	.init = fsl_usb2_mpc5121_init,
++	.exit = fsl_usb2_mpc5121_exit,
++};
++#endif /* CONFIG_PPC_MPC512x */
++
+ static const struct of_device_id fsl_usb2_mph_dr_of_match[] = {
+ 	{ .compatible = "fsl-usb2-mph", },
+ 	{ .compatible = "fsl-usb2-dr", },
++#ifdef CONFIG_PPC_MPC512x
++	{ .compatible = "fsl,mpc5121-usb2-dr", .data = &fsl_usb2_mpc5121_pd, },
++#endif
+ 	{},
+ };
+ 
+--- a/include/linux/fsl_devices.h
++++ b/include/linux/fsl_devices.h
+@@ -58,11 +58,26 @@ enum fsl_usb2_phy_modes {
+ 	FSL_USB2_PHY_SERIAL,
+ };
+ 
++struct clk;
++struct platform_device;
++
+ struct fsl_usb2_platform_data {
+ 	/* board specific information */
+ 	enum fsl_usb2_operating_modes	operating_mode;
+ 	enum fsl_usb2_phy_modes		phy_mode;
+ 	unsigned int			port_enables;
++
++	int		(*init)(struct platform_device *);
++	void		(*exit)(struct platform_device *);
++	void __iomem	*regs;		/* ioremap'd register base */
++	struct clk	*clk;
++	unsigned	big_endian_mmio:1;
++	unsigned	big_endian_desc:1;
++	unsigned	es:1;		/* need USBMODE:ES */
++	unsigned	le_setup_buf:1;
++	unsigned	have_sysif_regs:1;
++	unsigned	invert_drvvbus:1;
++	unsigned	invert_pwr_fault:1;
+ };
+ 
+ /* Flags in fsl_usb2_mph_platform_data */
diff --git a/usb/usb-cdc-acm-fix-code-indentation.patch b/usb/usb-cdc-acm-fix-code-indentation.patch
new file mode 100644
index 00000000000000..a31d98c00522f2
--- /dev/null
+++ b/usb/usb-cdc-acm-fix-code-indentation.patch
@@ -0,0 +1,27 @@
+From otavio.salvador@gmail.com  Tue Oct  5 15:34:23 2010
+From: Otavio Salvador <otavio@ossystems.com.br>
+To: linux-kernel@vger.kernel.org
+Cc: Otavio Salvador <otavio@ossystems.com.br>,
+	Greg Kroah-Hartman <gregkh@suse.de>
+Subject: USB: cdc-acm: fix code indentation
+Date: Sun, 26 Sep 2010 23:35:05 -0300
+Message-Id: <1285554907-4495-2-git-send-email-otavio@ossystems.com.br>
+
+Signed-off-by: Otavio Salvador <otavio@ossystems.com.br>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/class/cdc-acm.c |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/drivers/usb/class/cdc-acm.c
++++ b/drivers/usb/class/cdc-acm.c
+@@ -1614,7 +1614,7 @@ static const struct usb_device_id acm_id
+ 	/* Support Lego NXT using pbLua firmware */
+ 	{ USB_DEVICE(0x0694, 0xff00),
+ 	.driver_info = NOT_A_MODEM,
+-       	},
++	},
+ 
+ 	/* control interfaces without any protocol set */
+ 	{ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
diff --git a/usb/usb-change-to-new-flag-variable.patch b/usb/usb-change-to-new-flag-variable.patch
new file mode 100644
index 00000000000000..41b859905c8fe8
--- /dev/null
+++ b/usb/usb-change-to-new-flag-variable.patch
@@ -0,0 +1,117 @@
+From mfm@muteddisk.com  Tue Oct  5 15:33:13 2010
+From: matt mooney <mfm@muteddisk.com>
+To: kernel-janitors@vger.kernel.org
+Cc: Greg Kroah-Hartman <gregkh@suse.de>,
+	David Brownell <dbrownell@users.sourceforge.net>,
+	Felipe Balbi <felipe.balbi@nokia.com>,
+	Matthew Dharm <mdharm-usb@one-eyed-alien.net>,
+	David Vrabel <david.vrabel@csr.com>, linux-usb@vger.kernel.org,
+	linux-kernel@vger.kernel.org, usb-storage@lists.one-eyed-alien.net
+Subject: usb: change to new flag variable
+Date: Fri, 24 Sep 2010 12:17:33 -0700
+Message-Id: <1dd0f4a1709a9b139fe87f2b311cc0d129900b3f.1285355033.git.mfm@muteddisk.com>
+
+Replace EXTRA_CFLAGS with ccflags-y.
+
+Signed-off-by: matt mooney <mfm@muteddisk.com>
+Acked-by: WANG Cong <xiyou.wangcong@gmail.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/atm/Makefile      |    4 +---
+ drivers/usb/core/Makefile     |    4 +---
+ drivers/usb/gadget/Makefile   |    4 +---
+ drivers/usb/host/Makefile     |    4 +---
+ drivers/usb/misc/Makefile     |    4 +---
+ drivers/usb/musb/Makefile     |    4 +---
+ drivers/usb/storage/Makefile  |    2 +-
+ drivers/usb/wusbcore/Makefile |    4 +---
+ 8 files changed, 8 insertions(+), 22 deletions(-)
+
+--- a/drivers/usb/atm/Makefile
++++ b/drivers/usb/atm/Makefile
+@@ -8,6 +8,4 @@ obj-$(CONFIG_USB_UEAGLEATM)	+= ueagle-at
+ obj-$(CONFIG_USB_ATM)		+= usbatm.o
+ obj-$(CONFIG_USB_XUSBATM)	+= xusbatm.o
+ 
+-ifeq ($(CONFIG_USB_DEBUG),y)
+-EXTRA_CFLAGS += -DDEBUG
+-endif
++ccflags-$(CONFIG_USB_DEBUG)	:= -DDEBUG
+--- a/drivers/usb/core/Makefile
++++ b/drivers/usb/core/Makefile
+@@ -16,6 +16,4 @@ endif
+ 
+ obj-$(CONFIG_USB)	+= usbcore.o
+ 
+-ifeq ($(CONFIG_USB_DEBUG),y)
+-EXTRA_CFLAGS += -DDEBUG
+-endif
++ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG
+--- a/drivers/usb/gadget/Makefile
++++ b/drivers/usb/gadget/Makefile
+@@ -1,9 +1,7 @@
+ #
+ # USB peripheral controller drivers
+ #
+-ifeq ($(CONFIG_USB_GADGET_DEBUG),y)
+-	EXTRA_CFLAGS		+= -DDEBUG
+-endif
++ccflags-$(CONFIG_USB_GADGET_DEBUG)	:= -DDEBUG
+ 
+ obj-$(CONFIG_USB_DUMMY_HCD)	+= dummy_hcd.o
+ obj-$(CONFIG_USB_NET2280)	+= net2280.o
+--- a/drivers/usb/host/Makefile
++++ b/drivers/usb/host/Makefile
+@@ -2,9 +2,7 @@
+ # Makefile for USB Host Controller Drivers
+ #
+ 
+-ifeq ($(CONFIG_USB_DEBUG),y)
+-	EXTRA_CFLAGS		+= -DDEBUG
+-endif
++ccflags-$(CONFIG_USB_DEBUG)	:= -DDEBUG
+ 
+ isp1760-objs := isp1760-hcd.o isp1760-if.o
+ fhci-objs := fhci-hcd.o fhci-hub.o fhci-q.o fhci-mem.o \
+--- a/drivers/usb/misc/Makefile
++++ b/drivers/usb/misc/Makefile
+@@ -26,6 +26,4 @@ obj-$(CONFIG_USB_YUREX)		+= yurex.o
+ 
+ obj-$(CONFIG_USB_SISUSBVGA)	+= sisusbvga/
+ 
+-ifeq ($(CONFIG_USB_DEBUG),y)
+-EXTRA_CFLAGS += -DDEBUG
+-endif
++ccflags-$(CONFIG_USB_DEBUG)	:= -DDEBUG
+--- a/drivers/usb/musb/Makefile
++++ b/drivers/usb/musb/Makefile
+@@ -78,6 +78,4 @@ endif
+ 
+ # Debugging
+ 
+-ifeq ($(CONFIG_USB_MUSB_DEBUG),y)
+-	EXTRA_CFLAGS += -DDEBUG
+-endif
++ccflags-$(CONFIG_USB_MUSB_DEBUG) := -DDEBUG
+--- a/drivers/usb/storage/Makefile
++++ b/drivers/usb/storage/Makefile
+@@ -5,7 +5,7 @@
+ # Rewritten to use lists instead of if-statements.
+ #
+ 
+-EXTRA_CFLAGS	:= -Idrivers/scsi
++ccflags-y	:= -Idrivers/scsi
+ 
+ obj-$(CONFIG_USB_UAS)		+= uas.o
+ obj-$(CONFIG_USB_STORAGE)	+= usb-storage.o
+--- a/drivers/usb/wusbcore/Makefile
++++ b/drivers/usb/wusbcore/Makefile
+@@ -21,6 +21,4 @@ wusb-wa-objs :=	wa-hc.o		\
+ 		wa-rpipe.o	\
+ 		wa-xfer.o
+ 
+-ifeq ($(CONFIG_USB_WUSB_CBAF_DEBUG),y)
+-EXTRA_CFLAGS += -DDEBUG
+-endif
++ccflags-$(CONFIG_USB_WUSB_CBAF_DEBUG) := -DDEBUG
diff --git a/usb/usb-disable-endpoints-after-unbinding-interfaces-not-before.patch b/usb/usb-disable-endpoints-after-unbinding-interfaces-not-before.patch
new file mode 100644
index 00000000000000..aa594cfb541299
--- /dev/null
+++ b/usb/usb-disable-endpoints-after-unbinding-interfaces-not-before.patch
@@ -0,0 +1,69 @@
+From linux-usb-owner@vger.kernel.org  Tue Oct  5 15:43:59 2010
+Date: Thu, 30 Sep 2010 15:16:23 -0400 (EDT)
+From: Alan Stern <stern@rowland.harvard.edu>
+To: Greg KH <greg@kroah.com>
+cc: Carsten Sommer <carsten_sommer@ymail.com>
+Subject: USB: disable endpoints after unbinding interfaces, not before
+Message-ID: <Pine.LNX.4.44L0.1009301514290.1314-100000@iolanthe.rowland.org>
+
+This patch (as1430) fixes a bug in usbcore.  When a device
+configuration change occurs or a device is removed, the endpoints for
+the old config should be completely disabled.  However it turns out
+they aren't; this is because usb_unbind_interface() calls
+usb_enable_interface() or usb_set_interface() to put interfaces back
+in altsetting 0, which re-enables the interfaces' endpoints.
+
+As a result, when a device goes through a config change or is
+unconfigured, the ep_in[] and ep_out[] arrays may be left holding old
+pointers to usb_host_endpoint structures.  If the device is
+deauthorized these structures get freed, and the stale pointers cause
+errors when the the device is eventually unplugged.
+
+The solution is to disable the endpoints after unbinding the
+interfaces instead of before.  This isn't as large a change as it
+sounds, since usb_unbind_interface() disables all the interface's
+endpoints anyway before calling the driver's disconnect routine,
+unless the driver claims to support "soft" unbind.
+
+This fixes Bugzilla #19192.  Thanks to "Tom" Lei Ming for diagnosing
+the underlying cause of the problem.
+
+Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
+Tested-by: Carsten Sommer <carsten_sommer@ymail.com>
+CC: stable <stable@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/core/message.c |   14 +++++++-------
+ 1 file changed, 7 insertions(+), 7 deletions(-)
+
+--- a/drivers/usb/core/message.c
++++ b/drivers/usb/core/message.c
+@@ -1140,13 +1140,6 @@ void usb_disable_device(struct usb_devic
+ {
+ 	int i;
+ 
+-	dev_dbg(&dev->dev, "%s nuking %s URBs\n", __func__,
+-		skip_ep0 ? "non-ep0" : "all");
+-	for (i = skip_ep0; i < 16; ++i) {
+-		usb_disable_endpoint(dev, i, true);
+-		usb_disable_endpoint(dev, i + USB_DIR_IN, true);
+-	}
+-
+ 	/* getting rid of interfaces will disconnect
+ 	 * any drivers bound to them (a key side effect)
+ 	 */
+@@ -1176,6 +1169,13 @@ void usb_disable_device(struct usb_devic
+ 		if (dev->state == USB_STATE_CONFIGURED)
+ 			usb_set_device_state(dev, USB_STATE_ADDRESS);
+ 	}
++
++	dev_dbg(&dev->dev, "%s nuking %s URBs\n", __func__,
++		skip_ep0 ? "non-ep0" : "all");
++	for (i = skip_ep0; i < 16; ++i) {
++		usb_disable_endpoint(dev, i, true);
++		usb_disable_endpoint(dev, i + USB_DIR_IN, true);
++	}
+ }
+ 
+ /**
diff --git a/usb/usb-gadget-don-t-save-bind-callback-in-struct-usb_gadget_driver.patch b/usb/usb-gadget-don-t-save-bind-callback-in-struct-usb_gadget_driver.patch
index f1c3666c64b9cb..78f7947c39c6fa 100644
--- a/usb/usb-gadget-don-t-save-bind-callback-in-struct-usb_gadget_driver.patch
+++ b/usb/usb-gadget-don-t-save-bind-callback-in-struct-usb_gadget_driver.patch
@@ -54,9 +54,9 @@ Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
  drivers/usb/gadget/r8a66597-udc.c   |    9 +++++----
  drivers/usb/gadget/s3c-hsotg.c      |    9 +++++----
  drivers/usb/gadget/s3c2410_udc.c    |   17 ++++++++---------
- drivers/usb/musb/musb_gadget.c      |    9 +++++----
+ drivers/usb/musb/musb_gadget.c      |   11 ++++++-----
  include/linux/usb/gadget.h          |   20 ++++++++------------
- 27 files changed, 127 insertions(+), 124 deletions(-)
+ 27 files changed, 128 insertions(+), 125 deletions(-)
 
 --- a/drivers/usb/gadget/amd5536udc.c
 +++ b/drivers/usb/gadget/amd5536udc.c
@@ -1012,6 +1012,15 @@ Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
  		if (retval != 0) {
  			DBG(3, "bind to driver %s failed --> %d\n",
  					driver->driver.name, retval);
+@@ -1786,7 +1787,7 @@ int usb_gadget_register_driver(struct us
+ 
+ 	return retval;
+ }
+-EXPORT_SYMBOL(usb_gadget_register_driver);
++EXPORT_SYMBOL(usb_gadget_probe_driver);
+ 
+ static void stop_activity(struct musb *musb, struct usb_gadget_driver *driver)
+ {
 --- a/include/linux/usb/gadget.h
 +++ b/include/linux/usb/gadget.h
 @@ -705,11 +705,6 @@ static inline int usb_gadget_disconnect(
diff --git a/usb/usb-imx21-hcd-accept-arbitary-transfer-buffer-alignement.patch b/usb/usb-imx21-hcd-accept-arbitary-transfer-buffer-alignement.patch
new file mode 100644
index 00000000000000..d2ec1eb74c239a
--- /dev/null
+++ b/usb/usb-imx21-hcd-accept-arbitary-transfer-buffer-alignement.patch
@@ -0,0 +1,452 @@
+From mfuzzey@gmail.com  Tue Oct  5 15:56:17 2010
+From: Martin Fuzzey <mfuzzey@gmail.com>
+Subject: USB: imx21-hcd accept arbitary transfer buffer alignement.
+To: Greg KH <greg@kroah.com>, linux-usb@vger.kernel.org
+Date: Fri, 01 Oct 2010 00:21:59 +0200
+Message-ID: <20100930222159.15137.87053.stgit@srv002.fuzzey.net>
+
+The hardware can only do DMA to 4 byte aligned addresses.
+When this requirement is not met use PIO or a bounce buffer.
+
+PIO is used when the buffer is small enough to directly
+use the hardware data memory (2*maxpacket).
+
+A bounce buffer is used for larger transfers.
+
+Signed-off-by: Martin Fuzzey <mfuzzey@gmail.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+
+---
+ drivers/usb/host/imx21-hcd.c |  196 +++++++++++++++++++++++++++++++++++--------
+ drivers/usb/host/imx21-hcd.h |    8 +
+ 2 files changed, 169 insertions(+), 35 deletions(-)
+
+--- a/drivers/usb/host/imx21-hcd.c
++++ b/drivers/usb/host/imx21-hcd.c
+@@ -57,6 +57,7 @@
+ #include <linux/slab.h>
+ #include <linux/usb.h>
+ #include <linux/usb/hcd.h>
++#include <linux/dma-mapping.h>
+ 
+ #include "imx21-hcd.h"
+ 
+@@ -136,9 +137,18 @@ static int imx21_hc_get_frame(struct usb
+ 	return wrap_frame(readl(imx21->regs + USBH_FRMNUB));
+ }
+ 
++static inline bool unsuitable_for_dma(dma_addr_t addr)
++{
++	return (addr & 3) != 0;
++}
+ 
+ #include "imx21-dbg.c"
+ 
++static void nonisoc_urb_completed_for_etd(
++	struct imx21 *imx21, struct etd_priv *etd, int status);
++static void schedule_nonisoc_etd(struct imx21 *imx21, struct urb *urb);
++static void free_dmem(struct imx21 *imx21, struct etd_priv *etd);
++
+ /* =========================================== */
+ /* ETD management				*/
+ /* ===========================================	*/
+@@ -185,7 +195,8 @@ static void reset_etd(struct imx21 *imx2
+ 		etd_writel(imx21, num, i, 0);
+ 	etd->urb = NULL;
+ 	etd->ep = NULL;
+-	etd->td = NULL;;
++	etd->td = NULL;
++	etd->bounce_buffer = NULL;
+ }
+ 
+ static void free_etd(struct imx21 *imx21, int num)
+@@ -221,26 +232,94 @@ static void setup_etd_dword0(struct imx2
+ 		((u32) maxpacket << DW0_MAXPKTSIZ));
+ }
+ 
+-static void activate_etd(struct imx21 *imx21,
+-	int etd_num, dma_addr_t dma, u8 dir)
++/**
++ * Copy buffer to data controller data memory.
++ * We cannot use memcpy_toio() because the hardware requires 32bit writes
++ */
++static void copy_to_dmem(
++	struct imx21 *imx21, int dmem_offset, void *src, int count)
++{
++	void __iomem *dmem = imx21->regs + USBOTG_DMEM + dmem_offset;
++	u32 word = 0;
++	u8 *p = src;
++	int byte = 0;
++	int i;
++
++	for (i = 0; i < count; i++) {
++		byte = i % 4;
++		word += (*p++ << (byte * 8));
++		if (byte == 3) {
++			writel(word, dmem);
++			dmem += 4;
++			word = 0;
++		}
++	}
++
++	if (count && byte != 3)
++		writel(word, dmem);
++}
++
++static void activate_etd(struct imx21 *imx21, int etd_num, u8 dir)
+ {
+ 	u32 etd_mask = 1 << etd_num;
+ 	struct etd_priv *etd = &imx21->etd[etd_num];
+ 
++	if (etd->dma_handle && unsuitable_for_dma(etd->dma_handle)) {
++		/* For non aligned isoc the condition below is always true */
++		if (etd->len <= etd->dmem_size) {
++			/* Fits into data memory, use PIO */
++			if (dir != TD_DIR_IN) {
++				copy_to_dmem(imx21,
++						etd->dmem_offset,
++						etd->cpu_buffer, etd->len);
++			}
++			etd->dma_handle = 0;
++
++		} else {
++			/* Too big for data memory, use bounce buffer */
++			enum dma_data_direction dmadir;
++
++			if (dir == TD_DIR_IN) {
++				dmadir = DMA_FROM_DEVICE;
++				etd->bounce_buffer = kmalloc(etd->len,
++								GFP_ATOMIC);
++			} else {
++				dmadir = DMA_TO_DEVICE;
++				etd->bounce_buffer = kmemdup(etd->cpu_buffer,
++								etd->len,
++								GFP_ATOMIC);
++			}
++			if (!etd->bounce_buffer) {
++				dev_err(imx21->dev, "failed bounce alloc\n");
++				goto err_bounce_alloc;
++			}
++
++			etd->dma_handle =
++				dma_map_single(imx21->dev,
++						etd->bounce_buffer,
++						etd->len,
++						dmadir);
++			if (dma_mapping_error(imx21->dev, etd->dma_handle)) {
++				dev_err(imx21->dev, "failed bounce map\n");
++				goto err_bounce_map;
++			}
++		}
++	}
++
+ 	clear_toggle_bit(imx21, USBH_ETDDONESTAT, etd_mask);
+ 	set_register_bits(imx21, USBH_ETDDONEEN, etd_mask);
+ 	clear_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
+ 	clear_toggle_bit(imx21, USBH_YFILLSTAT, etd_mask);
+ 
+-	if (dma) {
++	if (etd->dma_handle) {
+ 		set_register_bits(imx21, USB_ETDDMACHANLCLR, etd_mask);
+ 		clear_toggle_bit(imx21, USBH_XBUFSTAT, etd_mask);
+ 		clear_toggle_bit(imx21, USBH_YBUFSTAT, etd_mask);
+-		writel(dma, imx21->regs + USB_ETDSMSA(etd_num));
++		writel(etd->dma_handle, imx21->regs + USB_ETDSMSA(etd_num));
+ 		set_register_bits(imx21, USB_ETDDMAEN, etd_mask);
+ 	} else {
+ 		if (dir != TD_DIR_IN) {
+-			/* need to set for ZLP */
++			/* need to set for ZLP and PIO */
+ 			set_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
+ 			set_toggle_bit(imx21, USBH_YFILLSTAT, etd_mask);
+ 		}
+@@ -263,6 +342,14 @@ static void activate_etd(struct imx21 *i
+ 
+ 	etd->active_count = 1;
+ 	writel(etd_mask, imx21->regs + USBH_ETDENSET);
++	return;
++
++err_bounce_map:
++	kfree(etd->bounce_buffer);
++
++err_bounce_alloc:
++	free_dmem(imx21, etd);
++	nonisoc_urb_completed_for_etd(imx21, etd, -ENOMEM);
+ }
+ 
+ /* ===========================================	*/
+@@ -325,7 +412,7 @@ static void activate_queued_etd(struct i
+ 
+ 	etd->dmem_offset = dmem_offset;
+ 	urb_priv->active = 1;
+-	activate_etd(imx21, etd_num, etd->dma_handle, dir);
++	activate_etd(imx21, etd_num, dir);
+ }
+ 
+ static void free_dmem(struct imx21 *imx21, struct etd_priv *etd)
+@@ -385,7 +472,6 @@ static void free_epdmem(struct imx21 *im
+ /* ===========================================	*/
+ /* End handling 				*/
+ /* ===========================================	*/
+-static void schedule_nonisoc_etd(struct imx21 *imx21, struct urb *urb);
+ 
+ /* Endpoint now idle - release it's ETD(s) or asssign to queued request */
+ static void ep_idle(struct imx21 *imx21, struct ep_priv *ep_priv)
+@@ -448,6 +534,24 @@ __acquires(imx21->lock)
+ 		ep_idle(imx21, ep_priv);
+ }
+ 
++static void nonisoc_urb_completed_for_etd(
++	struct imx21 *imx21, struct etd_priv *etd, int status)
++{
++	struct usb_host_endpoint *ep = etd->ep;
++
++	urb_done(imx21->hcd, etd->urb, status);
++	etd->urb = NULL;
++
++	if (!list_empty(&ep->urb_list)) {
++		struct urb *urb = list_first_entry(
++					&ep->urb_list, struct urb, urb_list);
++
++		dev_vdbg(imx21->dev, "next URB %p\n", urb);
++		schedule_nonisoc_etd(imx21, urb);
++	}
++}
++
++
+ /* ===========================================	*/
+ /* ISOC Handling ... 				*/
+ /* ===========================================	*/
+@@ -500,6 +604,8 @@ too_late:
+ 		etd->ep = td->ep;
+ 		etd->urb = td->urb;
+ 		etd->len = td->len;
++		etd->dma_handle = td->dma_handle;
++		etd->cpu_buffer = td->cpu_buffer;
+ 
+ 		debug_isoc_submitted(imx21, cur_frame, td);
+ 
+@@ -513,16 +619,17 @@ too_late:
+ 			(TD_NOTACCESSED << DW3_COMPCODE0) |
+ 			(td->len << DW3_PKTLEN0));
+ 
+-		activate_etd(imx21, etd_num, td->data, dir);
++		activate_etd(imx21, etd_num, dir);
+ 	}
+ }
+ 
+-static void isoc_etd_done(struct usb_hcd *hcd, struct urb *urb, int etd_num)
++static void isoc_etd_done(struct usb_hcd *hcd, int etd_num)
+ {
+ 	struct imx21 *imx21 = hcd_to_imx21(hcd);
+ 	int etd_mask = 1 << etd_num;
+-	struct urb_priv *urb_priv = urb->hcpriv;
+ 	struct etd_priv *etd = imx21->etd + etd_num;
++	struct urb *urb = etd->urb;
++	struct urb_priv *urb_priv = urb->hcpriv;
+ 	struct td *td = etd->td;
+ 	struct usb_host_endpoint *ep = etd->ep;
+ 	int isoc_index = td->isoc_index;
+@@ -556,8 +663,13 @@ static void isoc_etd_done(struct usb_hcd
+ 			bytes_xfrd, td->len, urb, etd_num, isoc_index);
+ 	}
+ 
+-	if (dir_in)
++	if (dir_in) {
+ 		clear_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
++		if (!etd->dma_handle)
++			memcpy_fromio(etd->cpu_buffer,
++				imx21->regs + USBOTG_DMEM + etd->dmem_offset,
++				bytes_xfrd);
++	}
+ 
+ 	urb->actual_length += bytes_xfrd;
+ 	urb->iso_frame_desc[isoc_index].actual_length = bytes_xfrd;
+@@ -716,12 +828,14 @@ static int imx21_hc_urb_enqueue_isoc(str
+ 	/* set up transfers */
+ 	td = urb_priv->isoc_td;
+ 	for (i = 0; i < urb->number_of_packets; i++, td++) {
++		unsigned int offset = urb->iso_frame_desc[i].offset;
+ 		td->ep = ep;
+ 		td->urb = urb;
+ 		td->len = urb->iso_frame_desc[i].length;
+ 		td->isoc_index = i;
+ 		td->frame = wrap_frame(urb->start_frame + urb->interval * i);
+-		td->data = urb->transfer_dma + urb->iso_frame_desc[i].offset;
++		td->dma_handle = urb->transfer_dma + offset;
++		td->cpu_buffer = urb->transfer_buffer + offset;
+ 		list_add_tail(&td->list, &ep_priv->td_list);
+ 	}
+ 
+@@ -812,13 +926,15 @@ static void schedule_nonisoc_etd(struct
+ 	if (usb_pipecontrol(pipe) && (state != US_CTRL_DATA)) {
+ 		if (state == US_CTRL_SETUP) {
+ 			dir = TD_DIR_SETUP;
++			if (unsuitable_for_dma(urb->setup_dma))
++				unmap_urb_setup_for_dma(imx21->hcd, urb);
+ 			etd->dma_handle = urb->setup_dma;
++			etd->cpu_buffer = urb->setup_packet;
+ 			bufround = 0;
+ 			count = 8;
+ 			datatoggle = TD_TOGGLE_DATA0;
+ 		} else {	/* US_CTRL_ACK */
+ 			dir = usb_pipeout(pipe) ? TD_DIR_IN : TD_DIR_OUT;
+-			etd->dma_handle = urb->transfer_dma;
+ 			bufround = 0;
+ 			count = 0;
+ 			datatoggle = TD_TOGGLE_DATA1;
+@@ -826,7 +942,11 @@ static void schedule_nonisoc_etd(struct
+ 	} else {
+ 		dir = usb_pipeout(pipe) ? TD_DIR_OUT : TD_DIR_IN;
+ 		bufround = (dir == TD_DIR_IN) ? 1 : 0;
++		if (unsuitable_for_dma(urb->transfer_dma))
++			unmap_urb_for_dma(imx21->hcd, urb);
++
+ 		etd->dma_handle = urb->transfer_dma;
++		etd->cpu_buffer = urb->transfer_buffer;
+ 		if (usb_pipebulk(pipe) && (state == US_BULK0))
+ 			count = 0;
+ 		else
+@@ -901,14 +1021,15 @@ static void schedule_nonisoc_etd(struct
+ 	/* enable the ETD to kick off transfer */
+ 	dev_vdbg(imx21->dev, "Activating etd %d for %d bytes %s\n",
+ 		etd_num, count, dir != TD_DIR_IN ? "out" : "in");
+-	activate_etd(imx21, etd_num, etd->dma_handle, dir);
++	activate_etd(imx21, etd_num, dir);
+ 
+ }
+ 
+-static void nonisoc_etd_done(struct usb_hcd *hcd, struct urb *urb, int etd_num)
++static void nonisoc_etd_done(struct usb_hcd *hcd, int etd_num)
+ {
+ 	struct imx21 *imx21 = hcd_to_imx21(hcd);
+ 	struct etd_priv *etd = &imx21->etd[etd_num];
++	struct urb *urb = etd->urb;
+ 	u32 etd_mask = 1 << etd_num;
+ 	struct urb_priv *urb_priv = urb->hcpriv;
+ 	int dir;
+@@ -930,7 +1051,20 @@ static void nonisoc_etd_done(struct usb_
+ 	if (dir == TD_DIR_IN) {
+ 		clear_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
+ 		clear_toggle_bit(imx21, USBH_YFILLSTAT, etd_mask);
++
++		if (etd->bounce_buffer) {
++			memcpy(etd->cpu_buffer, etd->bounce_buffer, bytes_xfrd);
++			dma_unmap_single(imx21->dev,
++				etd->dma_handle, etd->len, DMA_FROM_DEVICE);
++		} else if (!etd->dma_handle && bytes_xfrd) {/* PIO */
++			memcpy_fromio(etd->cpu_buffer,
++				imx21->regs + USBOTG_DMEM + etd->dmem_offset,
++				bytes_xfrd);
++		}
+ 	}
++
++	kfree(etd->bounce_buffer);
++	etd->bounce_buffer = NULL;
+ 	free_dmem(imx21, etd);
+ 
+ 	urb->error_count = 0;
+@@ -988,24 +1122,15 @@ static void nonisoc_etd_done(struct usb_
+ 		break;
+ 	}
+ 
+-	if (!etd_done) {
++	if (etd_done)
++		nonisoc_urb_completed_for_etd(imx21, etd, cc_to_error[cc]);
++	else {
+ 		dev_vdbg(imx21->dev, "next state=%d\n", urb_priv->state);
+ 		schedule_nonisoc_etd(imx21, urb);
+-	} else {
+-		struct usb_host_endpoint *ep = urb->ep;
+-
+-		urb_done(hcd, urb, cc_to_error[cc]);
+-		etd->urb = NULL;
+-
+-		if (!list_empty(&ep->urb_list)) {
+-			urb = list_first_entry(&ep->urb_list,
+-				struct urb, urb_list);
+-			dev_vdbg(imx21->dev, "next URB %p\n", urb);
+-			schedule_nonisoc_etd(imx21, urb);
+-		}
+ 	}
+ }
+ 
++
+ static struct ep_priv *alloc_ep(void)
+ {
+ 	int i;
+@@ -1146,9 +1271,13 @@ static int imx21_hc_urb_dequeue(struct u
+ 	} else if (urb_priv->active) {
+ 		int etd_num = ep_priv->etd[0];
+ 		if (etd_num != -1) {
++			struct etd_priv *etd = &imx21->etd[etd_num];
++
+ 			disactivate_etd(imx21, etd_num);
+-			free_dmem(imx21, &imx21->etd[etd_num]);
+-			imx21->etd[etd_num].urb = NULL;
++			free_dmem(imx21, etd);
++			etd->urb = NULL;
++			kfree(etd->bounce_buffer);
++			etd->bounce_buffer = NULL;
+ 		}
+ 	}
+ 
+@@ -1248,9 +1377,9 @@ static void process_etds(struct usb_hcd
+ 		}
+ 
+ 		if (usb_pipeisoc(etd->urb->pipe))
+-			isoc_etd_done(hcd, etd->urb, etd_num);
++			isoc_etd_done(hcd, etd_num);
+ 		else
+-			nonisoc_etd_done(hcd, etd->urb, etd_num);
++			nonisoc_etd_done(hcd, etd_num);
+ 	}
+ 
+ 	/* only enable SOF interrupt if it may be needed for the kludge */
+@@ -1718,6 +1847,7 @@ static int imx21_probe(struct platform_d
+ 	}
+ 
+ 	imx21 = hcd_to_imx21(hcd);
++	imx21->hcd = hcd;
+ 	imx21->dev = &pdev->dev;
+ 	imx21->pdata = pdev->dev.platform_data;
+ 	if (!imx21->pdata)
+--- a/drivers/usb/host/imx21-hcd.h
++++ b/drivers/usb/host/imx21-hcd.h
+@@ -250,6 +250,7 @@
+ #define USBCTRL_USB_BYP			(1 << 2)
+ #define USBCTRL_HOST1_TXEN_OE		(1 << 1)
+ 
++#define USBOTG_DMEM		0x1000
+ 
+ /* Values in TD blocks */
+ #define TD_DIR_SETUP	    0
+@@ -346,8 +347,8 @@ struct td {
+ 	struct list_head list;
+ 	struct urb *urb;
+ 	struct usb_host_endpoint *ep;
+-	dma_addr_t data;
+-	unsigned long buf_addr;
++	dma_addr_t dma_handle;
++	void *cpu_buffer;
+ 	int len;
+ 	int frame;
+ 	int isoc_index;
+@@ -360,6 +361,8 @@ struct etd_priv {
+ 	struct td *td;
+ 	struct list_head queue;
+ 	dma_addr_t dma_handle;
++	void *cpu_buffer;
++	void *bounce_buffer;
+ 	int alloc;
+ 	int len;
+ 	int dmem_size;
+@@ -412,6 +415,7 @@ struct debug_isoc_trace {
+ struct imx21 {
+ 	spinlock_t lock;
+ 	struct device *dev;
++	struct usb_hcd *hcd;
+ 	struct mx21_usbh_platform_data *pdata;
+ 	struct list_head dmem_list;
+ 	struct list_head queue_for_etd; /* eps queued due to etd shortage */
diff --git a/usb/usb-imx21-hcd-fix-isochronous-endpoint-idle.patch b/usb/usb-imx21-hcd-fix-isochronous-endpoint-idle.patch
new file mode 100644
index 00000000000000..d525e66f666967
--- /dev/null
+++ b/usb/usb-imx21-hcd-fix-isochronous-endpoint-idle.patch
@@ -0,0 +1,125 @@
+From mfuzzey@gmail.com  Tue Oct  5 15:54:46 2010
+From: Martin Fuzzey <mfuzzey@gmail.com>
+Subject: USB: imx21-hcd: Fix isochronous endpoint idle
+To: Greg KH <greg@kroah.com>, linux-usb@vger.kernel.org
+Date: Fri, 01 Oct 2010 00:21:48 +0200
+Message-ID: <20100930222148.15137.25994.stgit@srv002.fuzzey.net>
+
+Release the hardware resources and reset the internal HCD state
+associated with an isochronous endpoint when the last URB queued
+for it completes.
+
+Previously this was only done in then endpoint_disable() method
+causing usbtest 15 and 16 to hang when run twice in succession
+without a disconnect.
+
+Signed-off-by: Martin Fuzzey <mfuzzey@gmail.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+
+---
+ drivers/usb/host/imx21-hcd.c |   56 +++++++++++++++++++++++++++++--------------
+ 1 file changed, 39 insertions(+), 17 deletions(-)
+
+--- a/drivers/usb/host/imx21-hcd.c
++++ b/drivers/usb/host/imx21-hcd.c
+@@ -390,15 +390,19 @@ static void schedule_nonisoc_etd(struct
+ /* Endpoint now idle - release it's ETD(s) or asssign to queued request */
+ static void ep_idle(struct imx21 *imx21, struct ep_priv *ep_priv)
+ {
+-	int etd_num;
+ 	int i;
+ 
+ 	for (i = 0; i < NUM_ISO_ETDS; i++) {
+-		etd_num = ep_priv->etd[i];
++		int etd_num = ep_priv->etd[i];
++		struct etd_priv *etd;
+ 		if (etd_num < 0)
+ 			continue;
+ 
++		etd = &imx21->etd[etd_num];
+ 		ep_priv->etd[i] = -1;
++
++		free_dmem(imx21, etd); /* for isoc */
++
+ 		if (list_empty(&imx21->queue_for_etd)) {
+ 			free_etd(imx21, etd_num);
+ 			continue;
+@@ -576,30 +580,43 @@ static struct ep_priv *alloc_isoc_ep(
+ 	int i;
+ 
+ 	ep_priv = kzalloc(sizeof(struct ep_priv), GFP_ATOMIC);
+-	if (ep_priv == NULL)
++	if (!ep_priv)
+ 		return NULL;
+ 
+-	/* Allocate the ETDs */
+-	for (i = 0; i < NUM_ISO_ETDS; i++) {
+-		ep_priv->etd[i] = alloc_etd(imx21);
+-		if (ep_priv->etd[i] < 0) {
+-			int j;
+-			dev_err(imx21->dev, "isoc: Couldn't allocate etd\n");
+-			for (j = 0; j < i; j++)
+-				free_etd(imx21, ep_priv->etd[j]);
+-			goto alloc_etd_failed;
+-		}
+-		imx21->etd[ep_priv->etd[i]].ep = ep;
+-	}
++	for (i = 0; i < NUM_ISO_ETDS; i++)
++		ep_priv->etd[i] = -1;
+ 
+ 	INIT_LIST_HEAD(&ep_priv->td_list);
+ 	ep_priv->ep = ep;
+ 	ep->hcpriv = ep_priv;
+ 	return ep_priv;
++}
++
++static int alloc_isoc_etds(struct imx21 *imx21, struct ep_priv *ep_priv)
++{
++	int i, j;
++	int etd_num;
++
++	/* Allocate the ETDs if required */
++	for (i = 0; i < NUM_ISO_ETDS; i++) {
++		if (ep_priv->etd[i] < 0) {
++			etd_num = alloc_etd(imx21);
++			if (etd_num < 0)
++				goto alloc_etd_failed;
++
++			ep_priv->etd[i] = etd_num;
++			imx21->etd[etd_num].ep = ep_priv->ep;
++		}
++	}
++	return 0;
+ 
+ alloc_etd_failed:
+-	kfree(ep_priv);
+-	return NULL;
++	dev_err(imx21->dev, "isoc: Couldn't allocate etd\n");
++	for (j = 0; j < i; j++) {
++		free_etd(imx21, ep_priv->etd[j]);
++		ep_priv->etd[j] = -1;
++	}
++	return -ENOMEM;
+ }
+ 
+ static int imx21_hc_urb_enqueue_isoc(struct usb_hcd *hcd,
+@@ -639,6 +656,10 @@ static int imx21_hc_urb_enqueue_isoc(str
+ 		ep_priv = ep->hcpriv;
+ 	}
+ 
++	ret = alloc_isoc_etds(imx21, ep_priv);
++	if (ret)
++		goto alloc_etd_failed;
++
+ 	ret = usb_hcd_link_urb_to_ep(hcd, urb);
+ 	if (ret)
+ 		goto link_failed;
+@@ -718,6 +739,7 @@ alloc_dmem_failed:
+ 	usb_hcd_unlink_urb_from_ep(hcd, urb);
+ 
+ link_failed:
++alloc_etd_failed:
+ alloc_ep_failed:
+ 	spin_unlock_irqrestore(&imx21->lock, flags);
+ 	kfree(urb_priv->isoc_td);
diff --git a/usb/usb-imx21-hcd-refactor-hardware-data-memory-management.patch b/usb/usb-imx21-hcd-refactor-hardware-data-memory-management.patch
new file mode 100644
index 00000000000000..3e244cbbfeef06
--- /dev/null
+++ b/usb/usb-imx21-hcd-refactor-hardware-data-memory-management.patch
@@ -0,0 +1,123 @@
+From linux-usb-owner@vger.kernel.org  Tue Oct  5 15:54:36 2010
+From: Martin Fuzzey <mfuzzey@gmail.com>
+Subject: USB: imx21-hcd: refactor hardware data memory management
+To: Greg KH <greg@kroah.com>, linux-usb@vger.kernel.org
+Date: Fri, 01 Oct 2010 00:21:43 +0200
+Message-ID: <20100930222143.15137.49718.stgit@srv002.fuzzey.net>
+
+We already have fields describing the hardware data memory
+(dmem_size and dmem_offset) in the HCD private data,
+use them rather than the rather obscure read from the
+hardware descriptor.
+
+Signed-off-by: Martin Fuzzey <mfuzzey@gmail.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+
+---
+ drivers/usb/host/imx21-hcd.c |   30 ++++++++++++++++--------------
+ 1 file changed, 16 insertions(+), 14 deletions(-)
+
+--- a/drivers/usb/host/imx21-hcd.c
++++ b/drivers/usb/host/imx21-hcd.c
+@@ -323,16 +323,23 @@ static void activate_queued_etd(struct i
+ 	etd_writel(imx21, etd_num, 1,
+ 	    ((dmem_offset + maxpacket) << DW1_YBUFSRTAD) | dmem_offset);
+ 
++	etd->dmem_offset = dmem_offset;
+ 	urb_priv->active = 1;
+ 	activate_etd(imx21, etd_num, etd->dma_handle, dir);
+ }
+ 
+-static void free_dmem(struct imx21 *imx21, int offset)
++static void free_dmem(struct imx21 *imx21, struct etd_priv *etd)
+ {
+ 	struct imx21_dmem_area *area;
+-	struct etd_priv *etd, *tmp;
++	struct etd_priv *tmp;
+ 	int found = 0;
++	int offset;
+ 
++	if (!etd->dmem_size)
++		return;
++	etd->dmem_size = 0;
++
++	offset = etd->dmem_offset;
+ 	list_for_each_entry(area, &imx21->dmem_list, list) {
+ 		if (area->offset == offset) {
+ 			debug_dmem_freed(imx21, area->size);
+@@ -734,9 +741,7 @@ static void dequeue_isoc_urb(struct imx2
+ 				struct etd_priv *etd = imx21->etd + etd_num;
+ 
+ 				reset_etd(imx21, etd_num);
+-				if (etd->dmem_size)
+-					free_dmem(imx21, etd->dmem_offset);
+-				etd->dmem_size = 0;
++				free_dmem(imx21, etd);
+ 			}
+ 		}
+ 	}
+@@ -761,7 +766,6 @@ static void schedule_nonisoc_etd(struct
+ 	int state = urb_priv->state;
+ 	int etd_num = ep_priv->etd[0];
+ 	struct etd_priv *etd;
+-	int dmem_offset;
+ 	u32 count;
+ 	u16 etd_buf_size;
+ 	u16 maxpacket;
+@@ -855,8 +859,8 @@ static void schedule_nonisoc_etd(struct
+ 
+ 	/* allocate x and y buffer space at once */
+ 	etd->dmem_size = (count > maxpacket) ? maxpacket * 2 : maxpacket;
+-	dmem_offset = alloc_dmem(imx21, etd->dmem_size, urb_priv->ep);
+-	if (dmem_offset < 0) {
++	etd->dmem_offset = alloc_dmem(imx21, etd->dmem_size, urb_priv->ep);
++	if (etd->dmem_offset < 0) {
+ 		/* Setup everything we can in HW and update when we get DMEM */
+ 		etd_writel(imx21, etd_num, 1, (u32)maxpacket << 16);
+ 
+@@ -867,8 +871,8 @@ static void schedule_nonisoc_etd(struct
+ 	}
+ 
+ 	etd_writel(imx21, etd_num, 1,
+-		(((u32) dmem_offset + (u32) maxpacket) << DW1_YBUFSRTAD) |
+-		(u32) dmem_offset);
++		(((u32) etd->dmem_offset + (u32) maxpacket) << DW1_YBUFSRTAD) |
++		(u32) etd->dmem_offset);
+ 
+ 	urb_priv->active = 1;
+ 
+@@ -886,7 +890,6 @@ static void nonisoc_etd_done(struct usb_
+ 	u32 etd_mask = 1 << etd_num;
+ 	struct urb_priv *urb_priv = urb->hcpriv;
+ 	int dir;
+-	u16 xbufaddr;
+ 	int cc;
+ 	u32 bytes_xfrd;
+ 	int etd_done;
+@@ -894,7 +897,6 @@ static void nonisoc_etd_done(struct usb_
+ 	disactivate_etd(imx21, etd_num);
+ 
+ 	dir = (etd_readl(imx21, etd_num, 0) >> DW0_DIRECT) & 0x3;
+-	xbufaddr = etd_readl(imx21, etd_num, 1) & 0xffff;
+ 	cc = (etd_readl(imx21, etd_num, 2) >> DW2_COMPCODE) & 0xf;
+ 	bytes_xfrd = etd->len - (etd_readl(imx21, etd_num, 3) & 0x1fffff);
+ 
+@@ -907,7 +909,7 @@ static void nonisoc_etd_done(struct usb_
+ 		clear_toggle_bit(imx21, USBH_XFILLSTAT, etd_mask);
+ 		clear_toggle_bit(imx21, USBH_YFILLSTAT, etd_mask);
+ 	}
+-	free_dmem(imx21, xbufaddr);
++	free_dmem(imx21, etd);
+ 
+ 	urb->error_count = 0;
+ 	if (!(urb->transfer_flags & URB_SHORT_NOT_OK)
+@@ -1123,7 +1125,7 @@ static int imx21_hc_urb_dequeue(struct u
+ 		int etd_num = ep_priv->etd[0];
+ 		if (etd_num != -1) {
+ 			disactivate_etd(imx21, etd_num);
+-			free_dmem(imx21, etd_readl(imx21, etd_num, 1) & 0xffff);
++			free_dmem(imx21, &imx21->etd[etd_num]);
+ 			imx21->etd[etd_num].urb = NULL;
+ 		}
+ 	}
diff --git a/usb/usb-imx21-hcd-remove-unused-variable.patch b/usb/usb-imx21-hcd-remove-unused-variable.patch
new file mode 100644
index 00000000000000..ff2eec74d19a35
--- /dev/null
+++ b/usb/usb-imx21-hcd-remove-unused-variable.patch
@@ -0,0 +1,34 @@
+From mfuzzey@gmail.com  Tue Oct  5 15:54:25 2010
+From: Martin Fuzzey <mfuzzey@gmail.com>
+Subject: USB: imx21-hcd: remove unused variable
+To: Greg KH <greg@kroah.com>, linux-usb@vger.kernel.org
+Date: Fri, 01 Oct 2010 00:21:38 +0200
+Message-ID: <20100930222138.15137.95743.stgit@srv002.fuzzey.net>
+
+Remove a local variable left over from some debugging code.
+
+Signed-off-by: Martin Fuzzey <mfuzzey@gmail.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/host/imx21-hcd.c |    2 --
+ 1 file changed, 2 deletions(-)
+
+--- a/drivers/usb/host/imx21-hcd.c
++++ b/drivers/usb/host/imx21-hcd.c
+@@ -1007,7 +1007,6 @@ static int imx21_hc_urb_enqueue(struct u
+ 	struct etd_priv *etd;
+ 	int ret;
+ 	unsigned long flags;
+-	int new_ep = 0;
+ 
+ 	dev_vdbg(imx21->dev,
+ 		"enqueue urb=%p ep=%p len=%d "
+@@ -1035,7 +1034,6 @@ static int imx21_hc_urb_enqueue(struct u
+ 		}
+ 		ep->hcpriv = ep_priv;
+ 		ep_priv->ep = ep;
+-		new_ep = 1;
+ 	}
+ 
+ 	ret = usb_hcd_link_urb_to_ep(hcd, urb);
diff --git a/usb/usb-introduce-unmap_urb_setup_for_dma.patch b/usb/usb-introduce-unmap_urb_setup_for_dma.patch
new file mode 100644
index 00000000000000..0aea3b2345a8bd
--- /dev/null
+++ b/usb/usb-introduce-unmap_urb_setup_for_dma.patch
@@ -0,0 +1,71 @@
+From mfuzzey@gmail.com  Tue Oct  5 15:55:53 2010
+From: Martin Fuzzey <mfuzzey@gmail.com>
+Subject: USB: introduce unmap_urb_setup_for_dma()
+To: Greg KH <greg@kroah.com>, linux-usb@vger.kernel.org
+Date: Fri, 01 Oct 2010 00:21:55 +0200
+Message-ID: <20100930222154.15137.36039.stgit@srv002.fuzzey.net>
+
+Split unmap_urb_for_dma() to allow just the setup buffer
+to be unmapped. This allows HCDs to use PIO for the setup
+buffer if it is not suitable for DMA.
+
+Signed-off-by: Martin Fuzzey <mfuzzey@gmail.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/core/hcd.c  |   18 +++++++++++++-----
+ include/linux/usb/hcd.h |    1 +
+ 2 files changed, 14 insertions(+), 5 deletions(-)
+
+--- a/drivers/usb/core/hcd.c
++++ b/drivers/usb/core/hcd.c
+@@ -1263,10 +1263,8 @@ static void hcd_free_coherent(struct usb
+ 	*dma_handle = 0;
+ }
+ 
+-void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
++void unmap_urb_setup_for_dma(struct usb_hcd *hcd, struct urb *urb)
+ {
+-	enum dma_data_direction dir;
+-
+ 	if (urb->transfer_flags & URB_SETUP_MAP_SINGLE)
+ 		dma_unmap_single(hcd->self.controller,
+ 				urb->setup_dma,
+@@ -1279,6 +1277,17 @@ void unmap_urb_for_dma(struct usb_hcd *h
+ 				sizeof(struct usb_ctrlrequest),
+ 				DMA_TO_DEVICE);
+ 
++	/* Make it safe to call this routine more than once */
++	urb->transfer_flags &= ~(URB_SETUP_MAP_SINGLE | URB_SETUP_MAP_LOCAL);
++}
++EXPORT_SYMBOL_GPL(unmap_urb_setup_for_dma);
++
++void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
++{
++	enum dma_data_direction dir;
++
++	unmap_urb_setup_for_dma(hcd, urb);
++
+ 	dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
+ 	if (urb->transfer_flags & URB_DMA_MAP_SG)
+ 		dma_unmap_sg(hcd->self.controller,
+@@ -1303,8 +1312,7 @@ void unmap_urb_for_dma(struct usb_hcd *h
+ 				dir);
+ 
+ 	/* Make it safe to call this routine more than once */
+-	urb->transfer_flags &= ~(URB_SETUP_MAP_SINGLE | URB_SETUP_MAP_LOCAL |
+-			URB_DMA_MAP_SG | URB_DMA_MAP_PAGE |
++	urb->transfer_flags &= ~(URB_DMA_MAP_SG | URB_DMA_MAP_PAGE |
+ 			URB_DMA_MAP_SINGLE | URB_MAP_LOCAL);
+ }
+ EXPORT_SYMBOL_GPL(unmap_urb_for_dma);
+--- a/include/linux/usb/hcd.h
++++ b/include/linux/usb/hcd.h
+@@ -329,6 +329,7 @@ extern int usb_hcd_submit_urb(struct urb
+ extern int usb_hcd_unlink_urb(struct urb *urb, int status);
+ extern void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb,
+ 		int status);
++extern void unmap_urb_setup_for_dma(struct usb_hcd *, struct urb *);
+ extern void unmap_urb_for_dma(struct usb_hcd *, struct urb *);
+ extern void usb_hcd_flush_endpoint(struct usb_device *udev,
+ 		struct usb_host_endpoint *ep);
diff --git a/usb/usb-langwell_udc-cancel-pending-requests-when-controller-is-suspended.patch b/usb/usb-langwell_udc-cancel-pending-requests-when-controller-is-suspended.patch
new file mode 100644
index 00000000000000..703e22b3d5eec6
--- /dev/null
+++ b/usb/usb-langwell_udc-cancel-pending-requests-when-controller-is-suspended.patch
@@ -0,0 +1,36 @@
+From linux-usb-owner@vger.kernel.org  Tue Oct  5 15:58:49 2010
+From: Alan Cox <alan@linux.intel.com>
+Subject: usb: langwell_udc: cancel pending requests when controller is suspended.
+To: linux-usb@vger.kernel.org
+Date: Fri, 01 Oct 2010 14:59:16 +0100
+Message-ID: <20101001135915.24212.57542.stgit@localhost.localdomain>
+
+From: Philippe Skowronski <philippe.skowronski@intel.com>
+
+It is safer to cancel pending requests before free dTD and dQH when
+controller enters suspend state.
+
+Signed-off-by: Philippe Skowronski <philippe.skowronski@intel.com>
+Signed-off-by: Hao Wu <hao.wu@intel.com>
+[Switch to spin_lock_irq as suggested by Alan Stern]
+Signed-off-by: Alan Cox <alan@linux.intel.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/gadget/langwell_udc.c |    5 +++++
+ 1 file changed, 5 insertions(+)
+
+--- a/drivers/usb/gadget/langwell_udc.c
++++ b/drivers/usb/gadget/langwell_udc.c
+@@ -3391,6 +3391,11 @@ static int langwell_udc_suspend(struct p
+ 	/* save PCI state */
+ 	pci_save_state(pdev);
+ 
++	spin_lock_irq(&dev->lock);
++	/* stop all usb activities */
++	stop_activity(dev, dev->driver);
++	spin_unlock_irq(&dev->lock);
++
+ 	/* free dTD dma_pool and dQH */
+ 	if (dev->dtd_pool)
+ 		dma_pool_destroy(dev->dtd_pool);
diff --git a/usb/usb-langwell_udc-fix-big-file-transfer-issue.patch b/usb/usb-langwell_udc-fix-big-file-transfer-issue.patch
new file mode 100644
index 00000000000000..cad44f75e780eb
--- /dev/null
+++ b/usb/usb-langwell_udc-fix-big-file-transfer-issue.patch
@@ -0,0 +1,40 @@
+From linux-usb-owner@vger.kernel.org  Tue Oct  5 15:43:16 2010
+From: Christophe Lebouc <christophex.lebouc@intel.com>
+Subject: usb: langwell_udc: fix big file transfer issue.
+To: linux-usb@vger.kernel.org
+Date: Thu, 30 Sep 2010 15:34:36 +0100
+Message-ID: <20100930143428.6994.79214.stgit@localhost.localdomain>
+
+From: Christophe Lebouc <christophex.lebouc@intel.com>
+
+This patch fixing the problem with large file transfers failing. Swap the read
+order to avoid unexpected RX status.
+
+Signed-off-by: Christophe Lebouc <christophex.lebouc@intel.com>
+Signed-off-by: Hao Wu <hao.wu@intel.com>
+Signed-off-by: Alan Cox <alan@linux.intel.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/gadget/langwell_udc.c |    6 ++++--
+ 1 file changed, 4 insertions(+), 2 deletions(-)
+
+--- a/drivers/usb/gadget/langwell_udc.c
++++ b/drivers/usb/gadget/langwell_udc.c
+@@ -2440,12 +2440,14 @@ static int process_ep_req(struct langwel
+ 	dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
+ 
+ 	for (i = 0; i < curr_req->dtd_count; i++) {
+-		remaining_length = le16_to_cpu(curr_dtd->dtd_total);
+-		actual -= remaining_length;
+ 
+ 		/* command execution states by dTD */
+ 		dtd_status = curr_dtd->dtd_status;
+ 
++		barrier();
++		remaining_length = le16_to_cpu(curr_dtd->dtd_total);
++		actual -= remaining_length;
++
+ 		if (!dtd_status) {
+ 			/* transfers completed successfully */
+ 			if (!remaining_length) {
diff --git a/usb/usb-musb-blackfin-call-gpio_free-on-error-path-in-musb_platform_init.patch b/usb/usb-musb-blackfin-call-gpio_free-on-error-path-in-musb_platform_init.patch
new file mode 100644
index 00000000000000..b73dfc37ca0998
--- /dev/null
+++ b/usb/usb-musb-blackfin-call-gpio_free-on-error-path-in-musb_platform_init.patch
@@ -0,0 +1,38 @@
+From linux-usb-owner@vger.kernel.org  Tue Oct  5 15:38:49 2010
+From: Felipe Balbi <balbi@ti.com>
+To: Greg KH <greg@kroah.com>
+Cc: Sergei Shtylyov <sshtylyov@ru.mvista.com>,
+	Felipe Balbi <balbi@ti.com>
+Subject: usb: musb: blackfin: call gpio_free() on error path in musb_platform_init()
+Date: Wed, 29 Sep 2010 09:54:31 +0300
+Message-Id: <1285743271-21654-4-git-send-email-balbi@ti.com>
+
+From: Sergei Shtylyov <sshtylyov@ru.mvista.com>
+
+Blackfin's musb_platform_init() needs to call gpio_free() for error cleanup iff
+otg_get_transceiver() call returns NULL.
+
+Signed-off-by: Sergei Shtylyov <sshtylyov@ru.mvista.com>
+Acked-by: Mike Frysinger <vapier@gentoo.org>
+Signed-off-by: Felipe Balbi <balbi@ti.com>
+Cc: stable <stable@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/musb/blackfin.c |    4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+--- a/drivers/usb/musb/blackfin.c
++++ b/drivers/usb/musb/blackfin.c
+@@ -342,8 +342,10 @@ int __init musb_platform_init(struct mus
+ 
+ 	usb_nop_xceiv_register();
+ 	musb->xceiv = otg_get_transceiver();
+-	if (!musb->xceiv)
++	if (!musb->xceiv) {
++		gpio_free(musb->config->gpio_vrsel);
+ 		return -ENODEV;
++	}
+ 
+ 	if (ANOMALY_05000346) {
+ 		bfin_write_USB_APHY_CALIB(ANOMALY_05000346_value);
diff --git a/usb/usb-musb-blackfin-call-usb_nop_xceiv_unregister-in-musb_platform_exit.patch b/usb/usb-musb-blackfin-call-usb_nop_xceiv_unregister-in-musb_platform_exit.patch
new file mode 100644
index 00000000000000..1822d881a287bd
--- /dev/null
+++ b/usb/usb-musb-blackfin-call-usb_nop_xceiv_unregister-in-musb_platform_exit.patch
@@ -0,0 +1,37 @@
+From balbi@ti.com  Tue Oct  5 15:38:30 2010
+From: Felipe Balbi <balbi@ti.com>
+To: Greg KH <greg@kroah.com>
+Cc: Sergei Shtylyov <sshtylyov@ru.mvista.com>, stable@kernel.org,
+        Felipe Balbi <balbi@ti.com>
+Subject: usb: musb: blackfin: call usb_nop_xceiv_unregister() in musb_platform_exit()
+Date: Wed, 29 Sep 2010 09:54:30 +0300
+Message-Id: <1285743271-21654-3-git-send-email-balbi@ti.com>
+
+From: Sergei Shtylyov <sshtylyov@ru.mvista.com>
+
+Blackfin's musb_platform_exit() forgets to call usb_nop_xceiv_unregister().
+While fixing this, also remove the unneeded blank line there.
+
+Signed-off-by: Sergei Shtylyov <sshtylyov@ru.mvista.com>
+Acked-by: Mike Frysinger <vapier@gentoo.org>
+Cc: stable <stable@kernel.org>
+Signed-off-by: Felipe Balbi <balbi@ti.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/musb/blackfin.c |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/drivers/usb/musb/blackfin.c
++++ b/drivers/usb/musb/blackfin.c
+@@ -394,9 +394,9 @@ int __init musb_platform_init(struct mus
+ 
+ int musb_platform_exit(struct musb *musb)
+ {
+-
+ 	gpio_free(musb->config->gpio_vrsel);
+ 
+ 	otg_put_transceiver(musb->xceiv);
++	usb_nop_xceiv_unregister();
+ 	return 0;
+ }
diff --git a/usb/usb-musb-fix-kernel-warning-oops-when-unloading-module-in-otg-mode.patch b/usb/usb-musb-fix-kernel-warning-oops-when-unloading-module-in-otg-mode.patch
new file mode 100644
index 00000000000000..076dfec489ce34
--- /dev/null
+++ b/usb/usb-musb-fix-kernel-warning-oops-when-unloading-module-in-otg-mode.patch
@@ -0,0 +1,107 @@
+From linux-usb-owner@vger.kernel.org  Tue Oct  5 15:38:07 2010
+From: Felipe Balbi <balbi@ti.com>
+To: Greg KH <greg@kroah.com>
+Cc: Sergei Shtylyov <sshtylyov@ru.mvista.com>, stable@kernel.org,
+	Felipe Balbi <balbi@ti.com>
+Subject: USB: MUSB: fix kernel WARNING/oops when unloading module in OTG mode
+Date: Wed, 29 Sep 2010 09:54:29 +0300
+Message-Id: <1285743271-21654-2-git-send-email-balbi@ti.com>
+
+From: Sergei Shtylyov <sshtylyov@ru.mvista.com>
+
+Since commit 461972d8a4c94bc44f11a13046041c78a7cf18dd (musb_core: don't call
+musb_platform_exit() twice), unloading the driver module results in a WARNING
+"kobject: '(null)' (c73de788): is not initialized, yet kobject_put() is being
+called." (or even kernel oops) on e.g. DaVincis, though only in the OTG mode.
+There exists dubious and unbalanced put_device() call in musb_free() which
+takes place only in the OTG mode.  As this commit caused musb_platform_exit()
+to be called (and so unregister the NOP transceiver) before this put_device()
+call, this function references already freed memory.
+
+On the other hand, all the glue layers miss the otg_put_transceiver() call,
+complementary to the otg_get_transceiver() call that they do.  So, I think
+the solution is to get rid of the strange put_device() call, and instead
+call otg_put_transceiver() in the glue layers...
+
+Signed-off-by: Sergei Shtylyov <sshtylyov@ru.mvista.com>
+Cc: stable <stable@kernel.org>
+Signed-off-by: Felipe Balbi <balbi@ti.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/musb/blackfin.c  |    1 +
+ drivers/usb/musb/davinci.c   |    2 ++
+ drivers/usb/musb/musb_core.c |    4 ----
+ drivers/usb/musb/omap2430.c  |    1 +
+ drivers/usb/musb/tusb6010.c  |    4 ++++
+ 5 files changed, 8 insertions(+), 4 deletions(-)
+
+--- a/drivers/usb/musb/blackfin.c
++++ b/drivers/usb/musb/blackfin.c
+@@ -397,5 +397,6 @@ int musb_platform_exit(struct musb *musb
+ 
+ 	gpio_free(musb->config->gpio_vrsel);
+ 
++	otg_put_transceiver(musb->xceiv);
+ 	return 0;
+ }
+--- a/drivers/usb/musb/davinci.c
++++ b/drivers/usb/musb/davinci.c
+@@ -446,6 +446,7 @@ int __init musb_platform_init(struct mus
+ fail:
+ 	clk_disable(musb->clock);
+ 
++	otg_put_transceiver(musb->xceiv);
+ 	usb_nop_xceiv_unregister();
+ 	return -ENODEV;
+ }
+@@ -496,6 +497,7 @@ int musb_platform_exit(struct musb *musb
+ 
+ 	clk_disable(musb->clock);
+ 
++	otg_put_transceiver(musb->xceiv);
+ 	usb_nop_xceiv_unregister();
+ 
+ 	return 0;
+--- a/drivers/usb/musb/musb_core.c
++++ b/drivers/usb/musb/musb_core.c
+@@ -1926,10 +1926,6 @@ static void musb_free(struct musb *musb)
+ 		dma_controller_destroy(c);
+ 	}
+ 
+-#ifdef CONFIG_USB_MUSB_OTG
+-	put_device(musb->xceiv->dev);
+-#endif
+-
+ #ifdef CONFIG_USB_MUSB_HDRC_HCD
+ 	usb_put_hcd(musb_to_hcd(musb));
+ #else
+--- a/drivers/usb/musb/omap2430.c
++++ b/drivers/usb/musb/omap2430.c
+@@ -320,5 +320,6 @@ int musb_platform_exit(struct musb *musb
+ 
+ 	musb_platform_suspend(musb);
+ 
++	otg_put_transceiver(musb->xceiv);
+ 	return 0;
+ }
+--- a/drivers/usb/musb/tusb6010.c
++++ b/drivers/usb/musb/tusb6010.c
+@@ -1152,6 +1152,8 @@ done:
+ 	if (ret < 0) {
+ 		if (sync)
+ 			iounmap(sync);
++
++		otg_put_transceiver(musb->xceiv);
+ 		usb_nop_xceiv_unregister();
+ 	}
+ 	return ret;
+@@ -1166,6 +1168,8 @@ int musb_platform_exit(struct musb *musb
+ 		musb->board_set_power(0);
+ 
+ 	iounmap(musb->sync_va);
++
++	otg_put_transceiver(musb->xceiv);
+ 	usb_nop_xceiv_unregister();
+ 	return 0;
+ }
diff --git a/usb/usb-uhci-add-native-scatter-gather-support-v1.patch b/usb/usb-uhci-add-native-scatter-gather-support-v1.patch
new file mode 100644
index 00000000000000..3a227ca018d89b
--- /dev/null
+++ b/usb/usb-uhci-add-native-scatter-gather-support-v1.patch
@@ -0,0 +1,89 @@
+From tom.leiming@gmail.com  Tue Oct  5 15:42:44 2010
+From: Ming Lei <tom.leiming@gmail.com>
+To: greg@kroah.com,
+	stern@rowland.harvard.edu
+Cc: linux-usb@vger.kernel.org,
+	Ming Lei <tom.leiming@gmail.com>
+Subject: USB: UHCI: add native scatter-gather support(v1)
+Date: Thu, 30 Sep 2010 20:32:44 +0800
+Message-Id: <1285849964-3043-1-git-send-email-tom.leiming@gmail.com>
+
+From: Ming Lei <tom.leiming@gmail.com>
+
+This patch adds native scatter-gather support to uhci-hcd.
+
+Reviewed-by: Alan Stern <stern@rowland.harvard.edu>
+Signed-off-by: Ming Lei <tom.leiming@gmail.com>
+Acked-by: Alan Stern <stern@rowland.harvard.edu>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/host/uhci-q.c |   33 +++++++++++++++++++++++++++++----
+ 1 file changed, 29 insertions(+), 4 deletions(-)
+
+--- a/drivers/usb/host/uhci-q.c
++++ b/drivers/usb/host/uhci-q.c
+@@ -917,10 +917,13 @@ static int uhci_submit_common(struct uhc
+ 	unsigned long destination, status;
+ 	int maxsze = le16_to_cpu(qh->hep->desc.wMaxPacketSize);
+ 	int len = urb->transfer_buffer_length;
+-	dma_addr_t data = urb->transfer_dma;
++	int this_sg_len;
++	dma_addr_t data;
+ 	__le32 *plink;
+ 	struct urb_priv *urbp = urb->hcpriv;
+ 	unsigned int toggle;
++	struct scatterlist  *sg;
++	int i;
+ 
+ 	if (len < 0)
+ 		return -EINVAL;
+@@ -937,12 +940,26 @@ static int uhci_submit_common(struct uhc
+ 	if (usb_pipein(urb->pipe))
+ 		status |= TD_CTRL_SPD;
+ 
++	i = urb->num_sgs;
++	if (len > 0 && i > 0) {
++		sg = urb->sg;
++		data = sg_dma_address(sg);
++
++		/* urb->transfer_buffer_length may be smaller than the
++		 * size of the scatterlist (or vice versa)
++		 */
++		this_sg_len = min_t(int, sg_dma_len(sg), len);
++	} else {
++		sg = NULL;
++		data = urb->transfer_dma;
++		this_sg_len = len;
++	}
+ 	/*
+ 	 * Build the DATA TDs
+ 	 */
+ 	plink = NULL;
+ 	td = qh->dummy_td;
+-	do {	/* Allow zero length packets */
++	for (;;) {	/* Allow zero length packets */
+ 		int pktsze = maxsze;
+ 
+ 		if (len <= pktsze) {		/* The last packet */
+@@ -965,10 +982,18 @@ static int uhci_submit_common(struct uhc
+ 		plink = &td->link;
+ 		status |= TD_CTRL_ACTIVE;
+ 
++		toggle ^= 1;
+ 		data += pktsze;
++		this_sg_len -= pktsze;
+ 		len -= maxsze;
+-		toggle ^= 1;
+-	} while (len > 0);
++		if (this_sg_len <= 0) {
++			if (--i <= 0 || len <= 0)
++				break;
++			sg = sg_next(sg);
++			data = sg_dma_address(sg);
++			this_sg_len = min_t(int, sg_dma_len(sg), len);
++		}
++	}
+ 
+ 	/*
+ 	 * URB_ZERO_PACKET means adding a 0-length packet, if direction
diff --git a/usb/usb-usbtest-ensure-correct-isoc-data-length.patch b/usb/usb-usbtest-ensure-correct-isoc-data-length.patch
new file mode 100644
index 00000000000000..7560657f9baa80
--- /dev/null
+++ b/usb/usb-usbtest-ensure-correct-isoc-data-length.patch
@@ -0,0 +1,33 @@
+From linux-usb-owner@vger.kernel.org  Tue Oct  5 15:53:21 2010
+From: Martin Fuzzey <mfuzzey@gmail.com>
+Subject: USB: usbtest - ensure correct isoc data length
+To: Greg KH <greg@kroah.com>, David Brownell <david-b@pacbell.net>,
+	linux-usb@vger.kernel.org
+Date: Fri, 01 Oct 2010 00:20:48 +0200
+Message-ID: <20100930222048.15060.57008.stgit@srv002.fuzzey.net>
+
+Check the data length of isochronous transfers is
+as expected.
+
+With this test #16 will now fail if the device side
+sends no data.
+
+Signed-off-by: Martin Fuzzey <mfuzzey@gmail.com>
+Cc: David Brownell <david-b@pacbell.net>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+---
+ drivers/usb/misc/usbtest.c |    2 ++
+ 1 file changed, 2 insertions(+)
+
+--- a/drivers/usb/misc/usbtest.c
++++ b/drivers/usb/misc/usbtest.c
+@@ -1363,6 +1363,8 @@ static void iso_callback (struct urb *ur
+ 		ctx->errors += urb->error_count;
+ 	else if (urb->status != 0)
+ 		ctx->errors += urb->number_of_packets;
++	else if (urb->actual_length != urb->transfer_buffer_length)
++		ctx->errors++;
+ 
+ 	if (urb->status == 0 && ctx->count > (ctx->pending - 1)
+ 			&& !ctx->submit_error) {
diff --git a/usb/usb-usbtest-fix-coding-style.patch b/usb/usb-usbtest-fix-coding-style.patch
new file mode 100644
index 00000000000000..46760f641d95d3
--- /dev/null
+++ b/usb/usb-usbtest-fix-coding-style.patch
@@ -0,0 +1,1767 @@
+From mfuzzey@gmail.com  Tue Oct  5 15:51:58 2010
+From: Martin Fuzzey <mfuzzey@gmail.com>
+Subject: USB: usbtest fix coding style
+To: Greg KH <greg@kroah.com>, David Brownell <david-b@pacbell.net>,
+	linux-usb@vger.kernel.org
+Date: Fri, 01 Oct 2010 00:20:42 +0200
+Message-ID: <20100930222042.15060.63884.stgit@srv002.fuzzey.net>
+
+
+
+Signed-off-by: Martin Fuzzey <mfuzzey@gmail.com>
+Cc: David Brownell <david-b@pacbell.net>
+Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
+
+
+---
+ drivers/usb/misc/usbtest.c |  669 +++++++++++++++++++++++----------------------
+ 1 file changed, 343 insertions(+), 326 deletions(-)
+
+--- a/drivers/usb/misc/usbtest.c
++++ b/drivers/usb/misc/usbtest.c
+@@ -13,17 +13,16 @@
+ 
+ /*-------------------------------------------------------------------------*/
+ 
+-// FIXME make these public somewhere; usbdevfs.h?
+-//
++/* FIXME make these public somewhere; usbdevfs.h? */
+ struct usbtest_param {
+-	// inputs
++	/* inputs */
+ 	unsigned		test_num;	/* 0..(TEST_CASES-1) */
+ 	unsigned		iterations;
+ 	unsigned		length;
+ 	unsigned		vary;
+ 	unsigned		sglen;
+ 
+-	// outputs
++	/* outputs */
+ 	struct timeval		duration;
+ };
+ #define USBTEST_REQUEST	_IOWR('U', 100, struct usbtest_param)
+@@ -45,9 +44,9 @@ struct usbtest_info {
+ 	const char		*name;
+ 	u8			ep_in;		/* bulk/intr source */
+ 	u8			ep_out;		/* bulk/intr sink */
+-	unsigned		autoconf : 1;
+-	unsigned		ctrl_out : 1;
+-	unsigned		iso : 1;	/* try iso in/out */
++	unsigned		autoconf:1;
++	unsigned		ctrl_out:1;
++	unsigned		iso:1;		/* try iso in/out */
+ 	int			alt;
+ };
+ 
+@@ -71,9 +70,9 @@ struct usbtest_dev {
+ 	u8			*buf;
+ };
+ 
+-static struct usb_device *testdev_to_usbdev (struct usbtest_dev *test)
++static struct usb_device *testdev_to_usbdev(struct usbtest_dev *test)
+ {
+-	return interface_to_usbdev (test->intf);
++	return interface_to_usbdev(test->intf);
+ }
+ 
+ /* set up all urbs so they can be used with either bulk or interrupt */
+@@ -87,7 +86,7 @@ static struct usb_device *testdev_to_usb
+ /*-------------------------------------------------------------------------*/
+ 
+ static int
+-get_endpoints (struct usbtest_dev *dev, struct usb_interface *intf)
++get_endpoints(struct usbtest_dev *dev, struct usb_interface *intf)
+ {
+ 	int				tmp;
+ 	struct usb_host_interface	*alt;
+@@ -115,7 +114,7 @@ get_endpoints (struct usbtest_dev *dev,
+ 			case USB_ENDPOINT_XFER_ISOC:
+ 				if (dev->info->iso)
+ 					goto try_iso;
+-				// FALLTHROUGH
++				/* FALLTHROUGH */
+ 			default:
+ 				continue;
+ 			}
+@@ -142,9 +141,9 @@ try_iso:
+ 	return -EINVAL;
+ 
+ found:
+-	udev = testdev_to_usbdev (dev);
++	udev = testdev_to_usbdev(dev);
+ 	if (alt->desc.bAlternateSetting != 0) {
+-		tmp = usb_set_interface (udev,
++		tmp = usb_set_interface(udev,
+ 				alt->desc.bInterfaceNumber,
+ 				alt->desc.bAlternateSetting);
+ 		if (tmp < 0)
+@@ -152,21 +151,21 @@ found:
+ 	}
+ 
+ 	if (in) {
+-		dev->in_pipe = usb_rcvbulkpipe (udev,
++		dev->in_pipe = usb_rcvbulkpipe(udev,
+ 			in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+-		dev->out_pipe = usb_sndbulkpipe (udev,
++		dev->out_pipe = usb_sndbulkpipe(udev,
+ 			out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
+ 	}
+ 	if (iso_in) {
+ 		dev->iso_in = &iso_in->desc;
+-		dev->in_iso_pipe = usb_rcvisocpipe (udev,
++		dev->in_iso_pipe = usb_rcvisocpipe(udev,
+ 				iso_in->desc.bEndpointAddress
+ 					& USB_ENDPOINT_NUMBER_MASK);
+ 	}
+ 
+ 	if (iso_out) {
+ 		dev->iso_out = &iso_out->desc;
+-		dev->out_iso_pipe = usb_sndisocpipe (udev,
++		dev->out_iso_pipe = usb_sndisocpipe(udev,
+ 				iso_out->desc.bEndpointAddress
+ 					& USB_ENDPOINT_NUMBER_MASK);
+ 	}
+@@ -182,12 +181,12 @@ found:
+  * them with non-zero test data (or test for it) when appropriate.
+  */
+ 
+-static void simple_callback (struct urb *urb)
++static void simple_callback(struct urb *urb)
+ {
+ 	complete(urb->context);
+ }
+ 
+-static struct urb *simple_alloc_urb (
++static struct urb *simple_alloc_urb(
+ 	struct usb_device	*udev,
+ 	int			pipe,
+ 	unsigned long		bytes
+@@ -195,32 +194,32 @@ static struct urb *simple_alloc_urb (
+ {
+ 	struct urb		*urb;
+ 
+-	urb = usb_alloc_urb (0, GFP_KERNEL);
++	urb = usb_alloc_urb(0, GFP_KERNEL);
+ 	if (!urb)
+ 		return urb;
+-	usb_fill_bulk_urb (urb, udev, pipe, NULL, bytes, simple_callback, NULL);
++	usb_fill_bulk_urb(urb, udev, pipe, NULL, bytes, simple_callback, NULL);
+ 	urb->interval = (udev->speed == USB_SPEED_HIGH)
+ 			? (INTERRUPT_RATE << 3)
+ 			: INTERRUPT_RATE;
+ 	urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+-	if (usb_pipein (pipe))
++	if (usb_pipein(pipe))
+ 		urb->transfer_flags |= URB_SHORT_NOT_OK;
+-	urb->transfer_buffer = usb_alloc_coherent (udev, bytes, GFP_KERNEL,
++	urb->transfer_buffer = usb_alloc_coherent(udev, bytes, GFP_KERNEL,
+ 			&urb->transfer_dma);
+ 	if (!urb->transfer_buffer) {
+-		usb_free_urb (urb);
++		usb_free_urb(urb);
+ 		urb = NULL;
+ 	} else
+-		memset (urb->transfer_buffer, 0, bytes);
++		memset(urb->transfer_buffer, 0, bytes);
+ 	return urb;
+ }
+ 
+-static unsigned pattern = 0;
++static unsigned pattern;
+ static unsigned mod_pattern;
+ module_param_named(pattern, mod_pattern, uint, S_IRUGO | S_IWUSR);
+ MODULE_PARM_DESC(mod_pattern, "i/o pattern (0 == zeroes)");
+ 
+-static inline void simple_fill_buf (struct urb *urb)
++static inline void simple_fill_buf(struct urb *urb)
+ {
+ 	unsigned	i;
+ 	u8		*buf = urb->transfer_buffer;
+@@ -228,9 +227,9 @@ static inline void simple_fill_buf (stru
+ 
+ 	switch (pattern) {
+ 	default:
+-		// FALLTHROUGH
++		/* FALLTHROUGH */
+ 	case 0:
+-		memset (buf, 0, len);
++		memset(buf, 0, len);
+ 		break;
+ 	case 1:			/* mod63 */
+ 		for (i = 0; i < len; i++)
+@@ -273,14 +272,14 @@ static inline int simple_check_buf(struc
+ 	return 0;
+ }
+ 
+-static void simple_free_urb (struct urb *urb)
++static void simple_free_urb(struct urb *urb)
+ {
+ 	usb_free_coherent(urb->dev, urb->transfer_buffer_length,
+ 			  urb->transfer_buffer, urb->transfer_dma);
+-	usb_free_urb (urb);
++	usb_free_urb(urb);
+ }
+ 
+-static int simple_io (
++static int simple_io(
+ 	struct usbtest_dev	*tdev,
+ 	struct urb		*urb,
+ 	int			iterations,
+@@ -296,17 +295,18 @@ static int simple_io (
+ 
+ 	urb->context = &completion;
+ 	while (retval == 0 && iterations-- > 0) {
+-		init_completion (&completion);
+-		if (usb_pipeout (urb->pipe))
+-			simple_fill_buf (urb);
+-		if ((retval = usb_submit_urb (urb, GFP_KERNEL)) != 0)
++		init_completion(&completion);
++		if (usb_pipeout(urb->pipe))
++			simple_fill_buf(urb);
++		retval = usb_submit_urb(urb, GFP_KERNEL);
++		if (retval != 0)
+ 			break;
+ 
+ 		/* NOTE:  no timeouts; can't be broken out of by interrupt */
+-		wait_for_completion (&completion);
++		wait_for_completion(&completion);
+ 		retval = urb->status;
+ 		urb->dev = udev;
+-		if (retval == 0 && usb_pipein (urb->pipe))
++		if (retval == 0 && usb_pipein(urb->pipe))
+ 			retval = simple_check_buf(tdev, urb);
+ 
+ 		if (vary) {
+@@ -337,7 +337,7 @@ static int simple_io (
+  * Yes, this also tests the scatterlist primitives.
+  */
+ 
+-static void free_sglist (struct scatterlist *sg, int nents)
++static void free_sglist(struct scatterlist *sg, int nents)
+ {
+ 	unsigned		i;
+ 
+@@ -346,19 +346,19 @@ static void free_sglist (struct scatterl
+ 	for (i = 0; i < nents; i++) {
+ 		if (!sg_page(&sg[i]))
+ 			continue;
+-		kfree (sg_virt(&sg[i]));
++		kfree(sg_virt(&sg[i]));
+ 	}
+-	kfree (sg);
++	kfree(sg);
+ }
+ 
+ static struct scatterlist *
+-alloc_sglist (int nents, int max, int vary)
++alloc_sglist(int nents, int max, int vary)
+ {
+ 	struct scatterlist	*sg;
+ 	unsigned		i;
+ 	unsigned		size = max;
+ 
+-	sg = kmalloc (nents * sizeof *sg, GFP_KERNEL);
++	sg = kmalloc(nents * sizeof *sg, GFP_KERNEL);
+ 	if (!sg)
+ 		return NULL;
+ 	sg_init_table(sg, nents);
+@@ -367,9 +367,9 @@ alloc_sglist (int nents, int max, int va
+ 		char		*buf;
+ 		unsigned	j;
+ 
+-		buf = kzalloc (size, GFP_KERNEL);
++		buf = kzalloc(size, GFP_KERNEL);
+ 		if (!buf) {
+-			free_sglist (sg, i);
++			free_sglist(sg, i);
+ 			return NULL;
+ 		}
+ 
+@@ -397,7 +397,7 @@ alloc_sglist (int nents, int max, int va
+ 	return sg;
+ }
+ 
+-static int perform_sglist (
++static int perform_sglist(
+ 	struct usbtest_dev	*tdev,
+ 	unsigned		iterations,
+ 	int			pipe,
+@@ -410,7 +410,7 @@ static int perform_sglist (
+ 	int			retval = 0;
+ 
+ 	while (retval == 0 && iterations-- > 0) {
+-		retval = usb_sg_init (req, udev, pipe,
++		retval = usb_sg_init(req, udev, pipe,
+ 				(udev->speed == USB_SPEED_HIGH)
+ 					? (INTERRUPT_RATE << 3)
+ 					: INTERRUPT_RATE,
+@@ -418,7 +418,7 @@ static int perform_sglist (
+ 
+ 		if (retval)
+ 			break;
+-		usb_sg_wait (req);
++		usb_sg_wait(req);
+ 		retval = req->status;
+ 
+ 		/* FIXME check resulting data pattern */
+@@ -426,9 +426,9 @@ static int perform_sglist (
+ 		/* FIXME if endpoint halted, clear halt (and log) */
+ 	}
+ 
+-	// FIXME for unlink or fault handling tests, don't report
+-	// failure if retval is as we expected ...
+-
++	/* FIXME for unlink or fault handling tests, don't report
++	 * failure if retval is as we expected ...
++	 */
+ 	if (retval)
+ 		ERROR(tdev, "perform_sglist failed, "
+ 				"iterations left %d, status %d\n",
+@@ -452,31 +452,31 @@ static int perform_sglist (
+  */
+ 
+ static unsigned realworld = 1;
+-module_param (realworld, uint, 0);
+-MODULE_PARM_DESC (realworld, "clear to demand stricter spec compliance");
++module_param(realworld, uint, 0);
++MODULE_PARM_DESC(realworld, "clear to demand stricter spec compliance");
+ 
+-static int get_altsetting (struct usbtest_dev *dev)
++static int get_altsetting(struct usbtest_dev *dev)
+ {
+ 	struct usb_interface	*iface = dev->intf;
+-	struct usb_device	*udev = interface_to_usbdev (iface);
++	struct usb_device	*udev = interface_to_usbdev(iface);
+ 	int			retval;
+ 
+-	retval = usb_control_msg (udev, usb_rcvctrlpipe (udev, 0),
++	retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+ 			USB_REQ_GET_INTERFACE, USB_DIR_IN|USB_RECIP_INTERFACE,
+-			0, iface->altsetting [0].desc.bInterfaceNumber,
++			0, iface->altsetting[0].desc.bInterfaceNumber,
+ 			dev->buf, 1, USB_CTRL_GET_TIMEOUT);
+ 	switch (retval) {
+ 	case 1:
+-		return dev->buf [0];
++		return dev->buf[0];
+ 	case 0:
+ 		retval = -ERANGE;
+-		// FALLTHROUGH
++		/* FALLTHROUGH */
+ 	default:
+ 		return retval;
+ 	}
+ }
+ 
+-static int set_altsetting (struct usbtest_dev *dev, int alternate)
++static int set_altsetting(struct usbtest_dev *dev, int alternate)
+ {
+ 	struct usb_interface		*iface = dev->intf;
+ 	struct usb_device		*udev;
+@@ -484,9 +484,9 @@ static int set_altsetting (struct usbtes
+ 	if (alternate < 0 || alternate >= 256)
+ 		return -EINVAL;
+ 
+-	udev = interface_to_usbdev (iface);
+-	return usb_set_interface (udev,
+-			iface->altsetting [0].desc.bInterfaceNumber,
++	udev = interface_to_usbdev(iface);
++	return usb_set_interface(udev,
++			iface->altsetting[0].desc.bInterfaceNumber,
+ 			alternate);
+ }
+ 
+@@ -519,9 +519,9 @@ static int is_good_config(struct usbtest
+ 		return 0;
+ 	}
+ 
+-	if (le16_to_cpu(config->wTotalLength) == len)		/* read it all */
++	if (le16_to_cpu(config->wTotalLength) == len)	/* read it all */
+ 		return 1;
+-	if (le16_to_cpu(config->wTotalLength) >= TBUF_SIZE)		/* max partial read */
++	if (le16_to_cpu(config->wTotalLength) >= TBUF_SIZE)	/* max partial read */
+ 		return 1;
+ 	ERROR(tdev, "bogus config descriptor read size\n");
+ 	return 0;
+@@ -542,10 +542,10 @@ static int is_good_config(struct usbtest
+  * to see if usbcore, hcd, and device all behave right.  such testing would
+  * involve varied read sizes and other operation sequences.
+  */
+-static int ch9_postconfig (struct usbtest_dev *dev)
++static int ch9_postconfig(struct usbtest_dev *dev)
+ {
+ 	struct usb_interface	*iface = dev->intf;
+-	struct usb_device	*udev = interface_to_usbdev (iface);
++	struct usb_device	*udev = interface_to_usbdev(iface);
+ 	int			i, alt, retval;
+ 
+ 	/* [9.2.3] if there's more than one altsetting, we need to be able to
+@@ -554,7 +554,7 @@ static int ch9_postconfig (struct usbtes
+ 	for (i = 0; i < iface->num_altsetting; i++) {
+ 
+ 		/* 9.2.3 constrains the range here */
+-		alt = iface->altsetting [i].desc.bAlternateSetting;
++		alt = iface->altsetting[i].desc.bAlternateSetting;
+ 		if (alt < 0 || alt >= iface->num_altsetting) {
+ 			dev_err(&iface->dev,
+ 					"invalid alt [%d].bAltSetting = %d\n",
+@@ -566,7 +566,7 @@ static int ch9_postconfig (struct usbtes
+ 			continue;
+ 
+ 		/* [9.4.10] set_interface */
+-		retval = set_altsetting (dev, alt);
++		retval = set_altsetting(dev, alt);
+ 		if (retval) {
+ 			dev_err(&iface->dev, "can't set_interface = %d, %d\n",
+ 					alt, retval);
+@@ -574,7 +574,7 @@ static int ch9_postconfig (struct usbtes
+ 		}
+ 
+ 		/* [9.4.4] get_interface always works */
+-		retval = get_altsetting (dev);
++		retval = get_altsetting(dev);
+ 		if (retval != alt) {
+ 			dev_err(&iface->dev, "get alt should be %d, was %d\n",
+ 					alt, retval);
+@@ -591,11 +591,11 @@ static int ch9_postconfig (struct usbtes
+ 		 * ... although some cheap devices (like one TI Hub I've got)
+ 		 * won't return config descriptors except before set_config.
+ 		 */
+-		retval = usb_control_msg (udev, usb_rcvctrlpipe (udev, 0),
++		retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+ 				USB_REQ_GET_CONFIGURATION,
+ 				USB_DIR_IN | USB_RECIP_DEVICE,
+ 				0, 0, dev->buf, 1, USB_CTRL_GET_TIMEOUT);
+-		if (retval != 1 || dev->buf [0] != expected) {
++		if (retval != 1 || dev->buf[0] != expected) {
+ 			dev_err(&iface->dev, "get config --> %d %d (1 %d)\n",
+ 				retval, dev->buf[0], expected);
+ 			return (retval < 0) ? retval : -EDOM;
+@@ -603,7 +603,7 @@ static int ch9_postconfig (struct usbtes
+ 	}
+ 
+ 	/* there's always [9.4.3] a device descriptor [9.6.1] */
+-	retval = usb_get_descriptor (udev, USB_DT_DEVICE, 0,
++	retval = usb_get_descriptor(udev, USB_DT_DEVICE, 0,
+ 			dev->buf, sizeof udev->descriptor);
+ 	if (retval != sizeof udev->descriptor) {
+ 		dev_err(&iface->dev, "dev descriptor --> %d\n", retval);
+@@ -612,7 +612,7 @@ static int ch9_postconfig (struct usbtes
+ 
+ 	/* there's always [9.4.3] at least one config descriptor [9.6.3] */
+ 	for (i = 0; i < udev->descriptor.bNumConfigurations; i++) {
+-		retval = usb_get_descriptor (udev, USB_DT_CONFIG, i,
++		retval = usb_get_descriptor(udev, USB_DT_CONFIG, i,
+ 				dev->buf, TBUF_SIZE);
+ 		if (!is_good_config(dev, retval)) {
+ 			dev_err(&iface->dev,
+@@ -621,18 +621,19 @@ static int ch9_postconfig (struct usbtes
+ 			return (retval < 0) ? retval : -EDOM;
+ 		}
+ 
+-		// FIXME cross-checking udev->config[i] to make sure usbcore
+-		// parsed it right (etc) would be good testing paranoia
++		/* FIXME cross-checking udev->config[i] to make sure usbcore
++		 * parsed it right (etc) would be good testing paranoia
++		 */
+ 	}
+ 
+ 	/* and sometimes [9.2.6.6] speed dependent descriptors */
+ 	if (le16_to_cpu(udev->descriptor.bcdUSB) == 0x0200) {
+-		struct usb_qualifier_descriptor		*d = NULL;
++		struct usb_qualifier_descriptor *d = NULL;
+ 
+ 		/* device qualifier [9.6.2] */
+-		retval = usb_get_descriptor (udev,
++		retval = usb_get_descriptor(udev,
+ 				USB_DT_DEVICE_QUALIFIER, 0, dev->buf,
+-				sizeof (struct usb_qualifier_descriptor));
++				sizeof(struct usb_qualifier_descriptor));
+ 		if (retval == -EPIPE) {
+ 			if (udev->speed == USB_SPEED_HIGH) {
+ 				dev_err(&iface->dev,
+@@ -641,7 +642,7 @@ static int ch9_postconfig (struct usbtes
+ 				return (retval < 0) ? retval : -EDOM;
+ 			}
+ 			/* usb2.0 but not high-speed capable; fine */
+-		} else if (retval != sizeof (struct usb_qualifier_descriptor)) {
++		} else if (retval != sizeof(struct usb_qualifier_descriptor)) {
+ 			dev_err(&iface->dev, "dev qualifier --> %d\n", retval);
+ 			return (retval < 0) ? retval : -EDOM;
+ 		} else
+@@ -651,7 +652,7 @@ static int ch9_postconfig (struct usbtes
+ 		if (d) {
+ 			unsigned max = d->bNumConfigurations;
+ 			for (i = 0; i < max; i++) {
+-				retval = usb_get_descriptor (udev,
++				retval = usb_get_descriptor(udev,
+ 					USB_DT_OTHER_SPEED_CONFIG, i,
+ 					dev->buf, TBUF_SIZE);
+ 				if (!is_good_config(dev, retval)) {
+@@ -663,25 +664,26 @@ static int ch9_postconfig (struct usbtes
+ 			}
+ 		}
+ 	}
+-	// FIXME fetch strings from at least the device descriptor
++	/* FIXME fetch strings from at least the device descriptor */
+ 
+ 	/* [9.4.5] get_status always works */
+-	retval = usb_get_status (udev, USB_RECIP_DEVICE, 0, dev->buf);
++	retval = usb_get_status(udev, USB_RECIP_DEVICE, 0, dev->buf);
+ 	if (retval != 2) {
+ 		dev_err(&iface->dev, "get dev status --> %d\n", retval);
+ 		return (retval < 0) ? retval : -EDOM;
+ 	}
+ 
+-	// FIXME configuration.bmAttributes says if we could try to set/clear
+-	// the device's remote wakeup feature ... if we can, test that here
++	/* FIXME configuration.bmAttributes says if we could try to set/clear
++	 * the device's remote wakeup feature ... if we can, test that here
++	 */
+ 
+-	retval = usb_get_status (udev, USB_RECIP_INTERFACE,
+-			iface->altsetting [0].desc.bInterfaceNumber, dev->buf);
++	retval = usb_get_status(udev, USB_RECIP_INTERFACE,
++			iface->altsetting[0].desc.bInterfaceNumber, dev->buf);
+ 	if (retval != 2) {
+ 		dev_err(&iface->dev, "get interface status --> %d\n", retval);
+ 		return (retval < 0) ? retval : -EDOM;
+ 	}
+-	// FIXME get status for each endpoint in the interface
++	/* FIXME get status for each endpoint in the interface */
+ 
+ 	return 0;
+ }
+@@ -717,7 +719,7 @@ struct subcase {
+ 	int			expected;
+ };
+ 
+-static void ctrl_complete (struct urb *urb)
++static void ctrl_complete(struct urb *urb)
+ {
+ 	struct ctrl_ctx		*ctx = urb->context;
+ 	struct usb_ctrlrequest	*reqp;
+@@ -725,9 +727,9 @@ static void ctrl_complete (struct urb *u
+ 	int			status = urb->status;
+ 
+ 	reqp = (struct usb_ctrlrequest *)urb->setup_packet;
+-	subcase = container_of (reqp, struct subcase, setup);
++	subcase = container_of(reqp, struct subcase, setup);
+ 
+-	spin_lock (&ctx->lock);
++	spin_lock(&ctx->lock);
+ 	ctx->count--;
+ 	ctx->pending--;
+ 
+@@ -787,14 +789,14 @@ error:
+ 
+ 			/* unlink whatever's still pending */
+ 			for (i = 1; i < ctx->param->sglen; i++) {
+-				struct urb	*u = ctx->urb [
+-						(i + subcase->number)
+-						% ctx->param->sglen];
++				struct urb *u = ctx->urb[
++							(i + subcase->number)
++							% ctx->param->sglen];
+ 
+ 				if (u == urb || !u->dev)
+ 					continue;
+ 				spin_unlock(&ctx->lock);
+-				status = usb_unlink_urb (u);
++				status = usb_unlink_urb(u);
+ 				spin_lock(&ctx->lock);
+ 				switch (status) {
+ 				case -EINPROGRESS:
+@@ -812,7 +814,8 @@ error:
+ 
+ 	/* resubmit if we need to, else mark this as done */
+ 	if ((status == 0) && (ctx->pending < ctx->count)) {
+-		if ((status = usb_submit_urb (urb, GFP_ATOMIC)) != 0) {
++		status = usb_submit_urb(urb, GFP_ATOMIC);
++		if (status != 0) {
+ 			ERROR(ctx->dev,
+ 				"can't resubmit ctrl %02x.%02x, err %d\n",
+ 				reqp->bRequestType, reqp->bRequest, status);
+@@ -824,21 +827,21 @@ error:
+ 
+ 	/* signal completion when nothing's queued */
+ 	if (ctx->pending == 0)
+-		complete (&ctx->complete);
+-	spin_unlock (&ctx->lock);
++		complete(&ctx->complete);
++	spin_unlock(&ctx->lock);
+ }
+ 
+ static int
+-test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
++test_ctrl_queue(struct usbtest_dev *dev, struct usbtest_param *param)
+ {
+-	struct usb_device	*udev = testdev_to_usbdev (dev);
++	struct usb_device	*udev = testdev_to_usbdev(dev);
+ 	struct urb		**urb;
+ 	struct ctrl_ctx		context;
+ 	int			i;
+ 
+-	spin_lock_init (&context.lock);
++	spin_lock_init(&context.lock);
+ 	context.dev = dev;
+-	init_completion (&context.complete);
++	init_completion(&context.complete);
+ 	context.count = param->sglen * param->iterations;
+ 	context.pending = 0;
+ 	context.status = -ENOMEM;
+@@ -853,7 +856,7 @@ test_ctrl_queue (struct usbtest_dev *dev
+ 	if (!urb)
+ 		return -ENOMEM;
+ 	for (i = 0; i < param->sglen; i++) {
+-		int			pipe = usb_rcvctrlpipe (udev, 0);
++		int			pipe = usb_rcvctrlpipe(udev, 0);
+ 		unsigned		len;
+ 		struct urb		*u;
+ 		struct usb_ctrlrequest	req;
+@@ -869,104 +872,108 @@ test_ctrl_queue (struct usbtest_dev *dev
+ 		 * device, but some are chosen to trigger protocol stalls
+ 		 * or short reads.
+ 		 */
+-		memset (&req, 0, sizeof req);
++		memset(&req, 0, sizeof req);
+ 		req.bRequest = USB_REQ_GET_DESCRIPTOR;
+ 		req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
+ 
+ 		switch (i % NUM_SUBCASES) {
+-		case 0:		// get device descriptor
+-			req.wValue = cpu_to_le16 (USB_DT_DEVICE << 8);
+-			len = sizeof (struct usb_device_descriptor);
+-			break;
+-		case 1:		// get first config descriptor (only)
+-			req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
+-			len = sizeof (struct usb_config_descriptor);
++		case 0:		/* get device descriptor */
++			req.wValue = cpu_to_le16(USB_DT_DEVICE << 8);
++			len = sizeof(struct usb_device_descriptor);
++			break;
++		case 1:		/* get first config descriptor (only) */
++			req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
++			len = sizeof(struct usb_config_descriptor);
+ 			break;
+-		case 2:		// get altsetting (OFTEN STALLS)
++		case 2:		/* get altsetting (OFTEN STALLS) */
+ 			req.bRequest = USB_REQ_GET_INTERFACE;
+ 			req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
+-			// index = 0 means first interface
++			/* index = 0 means first interface */
+ 			len = 1;
+ 			expected = EPIPE;
+ 			break;
+-		case 3:		// get interface status
++		case 3:		/* get interface status */
+ 			req.bRequest = USB_REQ_GET_STATUS;
+ 			req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
+-			// interface 0
++			/* interface 0 */
+ 			len = 2;
+ 			break;
+-		case 4:		// get device status
++		case 4:		/* get device status */
+ 			req.bRequest = USB_REQ_GET_STATUS;
+ 			req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
+ 			len = 2;
+ 			break;
+-		case 5:		// get device qualifier (MAY STALL)
++		case 5:		/* get device qualifier (MAY STALL) */
+ 			req.wValue = cpu_to_le16 (USB_DT_DEVICE_QUALIFIER << 8);
+-			len = sizeof (struct usb_qualifier_descriptor);
++			len = sizeof(struct usb_qualifier_descriptor);
+ 			if (udev->speed != USB_SPEED_HIGH)
+ 				expected = EPIPE;
+ 			break;
+-		case 6:		// get first config descriptor, plus interface
+-			req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
+-			len = sizeof (struct usb_config_descriptor);
+-			len += sizeof (struct usb_interface_descriptor);
++		case 6:		/* get first config descriptor, plus interface */
++			req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
++			len = sizeof(struct usb_config_descriptor);
++			len += sizeof(struct usb_interface_descriptor);
+ 			break;
+-		case 7:		// get interface descriptor (ALWAYS STALLS)
++		case 7:		/* get interface descriptor (ALWAYS STALLS) */
+ 			req.wValue = cpu_to_le16 (USB_DT_INTERFACE << 8);
+-			// interface == 0
+-			len = sizeof (struct usb_interface_descriptor);
++			/* interface == 0 */
++			len = sizeof(struct usb_interface_descriptor);
+ 			expected = -EPIPE;
+ 			break;
+-		// NOTE: two consecutive stalls in the queue here.
+-		// that tests fault recovery a bit more aggressively.
+-		case 8:		// clear endpoint halt (MAY STALL)
++		/* NOTE: two consecutive stalls in the queue here.
++		 *  that tests fault recovery a bit more aggressively. */
++		case 8:		/* clear endpoint halt (MAY STALL) */
+ 			req.bRequest = USB_REQ_CLEAR_FEATURE;
+ 			req.bRequestType = USB_RECIP_ENDPOINT;
+-			// wValue 0 == ep halt
+-			// wIndex 0 == ep0 (shouldn't halt!)
++			/* wValue 0 == ep halt */
++			/* wIndex 0 == ep0 (shouldn't halt!) */
+ 			len = 0;
+-			pipe = usb_sndctrlpipe (udev, 0);
++			pipe = usb_sndctrlpipe(udev, 0);
+ 			expected = EPIPE;
+ 			break;
+-		case 9:		// get endpoint status
++		case 9:		/* get endpoint status */
+ 			req.bRequest = USB_REQ_GET_STATUS;
+ 			req.bRequestType = USB_DIR_IN|USB_RECIP_ENDPOINT;
+-			// endpoint 0
++			/* endpoint 0 */
+ 			len = 2;
+ 			break;
+-		case 10:	// trigger short read (EREMOTEIO)
+-			req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
++		case 10:	/* trigger short read (EREMOTEIO) */
++			req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
+ 			len = 1024;
+ 			expected = -EREMOTEIO;
+ 			break;
+-		// NOTE: two consecutive _different_ faults in the queue.
+-		case 11:	// get endpoint descriptor (ALWAYS STALLS)
+-			req.wValue = cpu_to_le16 (USB_DT_ENDPOINT << 8);
+-			// endpoint == 0
+-			len = sizeof (struct usb_interface_descriptor);
++		/* NOTE: two consecutive _different_ faults in the queue. */
++		case 11:	/* get endpoint descriptor (ALWAYS STALLS) */
++			req.wValue = cpu_to_le16(USB_DT_ENDPOINT << 8);
++			/* endpoint == 0 */
++			len = sizeof(struct usb_interface_descriptor);
+ 			expected = EPIPE;
+ 			break;
+-		// NOTE: sometimes even a third fault in the queue!
+-		case 12:	// get string 0 descriptor (MAY STALL)
+-			req.wValue = cpu_to_le16 (USB_DT_STRING << 8);
+-			// string == 0, for language IDs
+-			len = sizeof (struct usb_interface_descriptor);
+-			// may succeed when > 4 languages
+-			expected = EREMOTEIO;	// or EPIPE, if no strings
+-			break;
+-		case 13:	// short read, resembling case 10
+-			req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
+-			// last data packet "should" be DATA1, not DATA0
++		/* NOTE: sometimes even a third fault in the queue! */
++		case 12:	/* get string 0 descriptor (MAY STALL) */
++			req.wValue = cpu_to_le16(USB_DT_STRING << 8);
++			/* string == 0, for language IDs */
++			len = sizeof(struct usb_interface_descriptor);
++			/* may succeed when > 4 languages */
++			expected = EREMOTEIO;	/* or EPIPE, if no strings */
++			break;
++		case 13:	/* short read, resembling case 10 */
++			req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
++			/* last data packet "should" be DATA1, not DATA0 */
+ 			len = 1024 - udev->descriptor.bMaxPacketSize0;
+ 			expected = -EREMOTEIO;
+ 			break;
+-		case 14:	// short read; try to fill the last packet
+-			req.wValue = cpu_to_le16 ((USB_DT_DEVICE << 8) | 0);
++		case 14:	/* short read; try to fill the last packet */
++			req.wValue = cpu_to_le16((USB_DT_DEVICE << 8) | 0);
+ 			/* device descriptor size == 18 bytes */
+ 			len = udev->descriptor.bMaxPacketSize0;
+ 			switch (len) {
+-			case 8:		len = 24; break;
+-			case 16:	len = 32; break;
++			case 8:
++				len = 24;
++				break;
++			case 16:
++				len = 32;
++				break;
+ 			}
+ 			expected = -EREMOTEIO;
+ 			break;
+@@ -975,8 +982,8 @@ test_ctrl_queue (struct usbtest_dev *dev
+ 			context.status = -EINVAL;
+ 			goto cleanup;
+ 		}
+-		req.wLength = cpu_to_le16 (len);
+-		urb [i] = u = simple_alloc_urb (udev, pipe, len);
++		req.wLength = cpu_to_le16(len);
++		urb[i] = u = simple_alloc_urb(udev, pipe, len);
+ 		if (!u)
+ 			goto cleanup;
+ 
+@@ -994,9 +1001,9 @@ test_ctrl_queue (struct usbtest_dev *dev
+ 
+ 	/* queue the urbs */
+ 	context.urb = urb;
+-	spin_lock_irq (&context.lock);
++	spin_lock_irq(&context.lock);
+ 	for (i = 0; i < param->sglen; i++) {
+-		context.status = usb_submit_urb (urb [i], GFP_ATOMIC);
++		context.status = usb_submit_urb(urb[i], GFP_ATOMIC);
+ 		if (context.status != 0) {
+ 			ERROR(dev, "can't submit urb[%d], status %d\n",
+ 					i, context.status);
+@@ -1005,23 +1012,23 @@ test_ctrl_queue (struct usbtest_dev *dev
+ 		}
+ 		context.pending++;
+ 	}
+-	spin_unlock_irq (&context.lock);
++	spin_unlock_irq(&context.lock);
+ 
+ 	/* FIXME  set timer and time out; provide a disconnect hook */
+ 
+ 	/* wait for the last one to complete */
+ 	if (context.pending > 0)
+-		wait_for_completion (&context.complete);
++		wait_for_completion(&context.complete);
+ 
+ cleanup:
+ 	for (i = 0; i < param->sglen; i++) {
+-		if (!urb [i])
++		if (!urb[i])
+ 			continue;
+-		urb [i]->dev = udev;
++		urb[i]->dev = udev;
+ 		kfree(urb[i]->setup_packet);
+-		simple_free_urb (urb [i]);
++		simple_free_urb(urb[i]);
+ 	}
+-	kfree (urb);
++	kfree(urb);
+ 	return context.status;
+ }
+ #undef NUM_SUBCASES
+@@ -1029,27 +1036,27 @@ cleanup:
+ 
+ /*-------------------------------------------------------------------------*/
+ 
+-static void unlink1_callback (struct urb *urb)
++static void unlink1_callback(struct urb *urb)
+ {
+ 	int	status = urb->status;
+ 
+-	// we "know" -EPIPE (stall) never happens
++	/* we "know" -EPIPE (stall) never happens */
+ 	if (!status)
+-		status = usb_submit_urb (urb, GFP_ATOMIC);
++		status = usb_submit_urb(urb, GFP_ATOMIC);
+ 	if (status) {
+ 		urb->status = status;
+ 		complete(urb->context);
+ 	}
+ }
+ 
+-static int unlink1 (struct usbtest_dev *dev, int pipe, int size, int async)
++static int unlink1(struct usbtest_dev *dev, int pipe, int size, int async)
+ {
+ 	struct urb		*urb;
+ 	struct completion	completion;
+ 	int			retval = 0;
+ 
+-	init_completion (&completion);
+-	urb = simple_alloc_urb (testdev_to_usbdev (dev), pipe, size);
++	init_completion(&completion);
++	urb = simple_alloc_urb(testdev_to_usbdev(dev), pipe, size);
+ 	if (!urb)
+ 		return -ENOMEM;
+ 	urb->context = &completion;
+@@ -1061,7 +1068,8 @@ static int unlink1 (struct usbtest_dev *
+ 	 * FIXME want additional tests for when endpoint is STALLing
+ 	 * due to errors, or is just NAKing requests.
+ 	 */
+-	if ((retval = usb_submit_urb (urb, GFP_KERNEL)) != 0) {
++	retval = usb_submit_urb(urb, GFP_KERNEL);
++	if (retval != 0) {
+ 		dev_err(&dev->intf->dev, "submit fail %d\n", retval);
+ 		return retval;
+ 	}
+@@ -1069,7 +1077,7 @@ static int unlink1 (struct usbtest_dev *
+ 	/* unlinking that should always work.  variable delay tests more
+ 	 * hcd states and code paths, even with little other system load.
+ 	 */
+-	msleep (jiffies % (2 * INTERRUPT_RATE));
++	msleep(jiffies % (2 * INTERRUPT_RATE));
+ 	if (async) {
+ 		while (!completion_done(&completion)) {
+ 			retval = usb_unlink_urb(urb);
+@@ -1098,11 +1106,11 @@ static int unlink1 (struct usbtest_dev *
+ 			break;
+ 		}
+ 	} else
+-		usb_kill_urb (urb);
++		usb_kill_urb(urb);
+ 
+-	wait_for_completion (&completion);
++	wait_for_completion(&completion);
+ 	retval = urb->status;
+-	simple_free_urb (urb);
++	simple_free_urb(urb);
+ 
+ 	if (async)
+ 		return (retval == -ECONNRESET) ? 0 : retval - 1000;
+@@ -1111,14 +1119,14 @@ static int unlink1 (struct usbtest_dev *
+ 				0 : retval - 2000;
+ }
+ 
+-static int unlink_simple (struct usbtest_dev *dev, int pipe, int len)
++static int unlink_simple(struct usbtest_dev *dev, int pipe, int len)
+ {
+ 	int			retval = 0;
+ 
+ 	/* test sync and async paths */
+-	retval = unlink1 (dev, pipe, len, 1);
++	retval = unlink1(dev, pipe, len, 1);
+ 	if (!retval)
+-		retval = unlink1 (dev, pipe, len, 0);
++		retval = unlink1(dev, pipe, len, 0);
+ 	return retval;
+ }
+ 
+@@ -1130,7 +1138,7 @@ static int verify_not_halted(struct usbt
+ 	u16	status;
+ 
+ 	/* shouldn't look or act halted */
+-	retval = usb_get_status (urb->dev, USB_RECIP_ENDPOINT, ep, &status);
++	retval = usb_get_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
+ 	if (retval < 0) {
+ 		ERROR(tdev, "ep %02x couldn't get no-halt status, %d\n",
+ 				ep, retval);
+@@ -1152,7 +1160,7 @@ static int verify_halted(struct usbtest_
+ 	u16	status;
+ 
+ 	/* should look and act halted */
+-	retval = usb_get_status (urb->dev, USB_RECIP_ENDPOINT, ep, &status);
++	retval = usb_get_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
+ 	if (retval < 0) {
+ 		ERROR(tdev, "ep %02x couldn't get halt status, %d\n",
+ 				ep, retval);
+@@ -1182,7 +1190,7 @@ static int test_halt(struct usbtest_dev
+ 		return retval;
+ 
+ 	/* set halt (protocol test only), verify it worked */
+-	retval = usb_control_msg (urb->dev, usb_sndctrlpipe (urb->dev, 0),
++	retval = usb_control_msg(urb->dev, usb_sndctrlpipe(urb->dev, 0),
+ 			USB_REQ_SET_FEATURE, USB_RECIP_ENDPOINT,
+ 			USB_ENDPOINT_HALT, ep,
+ 			NULL, 0, USB_CTRL_SET_TIMEOUT);
+@@ -1195,7 +1203,7 @@ static int test_halt(struct usbtest_dev
+ 		return retval;
+ 
+ 	/* clear halt (tests API + protocol), verify it worked */
+-	retval = usb_clear_halt (urb->dev, urb->pipe);
++	retval = usb_clear_halt(urb->dev, urb->pipe);
+ 	if (retval < 0) {
+ 		ERROR(tdev, "ep %02x couldn't clear halt, %d\n", ep, retval);
+ 		return retval;
+@@ -1209,18 +1217,18 @@ static int test_halt(struct usbtest_dev
+ 	return 0;
+ }
+ 
+-static int halt_simple (struct usbtest_dev *dev)
++static int halt_simple(struct usbtest_dev *dev)
+ {
+ 	int		ep;
+ 	int		retval = 0;
+ 	struct urb	*urb;
+ 
+-	urb = simple_alloc_urb (testdev_to_usbdev (dev), 0, 512);
++	urb = simple_alloc_urb(testdev_to_usbdev(dev), 0, 512);
+ 	if (urb == NULL)
+ 		return -ENOMEM;
+ 
+ 	if (dev->in_pipe) {
+-		ep = usb_pipeendpoint (dev->in_pipe) | USB_DIR_IN;
++		ep = usb_pipeendpoint(dev->in_pipe) | USB_DIR_IN;
+ 		urb->pipe = dev->in_pipe;
+ 		retval = test_halt(dev, ep, urb);
+ 		if (retval < 0)
+@@ -1228,12 +1236,12 @@ static int halt_simple (struct usbtest_d
+ 	}
+ 
+ 	if (dev->out_pipe) {
+-		ep = usb_pipeendpoint (dev->out_pipe);
++		ep = usb_pipeendpoint(dev->out_pipe);
+ 		urb->pipe = dev->out_pipe;
+ 		retval = test_halt(dev, ep, urb);
+ 	}
+ done:
+-	simple_free_urb (urb);
++	simple_free_urb(urb);
+ 	return retval;
+ }
+ 
+@@ -1247,7 +1255,7 @@ done:
+  * need to be able to handle more than one OUT data packet.  We'll
+  * try whatever we're told to try.
+  */
+-static int ctrl_out (struct usbtest_dev *dev,
++static int ctrl_out(struct usbtest_dev *dev,
+ 		unsigned count, unsigned length, unsigned vary)
+ {
+ 	unsigned		i, j, len;
+@@ -1263,7 +1271,7 @@ static int ctrl_out (struct usbtest_dev
+ 	if (!buf)
+ 		return -ENOMEM;
+ 
+-	udev = testdev_to_usbdev (dev);
++	udev = testdev_to_usbdev(dev);
+ 	len = length;
+ 	retval = 0;
+ 
+@@ -1273,8 +1281,8 @@ static int ctrl_out (struct usbtest_dev
+ 	for (i = 0; i < count; i++) {
+ 		/* write patterned data */
+ 		for (j = 0; j < len; j++)
+-			buf [j] = i + j;
+-		retval = usb_control_msg (udev, usb_sndctrlpipe (udev,0),
++			buf[j] = i + j;
++		retval = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+ 				0x5b, USB_DIR_OUT|USB_TYPE_VENDOR,
+ 				0, 0, buf, len, USB_CTRL_SET_TIMEOUT);
+ 		if (retval != len) {
+@@ -1288,7 +1296,7 @@ static int ctrl_out (struct usbtest_dev
+ 		}
+ 
+ 		/* read it back -- assuming nothing intervened!!  */
+-		retval = usb_control_msg (udev, usb_rcvctrlpipe (udev,0),
++		retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+ 				0x5c, USB_DIR_IN|USB_TYPE_VENDOR,
+ 				0, 0, buf, len, USB_CTRL_GET_TIMEOUT);
+ 		if (retval != len) {
+@@ -1303,9 +1311,9 @@ static int ctrl_out (struct usbtest_dev
+ 
+ 		/* fail if we can't verify */
+ 		for (j = 0; j < len; j++) {
+-			if (buf [j] != (u8) (i + j)) {
++			if (buf[j] != (u8) (i + j)) {
+ 				ERROR(dev, "ctrl_out, byte %d is %d not %d\n",
+-					j, buf [j], (u8) i + j);
++					j, buf[j], (u8) i + j);
+ 				retval = -EBADMSG;
+ 				break;
+ 			}
+@@ -1326,10 +1334,10 @@ static int ctrl_out (struct usbtest_dev
+ 	}
+ 
+ 	if (retval < 0)
+-		ERROR (dev, "ctrl_out %s failed, code %d, count %d\n",
++		ERROR(dev, "ctrl_out %s failed, code %d, count %d\n",
+ 			what, retval, i);
+ 
+-	kfree (buf);
++	kfree(buf);
+ 	return retval;
+ }
+ 
+@@ -1351,7 +1359,7 @@ struct iso_context {
+ 	struct usbtest_dev	*dev;
+ };
+ 
+-static void iso_callback (struct urb *urb)
++static void iso_callback(struct urb *urb)
+ {
+ 	struct iso_context	*ctx = urb->context;
+ 
+@@ -1366,7 +1374,7 @@ static void iso_callback (struct urb *ur
+ 
+ 	if (urb->status == 0 && ctx->count > (ctx->pending - 1)
+ 			&& !ctx->submit_error) {
+-		int status = usb_submit_urb (urb, GFP_ATOMIC);
++		int status = usb_submit_urb(urb, GFP_ATOMIC);
+ 		switch (status) {
+ 		case 0:
+ 			goto done;
+@@ -1388,13 +1396,13 @@ static void iso_callback (struct urb *ur
+ 			dev_err(&ctx->dev->intf->dev,
+ 				"iso test, %lu errors out of %lu\n",
+ 				ctx->errors, ctx->packet_count);
+-		complete (&ctx->done);
++		complete(&ctx->done);
+ 	}
+ done:
+ 	spin_unlock(&ctx->lock);
+ }
+ 
+-static struct urb *iso_alloc_urb (
++static struct urb *iso_alloc_urb(
+ 	struct usb_device	*udev,
+ 	int			pipe,
+ 	struct usb_endpoint_descriptor	*desc,
+@@ -1410,7 +1418,7 @@ static struct urb *iso_alloc_urb (
+ 	maxp *= 1 + (0x3 & (le16_to_cpu(desc->wMaxPacketSize) >> 11));
+ 	packets = DIV_ROUND_UP(bytes, maxp);
+ 
+-	urb = usb_alloc_urb (packets, GFP_KERNEL);
++	urb = usb_alloc_urb(packets, GFP_KERNEL);
+ 	if (!urb)
+ 		return urb;
+ 	urb->dev = udev;
+@@ -1418,30 +1426,30 @@ static struct urb *iso_alloc_urb (
+ 
+ 	urb->number_of_packets = packets;
+ 	urb->transfer_buffer_length = bytes;
+-	urb->transfer_buffer = usb_alloc_coherent (udev, bytes, GFP_KERNEL,
++	urb->transfer_buffer = usb_alloc_coherent(udev, bytes, GFP_KERNEL,
+ 			&urb->transfer_dma);
+ 	if (!urb->transfer_buffer) {
+-		usb_free_urb (urb);
++		usb_free_urb(urb);
+ 		return NULL;
+ 	}
+-	memset (urb->transfer_buffer, 0, bytes);
++	memset(urb->transfer_buffer, 0, bytes);
+ 	for (i = 0; i < packets; i++) {
+ 		/* here, only the last packet will be short */
+-		urb->iso_frame_desc[i].length = min ((unsigned) bytes, maxp);
++		urb->iso_frame_desc[i].length = min((unsigned) bytes, maxp);
+ 		bytes -= urb->iso_frame_desc[i].length;
+ 
+ 		urb->iso_frame_desc[i].offset = maxp * i;
+ 	}
+ 
+ 	urb->complete = iso_callback;
+-	// urb->context = SET BY CALLER
++	/* urb->context = SET BY CALLER */
+ 	urb->interval = 1 << (desc->bInterval - 1);
+ 	urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
+ 	return urb;
+ }
+ 
+ static int
+-test_iso_queue (struct usbtest_dev *dev, struct usbtest_param *param,
++test_iso_queue(struct usbtest_dev *dev, struct usbtest_param *param,
+ 		int pipe, struct usb_endpoint_descriptor *desc)
+ {
+ 	struct iso_context	context;
+@@ -1457,11 +1465,11 @@ test_iso_queue (struct usbtest_dev *dev,
+ 	memset(&context, 0, sizeof context);
+ 	context.count = param->iterations * param->sglen;
+ 	context.dev = dev;
+-	init_completion (&context.done);
+-	spin_lock_init (&context.lock);
++	init_completion(&context.done);
++	spin_lock_init(&context.lock);
+ 
+-	memset (urbs, 0, sizeof urbs);
+-	udev = testdev_to_usbdev (dev);
++	memset(urbs, 0, sizeof urbs);
++	udev = testdev_to_usbdev(dev);
+ 	dev_info(&dev->intf->dev,
+ 		"... iso period %d %sframes, wMaxPacket %04x\n",
+ 		1 << (desc->bInterval - 1),
+@@ -1469,14 +1477,14 @@ test_iso_queue (struct usbtest_dev *dev,
+ 		le16_to_cpu(desc->wMaxPacketSize));
+ 
+ 	for (i = 0; i < param->sglen; i++) {
+-		urbs [i] = iso_alloc_urb (udev, pipe, desc,
++		urbs[i] = iso_alloc_urb(udev, pipe, desc,
+ 				param->length);
+-		if (!urbs [i]) {
++		if (!urbs[i]) {
+ 			status = -ENOMEM;
+ 			goto fail;
+ 		}
+ 		packets += urbs[i]->number_of_packets;
+-		urbs [i]->context = &context;
++		urbs[i]->context = &context;
+ 	}
+ 	packets *= param->iterations;
+ 	dev_info(&dev->intf->dev,
+@@ -1485,27 +1493,27 @@ test_iso_queue (struct usbtest_dev *dev,
+ 			/ ((udev->speed == USB_SPEED_HIGH) ? 8 : 1),
+ 		packets);
+ 
+-	spin_lock_irq (&context.lock);
++	spin_lock_irq(&context.lock);
+ 	for (i = 0; i < param->sglen; i++) {
+ 		++context.pending;
+-		status = usb_submit_urb (urbs [i], GFP_ATOMIC);
++		status = usb_submit_urb(urbs[i], GFP_ATOMIC);
+ 		if (status < 0) {
+-			ERROR (dev, "submit iso[%d], error %d\n", i, status);
++			ERROR(dev, "submit iso[%d], error %d\n", i, status);
+ 			if (i == 0) {
+-				spin_unlock_irq (&context.lock);
++				spin_unlock_irq(&context.lock);
+ 				goto fail;
+ 			}
+ 
+-			simple_free_urb (urbs [i]);
++			simple_free_urb(urbs[i]);
+ 			urbs[i] = NULL;
+ 			context.pending--;
+ 			context.submit_error = 1;
+ 			break;
+ 		}
+ 	}
+-	spin_unlock_irq (&context.lock);
++	spin_unlock_irq(&context.lock);
+ 
+-	wait_for_completion (&context.done);
++	wait_for_completion(&context.done);
+ 
+ 	for (i = 0; i < param->sglen; i++) {
+ 		if (urbs[i])
+@@ -1526,8 +1534,8 @@ test_iso_queue (struct usbtest_dev *dev,
+ 
+ fail:
+ 	for (i = 0; i < param->sglen; i++) {
+-		if (urbs [i])
+-			simple_free_urb (urbs [i]);
++		if (urbs[i])
++			simple_free_urb(urbs[i]);
+ 	}
+ 	return status;
+ }
+@@ -1557,10 +1565,10 @@ fail:
+ 
+ /* No BKL needed */
+ static int
+-usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
++usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf)
+ {
+-	struct usbtest_dev	*dev = usb_get_intfdata (intf);
+-	struct usb_device	*udev = testdev_to_usbdev (dev);
++	struct usbtest_dev	*dev = usb_get_intfdata(intf);
++	struct usb_device	*udev = testdev_to_usbdev(dev);
+ 	struct usbtest_param	*param = buf;
+ 	int			retval = -EOPNOTSUPP;
+ 	struct urb		*urb;
+@@ -1569,7 +1577,7 @@ usbtest_ioctl (struct usb_interface *int
+ 	struct timeval		start;
+ 	unsigned		i;
+ 
+-	// FIXME USBDEVFS_CONNECTINFO doesn't say how fast the device is.
++	/* FIXME USBDEVFS_CONNECTINFO doesn't say how fast the device is. */
+ 
+ 	pattern = mod_pattern;
+ 
+@@ -1595,9 +1603,9 @@ usbtest_ioctl (struct usb_interface *int
+ 			mutex_unlock(&dev->lock);
+ 			return -ENODEV;
+ 		}
+-		res = set_altsetting (dev, dev->info->alt);
++		res = set_altsetting(dev, dev->info->alt);
+ 		if (res) {
+-			dev_err (&intf->dev,
++			dev_err(&intf->dev,
+ 					"set altsetting to %d failed, %d\n",
+ 					dev->info->alt, res);
+ 			mutex_unlock(&dev->lock);
+@@ -1614,7 +1622,7 @@ usbtest_ioctl (struct usb_interface *int
+ 	 * FIXME add more tests!  cancel requests, verify the data, control
+ 	 * queueing, concurrent read+write threads, and so on.
+ 	 */
+-	do_gettimeofday (&start);
++	do_gettimeofday(&start);
+ 	switch (param->test_num) {
+ 
+ 	case 0:
+@@ -1629,14 +1637,14 @@ usbtest_ioctl (struct usb_interface *int
+ 		dev_info(&intf->dev,
+ 				"TEST 1:  write %d bytes %u times\n",
+ 				param->length, param->iterations);
+-		urb = simple_alloc_urb (udev, dev->out_pipe, param->length);
++		urb = simple_alloc_urb(udev, dev->out_pipe, param->length);
+ 		if (!urb) {
+ 			retval = -ENOMEM;
+ 			break;
+ 		}
+-		// FIRMWARE:  bulk sink (maybe accepts short writes)
++		/* FIRMWARE:  bulk sink (maybe accepts short writes) */
+ 		retval = simple_io(dev, urb, param->iterations, 0, 0, "test1");
+-		simple_free_urb (urb);
++		simple_free_urb(urb);
+ 		break;
+ 	case 2:
+ 		if (dev->in_pipe == 0)
+@@ -1644,14 +1652,14 @@ usbtest_ioctl (struct usb_interface *int
+ 		dev_info(&intf->dev,
+ 				"TEST 2:  read %d bytes %u times\n",
+ 				param->length, param->iterations);
+-		urb = simple_alloc_urb (udev, dev->in_pipe, param->length);
++		urb = simple_alloc_urb(udev, dev->in_pipe, param->length);
+ 		if (!urb) {
+ 			retval = -ENOMEM;
+ 			break;
+ 		}
+-		// FIRMWARE:  bulk source (maybe generates short writes)
++		/* FIRMWARE:  bulk source (maybe generates short writes) */
+ 		retval = simple_io(dev, urb, param->iterations, 0, 0, "test2");
+-		simple_free_urb (urb);
++		simple_free_urb(urb);
+ 		break;
+ 	case 3:
+ 		if (dev->out_pipe == 0 || param->vary == 0)
+@@ -1659,15 +1667,15 @@ usbtest_ioctl (struct usb_interface *int
+ 		dev_info(&intf->dev,
+ 				"TEST 3:  write/%d 0..%d bytes %u times\n",
+ 				param->vary, param->length, param->iterations);
+-		urb = simple_alloc_urb (udev, dev->out_pipe, param->length);
++		urb = simple_alloc_urb(udev, dev->out_pipe, param->length);
+ 		if (!urb) {
+ 			retval = -ENOMEM;
+ 			break;
+ 		}
+-		// FIRMWARE:  bulk sink (maybe accepts short writes)
++		/* FIRMWARE:  bulk sink (maybe accepts short writes) */
+ 		retval = simple_io(dev, urb, param->iterations, param->vary,
+ 					0, "test3");
+-		simple_free_urb (urb);
++		simple_free_urb(urb);
+ 		break;
+ 	case 4:
+ 		if (dev->in_pipe == 0 || param->vary == 0)
+@@ -1675,15 +1683,15 @@ usbtest_ioctl (struct usb_interface *int
+ 		dev_info(&intf->dev,
+ 				"TEST 4:  read/%d 0..%d bytes %u times\n",
+ 				param->vary, param->length, param->iterations);
+-		urb = simple_alloc_urb (udev, dev->in_pipe, param->length);
++		urb = simple_alloc_urb(udev, dev->in_pipe, param->length);
+ 		if (!urb) {
+ 			retval = -ENOMEM;
+ 			break;
+ 		}
+-		// FIRMWARE:  bulk source (maybe generates short writes)
++		/* FIRMWARE:  bulk source (maybe generates short writes) */
+ 		retval = simple_io(dev, urb, param->iterations, param->vary,
+ 					0, "test4");
+-		simple_free_urb (urb);
++		simple_free_urb(urb);
+ 		break;
+ 
+ 	/* Queued bulk I/O tests */
+@@ -1694,15 +1702,15 @@ usbtest_ioctl (struct usb_interface *int
+ 			"TEST 5:  write %d sglists %d entries of %d bytes\n",
+ 				param->iterations,
+ 				param->sglen, param->length);
+-		sg = alloc_sglist (param->sglen, param->length, 0);
++		sg = alloc_sglist(param->sglen, param->length, 0);
+ 		if (!sg) {
+ 			retval = -ENOMEM;
+ 			break;
+ 		}
+-		// FIRMWARE:  bulk sink (maybe accepts short writes)
++		/* FIRMWARE:  bulk sink (maybe accepts short writes) */
+ 		retval = perform_sglist(dev, param->iterations, dev->out_pipe,
+ 				&req, sg, param->sglen);
+-		free_sglist (sg, param->sglen);
++		free_sglist(sg, param->sglen);
+ 		break;
+ 
+ 	case 6:
+@@ -1712,15 +1720,15 @@ usbtest_ioctl (struct usb_interface *int
+ 			"TEST 6:  read %d sglists %d entries of %d bytes\n",
+ 				param->iterations,
+ 				param->sglen, param->length);
+-		sg = alloc_sglist (param->sglen, param->length, 0);
++		sg = alloc_sglist(param->sglen, param->length, 0);
+ 		if (!sg) {
+ 			retval = -ENOMEM;
+ 			break;
+ 		}
+-		// FIRMWARE:  bulk source (maybe generates short writes)
++		/* FIRMWARE:  bulk source (maybe generates short writes) */
+ 		retval = perform_sglist(dev, param->iterations, dev->in_pipe,
+ 				&req, sg, param->sglen);
+-		free_sglist (sg, param->sglen);
++		free_sglist(sg, param->sglen);
+ 		break;
+ 	case 7:
+ 		if (dev->out_pipe == 0 || param->sglen == 0 || param->vary == 0)
+@@ -1729,15 +1737,15 @@ usbtest_ioctl (struct usb_interface *int
+ 			"TEST 7:  write/%d %d sglists %d entries 0..%d bytes\n",
+ 				param->vary, param->iterations,
+ 				param->sglen, param->length);
+-		sg = alloc_sglist (param->sglen, param->length, param->vary);
++		sg = alloc_sglist(param->sglen, param->length, param->vary);
+ 		if (!sg) {
+ 			retval = -ENOMEM;
+ 			break;
+ 		}
+-		// FIRMWARE:  bulk sink (maybe accepts short writes)
++		/* FIRMWARE:  bulk sink (maybe accepts short writes) */
+ 		retval = perform_sglist(dev, param->iterations, dev->out_pipe,
+ 				&req, sg, param->sglen);
+-		free_sglist (sg, param->sglen);
++		free_sglist(sg, param->sglen);
+ 		break;
+ 	case 8:
+ 		if (dev->in_pipe == 0 || param->sglen == 0 || param->vary == 0)
+@@ -1746,15 +1754,15 @@ usbtest_ioctl (struct usb_interface *int
+ 			"TEST 8:  read/%d %d sglists %d entries 0..%d bytes\n",
+ 				param->vary, param->iterations,
+ 				param->sglen, param->length);
+-		sg = alloc_sglist (param->sglen, param->length, param->vary);
++		sg = alloc_sglist(param->sglen, param->length, param->vary);
+ 		if (!sg) {
+ 			retval = -ENOMEM;
+ 			break;
+ 		}
+-		// FIRMWARE:  bulk source (maybe generates short writes)
++		/* FIRMWARE:  bulk source (maybe generates short writes) */
+ 		retval = perform_sglist(dev, param->iterations, dev->in_pipe,
+ 				&req, sg, param->sglen);
+-		free_sglist (sg, param->sglen);
++		free_sglist(sg, param->sglen);
+ 		break;
+ 
+ 	/* non-queued sanity tests for control (chapter 9 subset) */
+@@ -1764,7 +1772,7 @@ usbtest_ioctl (struct usb_interface *int
+ 			"TEST 9:  ch9 (subset) control tests, %d times\n",
+ 				param->iterations);
+ 		for (i = param->iterations; retval == 0 && i--; /* NOP */)
+-			retval = ch9_postconfig (dev);
++			retval = ch9_postconfig(dev);
+ 		if (retval)
+ 			dev_err(&intf->dev, "ch9 subset failed, "
+ 					"iterations left %d\n", i);
+@@ -1779,7 +1787,7 @@ usbtest_ioctl (struct usb_interface *int
+ 				"TEST 10:  queue %d control calls, %d times\n",
+ 				param->sglen,
+ 				param->iterations);
+-		retval = test_ctrl_queue (dev, param);
++		retval = test_ctrl_queue(dev, param);
+ 		break;
+ 
+ 	/* simple non-queued unlinks (ring with one urb) */
+@@ -1790,7 +1798,7 @@ usbtest_ioctl (struct usb_interface *int
+ 		dev_info(&intf->dev, "TEST 11:  unlink %d reads of %d\n",
+ 				param->iterations, param->length);
+ 		for (i = param->iterations; retval == 0 && i--; /* NOP */)
+-			retval = unlink_simple (dev, dev->in_pipe,
++			retval = unlink_simple(dev, dev->in_pipe,
+ 						param->length);
+ 		if (retval)
+ 			dev_err(&intf->dev, "unlink reads failed %d, "
+@@ -1803,7 +1811,7 @@ usbtest_ioctl (struct usb_interface *int
+ 		dev_info(&intf->dev, "TEST 12:  unlink %d writes of %d\n",
+ 				param->iterations, param->length);
+ 		for (i = param->iterations; retval == 0 && i--; /* NOP */)
+-			retval = unlink_simple (dev, dev->out_pipe,
++			retval = unlink_simple(dev, dev->out_pipe,
+ 						param->length);
+ 		if (retval)
+ 			dev_err(&intf->dev, "unlink writes failed %d, "
+@@ -1818,7 +1826,7 @@ usbtest_ioctl (struct usb_interface *int
+ 		dev_info(&intf->dev, "TEST 13:  set/clear %d halts\n",
+ 				param->iterations);
+ 		for (i = param->iterations; retval == 0 && i--; /* NOP */)
+-			retval = halt_simple (dev);
++			retval = halt_simple(dev);
+ 
+ 		if (retval)
+ 			ERROR(dev, "halts failed, iterations left %d\n", i);
+@@ -1844,8 +1852,8 @@ usbtest_ioctl (struct usb_interface *int
+ 			"TEST 15:  write %d iso, %d entries of %d bytes\n",
+ 				param->iterations,
+ 				param->sglen, param->length);
+-		// FIRMWARE:  iso sink
+-		retval = test_iso_queue (dev, param,
++		/* FIRMWARE:  iso sink */
++		retval = test_iso_queue(dev, param,
+ 				dev->out_iso_pipe, dev->iso_out);
+ 		break;
+ 
+@@ -1857,17 +1865,17 @@ usbtest_ioctl (struct usb_interface *int
+ 			"TEST 16:  read %d iso, %d entries of %d bytes\n",
+ 				param->iterations,
+ 				param->sglen, param->length);
+-		// FIRMWARE:  iso source
+-		retval = test_iso_queue (dev, param,
++		/* FIRMWARE:  iso source */
++		retval = test_iso_queue(dev, param,
+ 				dev->in_iso_pipe, dev->iso_in);
+ 		break;
+ 
+-	// FIXME unlink from queue (ring with N urbs)
++	/* FIXME unlink from queue (ring with N urbs) */
+ 
+-	// FIXME scatterlist cancel (needs helper thread)
++	/* FIXME scatterlist cancel (needs helper thread) */
+ 
+ 	}
+-	do_gettimeofday (&param->duration);
++	do_gettimeofday(&param->duration);
+ 	param->duration.tv_sec -= start.tv_sec;
+ 	param->duration.tv_usec -= start.tv_usec;
+ 	if (param->duration.tv_usec < 0) {
+@@ -1880,22 +1888,22 @@ usbtest_ioctl (struct usb_interface *int
+ 
+ /*-------------------------------------------------------------------------*/
+ 
+-static unsigned force_interrupt = 0;
+-module_param (force_interrupt, uint, 0);
+-MODULE_PARM_DESC (force_interrupt, "0 = test default; else interrupt");
++static unsigned force_interrupt;
++module_param(force_interrupt, uint, 0);
++MODULE_PARM_DESC(force_interrupt, "0 = test default; else interrupt");
+ 
+ #ifdef	GENERIC
+ static unsigned short vendor;
+ module_param(vendor, ushort, 0);
+-MODULE_PARM_DESC (vendor, "vendor code (from usb-if)");
++MODULE_PARM_DESC(vendor, "vendor code (from usb-if)");
+ 
+ static unsigned short product;
+ module_param(product, ushort, 0);
+-MODULE_PARM_DESC (product, "product code (from vendor)");
++MODULE_PARM_DESC(product, "product code (from vendor)");
+ #endif
+ 
+ static int
+-usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
++usbtest_probe(struct usb_interface *intf, const struct usb_device_id *id)
+ {
+ 	struct usb_device	*udev;
+ 	struct usbtest_dev	*dev;
+@@ -1903,7 +1911,7 @@ usbtest_probe (struct usb_interface *int
+ 	char			*rtest, *wtest;
+ 	char			*irtest, *iwtest;
+ 
+-	udev = interface_to_usbdev (intf);
++	udev = interface_to_usbdev(intf);
+ 
+ #ifdef	GENERIC
+ 	/* specify devices by module parameters? */
+@@ -1930,8 +1938,9 @@ usbtest_probe (struct usb_interface *int
+ 	dev->intf = intf;
+ 
+ 	/* cacheline-aligned scratch for i/o */
+-	if ((dev->buf = kmalloc (TBUF_SIZE, GFP_KERNEL)) == NULL) {
+-		kfree (dev);
++	dev->buf = kmalloc(TBUF_SIZE, GFP_KERNEL);
++	if (dev->buf == NULL) {
++		kfree(dev);
+ 		return -ENOMEM;
+ 	}
+ 
+@@ -1943,18 +1952,18 @@ usbtest_probe (struct usb_interface *int
+ 	irtest = iwtest = "";
+ 	if (force_interrupt || udev->speed == USB_SPEED_LOW) {
+ 		if (info->ep_in) {
+-			dev->in_pipe = usb_rcvintpipe (udev, info->ep_in);
++			dev->in_pipe = usb_rcvintpipe(udev, info->ep_in);
+ 			rtest = " intr-in";
+ 		}
+ 		if (info->ep_out) {
+-			dev->out_pipe = usb_sndintpipe (udev, info->ep_out);
++			dev->out_pipe = usb_sndintpipe(udev, info->ep_out);
+ 			wtest = " intr-out";
+ 		}
+ 	} else {
+ 		if (info->autoconf) {
+ 			int status;
+ 
+-			status = get_endpoints (dev, intf);
++			status = get_endpoints(dev, intf);
+ 			if (status < 0) {
+ 				WARNING(dev, "couldn't get endpoints, %d\n",
+ 						status);
+@@ -1963,10 +1972,10 @@ usbtest_probe (struct usb_interface *int
+ 			/* may find bulk or ISO pipes */
+ 		} else {
+ 			if (info->ep_in)
+-				dev->in_pipe = usb_rcvbulkpipe (udev,
++				dev->in_pipe = usb_rcvbulkpipe(udev,
+ 							info->ep_in);
+ 			if (info->ep_out)
+-				dev->out_pipe = usb_sndbulkpipe (udev,
++				dev->out_pipe = usb_sndbulkpipe(udev,
+ 							info->ep_out);
+ 		}
+ 		if (dev->in_pipe)
+@@ -1979,15 +1988,23 @@ usbtest_probe (struct usb_interface *int
+ 			iwtest = " iso-out";
+ 	}
+ 
+-	usb_set_intfdata (intf, dev);
+-	dev_info (&intf->dev, "%s\n", info->name);
+-	dev_info (&intf->dev, "%s speed {control%s%s%s%s%s} tests%s\n",
++	usb_set_intfdata(intf, dev);
++	dev_info(&intf->dev, "%s\n", info->name);
++	dev_info(&intf->dev, "%s speed {control%s%s%s%s%s} tests%s\n",
+ 			({ char *tmp;
+ 			switch (udev->speed) {
+-			case USB_SPEED_LOW: tmp = "low"; break;
+-			case USB_SPEED_FULL: tmp = "full"; break;
+-			case USB_SPEED_HIGH: tmp = "high"; break;
+-			default: tmp = "unknown"; break;
++			case USB_SPEED_LOW:
++				tmp = "low";
++				break;
++			case USB_SPEED_FULL:
++				tmp = "full";
++				break;
++			case USB_SPEED_HIGH:
++				tmp = "high";
++				break;
++			default:
++				tmp = "unknown";
++				break;
+ 			}; tmp; }),
+ 			info->ctrl_out ? " in/out" : "",
+ 			rtest, wtest,
+@@ -1996,24 +2013,24 @@ usbtest_probe (struct usb_interface *int
+ 	return 0;
+ }
+ 
+-static int usbtest_suspend (struct usb_interface *intf, pm_message_t message)
++static int usbtest_suspend(struct usb_interface *intf, pm_message_t message)
+ {
+ 	return 0;
+ }
+ 
+-static int usbtest_resume (struct usb_interface *intf)
++static int usbtest_resume(struct usb_interface *intf)
+ {
+ 	return 0;
+ }
+ 
+ 
+-static void usbtest_disconnect (struct usb_interface *intf)
++static void usbtest_disconnect(struct usb_interface *intf)
+ {
+-	struct usbtest_dev	*dev = usb_get_intfdata (intf);
++	struct usbtest_dev	*dev = usb_get_intfdata(intf);
+ 
+-	usb_set_intfdata (intf, NULL);
+-	dev_dbg (&intf->dev, "disconnect\n");
+-	kfree (dev);
++	usb_set_intfdata(intf, NULL);
++	dev_dbg(&intf->dev, "disconnect\n");
++	kfree(dev);
+ }
+ 
+ /* Basic testing only needs a device that can source or sink bulk traffic.
+@@ -2050,9 +2067,9 @@ static struct usbtest_info fw_info = {
+ 	.ep_in		= 2,
+ 	.ep_out		= 2,
+ 	.alt		= 1,
+-	.autoconf	= 1,		// iso and ctrl_out need autoconf
++	.autoconf	= 1,		/* iso and ctrl_out need autoconf */
+ 	.ctrl_out	= 1,
+-	.iso		= 1,		// iso_ep's are #8 in/out
++	.iso		= 1,		/* iso_ep's are #8 in/out */
+ };
+ 
+ /* peripheral running Linux and 'zero.c' test firmware, or
+@@ -2109,56 +2126,56 @@ static const struct usb_device_id id_tab
+ 	 */
+ 
+ 	/* generic EZ-USB FX controller */
+-	{ USB_DEVICE (0x0547, 0x2235),
++	{ USB_DEVICE(0x0547, 0x2235),
+ 		.driver_info = (unsigned long) &ez1_info,
+-		},
++	},
+ 
+ 	/* CY3671 development board with EZ-USB FX */
+-	{ USB_DEVICE (0x0547, 0x0080),
++	{ USB_DEVICE(0x0547, 0x0080),
+ 		.driver_info = (unsigned long) &ez1_info,
+-		},
++	},
+ 
+ 	/* generic EZ-USB FX2 controller (or development board) */
+-	{ USB_DEVICE (0x04b4, 0x8613),
++	{ USB_DEVICE(0x04b4, 0x8613),
+ 		.driver_info = (unsigned long) &ez2_info,
+-		},
++	},
+ 
+ 	/* re-enumerated usb test device firmware */
+-	{ USB_DEVICE (0xfff0, 0xfff0),
++	{ USB_DEVICE(0xfff0, 0xfff0),
+ 		.driver_info = (unsigned long) &fw_info,
+-		},
++	},
+ 
+ 	/* "Gadget Zero" firmware runs under Linux */
+-	{ USB_DEVICE (0x0525, 0xa4a0),
++	{ USB_DEVICE(0x0525, 0xa4a0),
+ 		.driver_info = (unsigned long) &gz_info,
+-		},
++	},
+ 
+ 	/* so does a user-mode variant */
+-	{ USB_DEVICE (0x0525, 0xa4a4),
++	{ USB_DEVICE(0x0525, 0xa4a4),
+ 		.driver_info = (unsigned long) &um_info,
+-		},
++	},
+ 
+ 	/* ... and a user-mode variant that talks iso */
+-	{ USB_DEVICE (0x0525, 0xa4a3),
++	{ USB_DEVICE(0x0525, 0xa4a3),
+ 		.driver_info = (unsigned long) &um2_info,
+-		},
++	},
+ 
+ #ifdef KEYSPAN_19Qi
+ 	/* Keyspan 19qi uses an21xx (original EZ-USB) */
+-	// this does not coexist with the real Keyspan 19qi driver!
+-	{ USB_DEVICE (0x06cd, 0x010b),
++	/* this does not coexist with the real Keyspan 19qi driver! */
++	{ USB_DEVICE(0x06cd, 0x010b),
+ 		.driver_info = (unsigned long) &ez1_info,
+-		},
++	},
+ #endif
+ 
+ 	/*-------------------------------------------------------------*/
+ 
+ #ifdef IBOT2
+ 	/* iBOT2 makes a nice source of high speed bulk-in data */
+-	// this does not coexist with a real iBOT2 driver!
+-	{ USB_DEVICE (0x0b62, 0x0059),
++	/* this does not coexist with a real iBOT2 driver! */
++	{ USB_DEVICE(0x0b62, 0x0059),
+ 		.driver_info = (unsigned long) &ibot2_info,
+-		},
++	},
+ #endif
+ 
+ 	/*-------------------------------------------------------------*/
+@@ -2172,7 +2189,7 @@ static const struct usb_device_id id_tab
+ 
+ 	{ }
+ };
+-MODULE_DEVICE_TABLE (usb, id_table);
++MODULE_DEVICE_TABLE(usb, id_table);
+ 
+ static struct usb_driver usbtest_driver = {
+ 	.name =		"usbtest",
+@@ -2186,22 +2203,22 @@ static struct usb_driver usbtest_driver
+ 
+ /*-------------------------------------------------------------------------*/
+ 
+-static int __init usbtest_init (void)
++static int __init usbtest_init(void)
+ {
+ #ifdef GENERIC
+ 	if (vendor)
+ 		pr_debug("params: vend=0x%04x prod=0x%04x\n", vendor, product);
+ #endif
+-	return usb_register (&usbtest_driver);
++	return usb_register(&usbtest_driver);
+ }
+-module_init (usbtest_init);
++module_init(usbtest_init);
+ 
+-static void __exit usbtest_exit (void)
++static void __exit usbtest_exit(void)
+ {
+-	usb_deregister (&usbtest_driver);
++	usb_deregister(&usbtest_driver);
+ }
+-module_exit (usbtest_exit);
++module_exit(usbtest_exit);
+ 
+-MODULE_DESCRIPTION ("USB Core/HCD Testing Driver");
+-MODULE_LICENSE ("GPL");
++MODULE_DESCRIPTION("USB Core/HCD Testing Driver");
++MODULE_LICENSE("GPL");
+
author	Greg Kroah-Hartman <gregkh@suse.de>	2010-10-05 16:17:56 -0700
committer	Greg Kroah-Hartman <gregkh@suse.de>	2010-10-05 16:17:56 -0700
commit	eaaaa915fb5d26d4fbd71f1a9c9a5b9f07e6fef7 (patch)
tree	f840d84def75d831ae77b2740d39411573061102 /usb
parent	8c5c1508efaea4a39c857735bf23707cbd88ac22 (diff)
download	patches-eaaaa915fb5d26d4fbd71f1a9c9a5b9f07e6fef7.tar.gz