diff options
Diffstat (limited to 'usb')
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 (¶m->duration); ++ do_gettimeofday(¶m->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"); + |