--- /dev/null
+diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
+index 6e784d2..117d0c7 100644
+--- a/drivers/usb/gadget/Kconfig
++++ b/drivers/usb/gadget/Kconfig
+@@ -118,10 +118,10 @@ config USB_AMD5536UDC
+ config USB_GADGET_ATMEL_USBA
+ boolean "Atmel USBA"
+ select USB_GADGET_DUALSPEED
+- depends on AVR32 || ARCH_AT91CAP9
++ depends on AVR32 || ARCH_AT91CAP9 || ARCH_AT91SAM9RL
+ help
+ USBA is the integrated high-speed USB Device controller on
+- the AT32AP700x and AT91CAP9 processors from Atmel.
++ the AT32AP700x, some AT91SAM9 and AT91CAP9 processors from Atmel.
+
+ config USB_ATMEL_USBA
+ tristate
+@@ -172,7 +172,7 @@ config USB_NET2280
+ default USB_GADGET
+ select USB_GADGET_SELECTED
+
+-config USB_GADGET_PXA2XX
++config USB_GADGET_PXA25X
+ boolean "PXA 25x or IXP 4xx"
+ depends on (ARCH_PXA && PXA25x) || ARCH_IXP4XX
+ help
+@@ -184,19 +184,19 @@ config USB_GADGET_PXA2XX
+ zero (for control transfers).
+
+ Say "y" to link the driver statically, or "m" to build a
+- dynamically linked module called "pxa2xx_udc" and force all
++ dynamically linked module called "pxa25x_udc" and force all
+ gadget drivers to also be dynamically linked.
+
+-config USB_PXA2XX
++config USB_PXA25X
+ tristate
+- depends on USB_GADGET_PXA2XX
++ depends on USB_GADGET_PXA25X
+ default USB_GADGET
+ select USB_GADGET_SELECTED
+
+ # if there's only one gadget driver, using only two bulk endpoints,
+ # don't waste memory for the other endpoints
+-config USB_PXA2XX_SMALL
+- depends on USB_GADGET_PXA2XX
++config USB_PXA25X_SMALL
++ depends on USB_GADGET_PXA25X
+ bool
+ default n if USB_ETH_RNDIS
+ default y if USB_ZERO
+@@ -284,6 +284,16 @@ config USB_LH7A40X
+ default USB_GADGET
+ select USB_GADGET_SELECTED
+
++# built in ../musb along with host support
++config USB_GADGET_MUSB_HDRC
++ boolean "Inventra HDRC USB Peripheral (TI, ...)"
++ depends on USB_MUSB_HDRC && (USB_MUSB_PERIPHERAL || USB_MUSB_OTG)
++ select USB_GADGET_DUALSPEED
++ select USB_GADGET_SELECTED
++ help
++ This OTG-capable silicon IP is used in dual designs including
++ the TI DaVinci, OMAP 243x, OMAP 343x, and TUSB 6010.
++
+ config USB_GADGET_OMAP
+ boolean "OMAP USB Device Controller"
+ depends on ARCH_OMAP
+@@ -355,6 +365,20 @@ config USB_AT91
+ depends on USB_GADGET_AT91
+ default USB_GADGET
+
++config USB_GADGET_SA1100
++ boolean "SA1100 USB Device Port"
++ depends on ARCH_SA1100
++ help
++ Say "y" to link the driver statically, or "m" to build a
++ dynamically linked module called "sa1100_udc" and force all
++ gadget drivers to also be dynamically linked.
++
++config USB_SA1100
++ tristate
++ depends on USB_GADGET_SA1100
++ default USB_GADGET
++ select USB_GADGET_SELECTED
++
+ config USB_GADGET_DUMMY_HCD
+ boolean "Dummy HCD (DEVELOPMENT)"
+ depends on USB=y || (USB=m && USB_GADGET=m)
+@@ -504,6 +528,20 @@ config USB_ETH_RNDIS
+ XP, you'll need to download drivers from Microsoft's website; a URL
+ is given in comments found in that info file.
+
++config USB_ETH_NO_MDLM
++ bool "Disable MDLM support for CDC_SUBSET"
++ depends on USB_ETH
++ default n
++ help
++ A variation on CDC_SUBSET support is used in newer kernel
++ implementations for use with a proprietary Microsoft Windows driver
++ used for example with the Zaurus linux distribution.
++ However, the MDLM extensions break the older host side drivers making
++ g_ether incompatible with older kernels.
++
++ If you say "y" here, the Ethernet gadget driver will use the older
++ pre-MDLM extensions.
++
+ config USB_GADGETFS
+ tristate "Gadget Filesystem (EXPERIMENTAL)"
+ depends on EXPERIMENTAL
+@@ -586,6 +624,20 @@ config USB_G_PRINTER
+ For more information, see Documentation/usb/gadget_printer.txt
+ which includes sample code for accessing the device file.
+
++config USB_CDC_COMPOSITE
++ tristate "CDC Composite Device (Ethernet and ACM)"
++ depends on NET
++ help
++ This driver provides two functions in one configuration:
++ a CDC Ethernet (ECM) link, and a CDC ACM (serial port) link.
++
++ This driver requires four bulk and two interrupt endpoints,
++ plus the ability to handle altsettings. Not all peripheral
++ controllers are that capable.
++
++ Say "y" to link the driver statically, or "m" to build a
++ dynamically linked module.
++
+ # put drivers that need isochronous transfer support (for audio
+ # or video class gadget drivers), or specific hardware, here.
+
+diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
+index 1235725..79a69ae 100644
+--- a/drivers/usb/gadget/Makefile
++++ b/drivers/usb/gadget/Makefile
+@@ -8,7 +8,7 @@ endif
+ obj-$(CONFIG_USB_DUMMY_HCD) += dummy_hcd.o
+ obj-$(CONFIG_USB_NET2280) += net2280.o
+ obj-$(CONFIG_USB_AMD5536UDC) += amd5536udc.o
+-obj-$(CONFIG_USB_PXA2XX) += pxa2xx_udc.o
++obj-$(CONFIG_USB_PXA25X) += pxa25x_udc.o
+ obj-$(CONFIG_USB_PXA27X) += pxa27x_udc.o
+ obj-$(CONFIG_USB_GOKU) += goku_udc.o
+ obj-$(CONFIG_USB_OMAP) += omap_udc.o
+@@ -18,22 +18,27 @@ obj-$(CONFIG_USB_AT91) += at91_udc.o
+ obj-$(CONFIG_USB_ATMEL_USBA) += atmel_usba_udc.o
+ obj-$(CONFIG_USB_FSL_USB2) += fsl_usb2_udc.o
+ obj-$(CONFIG_USB_M66592) += m66592-udc.o
++obj-$(CONFIG_USB_SA1100) += sa1100_udc.o
+
+ #
+ # USB gadget drivers
+ #
+-g_zero-objs := zero.o usbstring.o config.o epautoconf.o
+-g_ether-objs := ether.o usbstring.o config.o epautoconf.o
+-g_serial-objs := serial.o usbstring.o config.o epautoconf.o
++C_UTILS = composite.o usbstring.o config.o epautoconf.o
++
++g_zero-objs := zero.o f_sourcesink.o f_loopback.o $(C_UTILS)
++g_ether-objs := ether.o u_ether.o f_subset.o f_ecm.o $(C_UTILS)
++g_serial-objs := serial.o u_serial.o f_acm.o f_serial.o $(C_UTILS)
+ g_midi-objs := gmidi.o usbstring.o config.o epautoconf.o
+ gadgetfs-objs := inode.o
+ g_file_storage-objs := file_storage.o usbstring.o config.o \
+ epautoconf.o
+ g_printer-objs := printer.o usbstring.o config.o \
+ epautoconf.o
++g_cdc-objs := cdc2.o u_ether.o f_ecm.o \
++ u_serial.o f_acm.o $(C_UTILS)
+
+ ifeq ($(CONFIG_USB_ETH_RNDIS),y)
+- g_ether-objs += rndis.o
++ g_ether-objs += f_rndis.o rndis.o
+ endif
+
+ obj-$(CONFIG_USB_ZERO) += g_zero.o
+@@ -43,4 +48,5 @@ obj-$(CONFIG_USB_FILE_STORAGE) += g_file_storage.o
+ obj-$(CONFIG_USB_G_SERIAL) += g_serial.o
+ obj-$(CONFIG_USB_G_PRINTER) += g_printer.o
+ obj-$(CONFIG_USB_MIDI_GADGET) += g_midi.o
++obj-$(CONFIG_USB_CDC_COMPOSITE) += g_cdc.o
+
+diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
+index f261d2a..abf8192 100644
+--- a/drivers/usb/gadget/amd5536udc.c
++++ b/drivers/usb/gadget/amd5536udc.c
+@@ -44,7 +44,6 @@
+ #include <linux/module.h>
+ #include <linux/pci.h>
+ #include <linux/kernel.h>
+-#include <linux/version.h>
+ #include <linux/delay.h>
+ #include <linux/ioport.h>
+ #include <linux/sched.h>
+@@ -3342,7 +3341,7 @@ static int udc_probe(struct udc *dev)
+ spin_lock_init(&dev->lock);
+ dev->gadget.ops = &udc_ops;
+
+- strcpy(dev->gadget.dev.bus_id, "gadget");
++ dev_set_name(&dev->gadget.dev, "gadget");
+ dev->gadget.dev.release = gadget_release;
+ dev->gadget.name = name;
+ dev->gadget.name = name;
+diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
+index 274c60a..a8a1de4 100644
+--- a/drivers/usb/gadget/at91_udc.c
++++ b/drivers/usb/gadget/at91_udc.c
+@@ -40,16 +40,15 @@
+ #include <linux/usb/gadget.h>
+
+ #include <asm/byteorder.h>
+-#include <asm/hardware.h>
++#include <mach/hardware.h>
+ #include <asm/io.h>
+ #include <asm/irq.h>
+ #include <asm/system.h>
+-#include <asm/mach-types.h>
+ #include <asm/gpio.h>
+
+-#include <asm/arch/board.h>
+-#include <asm/arch/cpu.h>
+-#include <asm/arch/at91sam9261_matrix.h>
++#include <mach/board.h>
++#include <mach/cpu.h>
++#include <mach/at91sam9261_matrix.h>
+
+ #include "at91_udc.h"
+
+@@ -888,7 +887,7 @@ static void pullup(struct at91_udc *udc, int is_on)
+ at91_udp_write(udc, AT91_UDP_TXVC, 0);
+ if (cpu_is_at91rm9200())
+ gpio_set_value(udc->board.pullup_pin, active);
+- else if (cpu_is_at91sam9260() || cpu_is_at91sam9263()) {
++ else if (cpu_is_at91sam9260() || cpu_is_at91sam9263() || cpu_is_at91sam9g20()) {
+ u32 txvc = at91_udp_read(udc, AT91_UDP_TXVC);
+
+ txvc |= AT91_UDP_TXVC_PUON;
+@@ -906,7 +905,7 @@ static void pullup(struct at91_udc *udc, int is_on)
+ at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
+ if (cpu_is_at91rm9200())
+ gpio_set_value(udc->board.pullup_pin, !active);
+- else if (cpu_is_at91sam9260() || cpu_is_at91sam9263()) {
++ else if (cpu_is_at91sam9260() || cpu_is_at91sam9263() || cpu_is_at91sam9g20()) {
+ u32 txvc = at91_udp_read(udc, AT91_UDP_TXVC);
+
+ txvc &= ~AT91_UDP_TXVC_PUON;
+@@ -1687,6 +1686,19 @@ static int __init at91udc_probe(struct platform_device *pdev)
+ udc->board.pullup_active_low);
+ }
+
++ /* newer chips have more FIFO memory than rm9200 */
++ if (cpu_is_at91sam9260()) {
++ udc->ep[0].maxpacket = 64;
++ udc->ep[3].maxpacket = 64;
++ udc->ep[4].maxpacket = 512;
++ udc->ep[5].maxpacket = 512;
++ } else if (cpu_is_at91sam9261()) {
++ udc->ep[3].maxpacket = 64;
++ } else if (cpu_is_at91sam9263()) {
++ udc->ep[0].maxpacket = 64;
++ udc->ep[3].maxpacket = 64;
++ }
++
+ udc->udp_baseaddr = ioremap(res->start, res->end - res->start + 1);
+ if (!udc->udp_baseaddr) {
+ retval = -ENOMEM;
+diff --git a/drivers/usb/gadget/at91_udc.h b/drivers/usb/gadget/at91_udc.h
+index a973f2a..c65d622 100644
+--- a/drivers/usb/gadget/at91_udc.h
++++ b/drivers/usb/gadget/at91_udc.h
+@@ -171,7 +171,7 @@ struct at91_request {
+ #endif
+
+ #define ERR(stuff...) pr_err("udc: " stuff)
+-#define WARN(stuff...) pr_warning("udc: " stuff)
++#define WARNING(stuff...) pr_warning("udc: " stuff)
+ #define INFO(stuff...) pr_info("udc: " stuff)
+ #define DBG(stuff...) pr_debug("udc: " stuff)
+
+diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
+index 07e5a0b..ae30ab1 100644
+--- a/drivers/usb/gadget/atmel_usba_udc.c
++++ b/drivers/usb/gadget/atmel_usba_udc.c
+@@ -22,7 +22,7 @@
+ #include <linux/delay.h>
+
+ #include <asm/gpio.h>
+-#include <asm/arch/board.h>
++#include <mach/board.h>
+
+ #include "atmel_usba_udc.h"
+
+@@ -334,7 +334,7 @@ static void toggle_bias(int is_on)
+
+ #elif defined(CONFIG_ARCH_AT91)
+
+-#include <asm/arch/at91_pmc.h>
++#include <mach/at91_pmc.h>
+
+ static void toggle_bias(int is_on)
+ {
+diff --git a/drivers/usb/gadget/cdc2.c b/drivers/usb/gadget/cdc2.c
+new file mode 100644
+index 0000000..a39a4b9
+--- /dev/null
++++ b/drivers/usb/gadget/cdc2.c
+@@ -0,0 +1,246 @@
++/*
++ * cdc2.c -- CDC Composite driver, with ECM and ACM support
++ *
++ * Copyright (C) 2008 David Brownell
++ * Copyright (C) 2008 Nokia Corporation
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++#include <linux/kernel.h>
++#include <linux/utsname.h>
++
++#include "u_ether.h"
++#include "u_serial.h"
++
++
++#define DRIVER_DESC "CDC Composite Gadget"
++#define DRIVER_VERSION "King Kamehameha Day 2008"
++
++/*-------------------------------------------------------------------------*/
++
++/* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
++ * Instead: allocate your own, using normal USB-IF procedures.
++ */
++
++/* Thanks to NetChip Technologies for donating this product ID.
++ * It's for devices with only this composite CDC configuration.
++ */
++#define CDC_VENDOR_NUM 0x0525 /* NetChip */
++#define CDC_PRODUCT_NUM 0xa4aa /* CDC Composite: ECM + ACM */
++
++/*-------------------------------------------------------------------------*/
++
++static struct usb_device_descriptor device_desc = {
++ .bLength = sizeof device_desc,
++ .bDescriptorType = USB_DT_DEVICE,
++
++ .bcdUSB = __constant_cpu_to_le16(0x0200),
++
++ .bDeviceClass = USB_CLASS_COMM,
++ .bDeviceSubClass = 0,
++ .bDeviceProtocol = 0,
++ /* .bMaxPacketSize0 = f(hardware) */
++
++ /* Vendor and product id can be overridden by module parameters. */
++ .idVendor = __constant_cpu_to_le16(CDC_VENDOR_NUM),
++ .idProduct = __constant_cpu_to_le16(CDC_PRODUCT_NUM),
++ /* .bcdDevice = f(hardware) */
++ /* .iManufacturer = DYNAMIC */
++ /* .iProduct = DYNAMIC */
++ /* NO SERIAL NUMBER */
++ .bNumConfigurations = 1,
++};
++
++static struct usb_otg_descriptor otg_descriptor = {
++ .bLength = sizeof otg_descriptor,
++ .bDescriptorType = USB_DT_OTG,
++
++ /* REVISIT SRP-only hardware is possible, although
++ * it would not be called "OTG" ...
++ */
++ .bmAttributes = USB_OTG_SRP | USB_OTG_HNP,
++};
++
++static const struct usb_descriptor_header *otg_desc[] = {
++ (struct usb_descriptor_header *) &otg_descriptor,
++ NULL,
++};
++
++
++/* string IDs are assigned dynamically */
++
++#define STRING_MANUFACTURER_IDX 0
++#define STRING_PRODUCT_IDX 1
++
++static char manufacturer[50];
++
++static struct usb_string strings_dev[] = {
++ [STRING_MANUFACTURER_IDX].s = manufacturer,
++ [STRING_PRODUCT_IDX].s = DRIVER_DESC,
++ { } /* end of list */
++};
++
++static struct usb_gadget_strings stringtab_dev = {
++ .language = 0x0409, /* en-us */
++ .strings = strings_dev,
++};
++
++static struct usb_gadget_strings *dev_strings[] = {
++ &stringtab_dev,
++ NULL,
++};
++
++static u8 hostaddr[ETH_ALEN];
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * We _always_ have both CDC ECM and CDC ACM functions.
++ */
++static int __init cdc_do_config(struct usb_configuration *c)
++{
++ int status;
++
++ if (gadget_is_otg(c->cdev->gadget)) {
++ c->descriptors = otg_desc;
++ c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
++ }
++
++ status = ecm_bind_config(c, hostaddr);
++ if (status < 0)
++ return status;
++
++ status = acm_bind_config(c, 0);
++ if (status < 0)
++ return status;
++
++ return 0;
++}
++
++static struct usb_configuration cdc_config_driver = {
++ .label = "CDC Composite (ECM + ACM)",
++ .bind = cdc_do_config,
++ .bConfigurationValue = 1,
++ /* .iConfiguration = DYNAMIC */
++ .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
++ .bMaxPower = 1, /* 2 mA, minimal */
++};
++
++/*-------------------------------------------------------------------------*/
++
++static int __init cdc_bind(struct usb_composite_dev *cdev)
++{
++ int gcnum;
++ struct usb_gadget *gadget = cdev->gadget;
++ int status;
++
++ if (!can_support_ecm(cdev->gadget)) {
++ ERROR(cdev, "controller '%s' not usable\n", gadget->name);
++ return -EINVAL;
++ }
++
++ /* set up network link layer */
++ status = gether_setup(cdev->gadget, hostaddr);
++ if (status < 0)
++ return status;
++
++ /* set up serial link layer */
++ status = gserial_setup(cdev->gadget, 1);
++ if (status < 0)
++ goto fail0;
++
++ gcnum = usb_gadget_controller_number(gadget);
++ if (gcnum >= 0)
++ device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
++ else {
++ /* We assume that can_support_ecm() tells the truth;
++ * but if the controller isn't recognized at all then
++ * that assumption is a bit more likely to be wrong.
++ */
++ WARNING(cdev, "controller '%s' not recognized; trying %s\n",
++ gadget->name,
++ cdc_config_driver.label);
++ device_desc.bcdDevice =
++ __constant_cpu_to_le16(0x0300 | 0x0099);
++ }
++
++
++ /* Allocate string descriptor numbers ... note that string
++ * contents can be overridden by the composite_dev glue.
++ */
++
++ /* device descriptor strings: manufacturer, product */
++ snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
++ init_utsname()->sysname, init_utsname()->release,
++ gadget->name);
++ status = usb_string_id(cdev);
++ if (status < 0)
++ goto fail1;
++ strings_dev[STRING_MANUFACTURER_IDX].id = status;
++ device_desc.iManufacturer = status;
++
++ status = usb_string_id(cdev);
++ if (status < 0)
++ goto fail1;
++ strings_dev[STRING_PRODUCT_IDX].id = status;
++ device_desc.iProduct = status;
++
++ /* register our configuration */
++ status = usb_add_config(cdev, &cdc_config_driver);
++ if (status < 0)
++ goto fail1;
++
++ INFO(cdev, "%s, version: " DRIVER_VERSION "\n", DRIVER_DESC);
++
++ return 0;
++
++fail1:
++ gserial_cleanup();
++fail0:
++ gether_cleanup();
++ return status;
++}
++
++static int __exit cdc_unbind(struct usb_composite_dev *cdev)
++{
++ gserial_cleanup();
++ gether_cleanup();
++ return 0;
++}
++
++static struct usb_composite_driver cdc_driver = {
++ .name = "g_cdc",
++ .dev = &device_desc,
++ .strings = dev_strings,
++ .bind = cdc_bind,
++ .unbind = __exit_p(cdc_unbind),
++};
++
++MODULE_DESCRIPTION(DRIVER_DESC);
++MODULE_AUTHOR("David Brownell");
++MODULE_LICENSE("GPL");
++
++static int __init init(void)
++{
++ return usb_composite_register(&cdc_driver);
++}
++module_init(init);
++
++static void __exit cleanup(void)
++{
++ usb_composite_unregister(&cdc_driver);
++}
++module_exit(cleanup);
+diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
+new file mode 100644
+index 0000000..85c876c
+--- /dev/null
++++ b/drivers/usb/gadget/composite.c
+@@ -0,0 +1,1041 @@
++/*
++ * composite.c - infrastructure for Composite USB Gadgets
++ *
++ * Copyright (C) 2006-2008 David Brownell
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++/* #define VERBOSE_DEBUG */
++
++#include <linux/kallsyms.h>
++#include <linux/kernel.h>
++#include <linux/slab.h>
++#include <linux/device.h>
++
++#include <linux/usb/composite.h>
++
++
++/*
++ * The code in this file is utility code, used to build a gadget driver
++ * from one or more "function" drivers, one or more "configuration"
++ * objects, and a "usb_composite_driver" by gluing them together along
++ * with the relevant device-wide data.
++ */
++
++/* big enough to hold our biggest descriptor */
++#define USB_BUFSIZ 512
++
++static struct usb_composite_driver *composite;
++
++/* Some systems will need runtime overrides for the product identifers
++ * published in the device descriptor, either numbers or strings or both.
++ * String parameters are in UTF-8 (superset of ASCII's 7 bit characters).
++ */
++
++static ushort idVendor;
++module_param(idVendor, ushort, 0);
++MODULE_PARM_DESC(idVendor, "USB Vendor ID");
++
++static ushort idProduct;
++module_param(idProduct, ushort, 0);
++MODULE_PARM_DESC(idProduct, "USB Product ID");
++
++static ushort bcdDevice;
++module_param(bcdDevice, ushort, 0);
++MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
++
++static char *iManufacturer;
++module_param(iManufacturer, charp, 0);
++MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
++
++static char *iProduct;
++module_param(iProduct, charp, 0);
++MODULE_PARM_DESC(iProduct, "USB Product string");
++
++static char *iSerialNumber;
++module_param(iSerialNumber, charp, 0);
++MODULE_PARM_DESC(iSerialNumber, "SerialNumber string");
++
++/*-------------------------------------------------------------------------*/
++
++/**
++ * usb_add_function() - add a function to a configuration
++ * @config: the configuration
++ * @function: the function being added
++ * Context: single threaded during gadget setup
++ *
++ * After initialization, each configuration must have one or more
++ * functions added to it. Adding a function involves calling its @bind()
++ * method to allocate resources such as interface and string identifiers
++ * and endpoints.
++ *
++ * This function returns the value of the function's bind(), which is
++ * zero for success else a negative errno value.
++ */
++int __init usb_add_function(struct usb_configuration *config,
++ struct usb_function *function)
++{
++ int value = -EINVAL;
++
++ DBG(config->cdev, "adding '%s'/%p to config '%s'/%p\n",
++ function->name, function,
++ config->label, config);
++
++ if (!function->set_alt || !function->disable)
++ goto done;
++
++ function->config = config;
++ list_add_tail(&function->list, &config->functions);
++
++ /* REVISIT *require* function->bind? */
++ if (function->bind) {
++ value = function->bind(config, function);
++ if (value < 0) {
++ list_del(&function->list);
++ function->config = NULL;
++ }
++ } else
++ value = 0;
++
++ /* We allow configurations that don't work at both speeds.
++ * If we run into a lowspeed Linux system, treat it the same
++ * as full speed ... it's the function drivers that will need
++ * to avoid bulk and ISO transfers.
++ */
++ if (!config->fullspeed && function->descriptors)
++ config->fullspeed = true;
++ if (!config->highspeed && function->hs_descriptors)
++ config->highspeed = true;
++
++done:
++ if (value)
++ DBG(config->cdev, "adding '%s'/%p --> %d\n",
++ function->name, function, value);
++ return value;
++}
++
++/**
++ * usb_interface_id() - allocate an unused interface ID
++ * @config: configuration associated with the interface
++ * @function: function handling the interface
++ * Context: single threaded during gadget setup
++ *
++ * usb_interface_id() is called from usb_function.bind() callbacks to
++ * allocate new interface IDs. The function driver will then store that
++ * ID in interface, association, CDC union, and other descriptors. It
++ * will also handle any control requests targetted at that interface,
++ * particularly changing its altsetting via set_alt(). There may
++ * also be class-specific or vendor-specific requests to handle.
++ *
++ * All interface identifier should be allocated using this routine, to
++ * ensure that for example different functions don't wrongly assign
++ * different meanings to the same identifier. Note that since interface
++ * identifers are configuration-specific, functions used in more than
++ * one configuration (or more than once in a given configuration) need
++ * multiple versions of the relevant descriptors.
++ *
++ * Returns the interface ID which was allocated; or -ENODEV if no
++ * more interface IDs can be allocated.
++ */
++int __init usb_interface_id(struct usb_configuration *config,
++ struct usb_function *function)
++{
++ unsigned id = config->next_interface_id;
++
++ if (id < MAX_CONFIG_INTERFACES) {
++ config->interface[id] = function;
++ config->next_interface_id = id + 1;
++ return id;
++ }
++ return -ENODEV;
++}
++
++static int config_buf(struct usb_configuration *config,
++ enum usb_device_speed speed, void *buf, u8 type)
++{
++ struct usb_config_descriptor *c = buf;
++ void *next = buf + USB_DT_CONFIG_SIZE;
++ int len = USB_BUFSIZ - USB_DT_CONFIG_SIZE;
++ struct usb_function *f;
++ int status;
++
++ /* write the config descriptor */
++ c = buf;
++ c->bLength = USB_DT_CONFIG_SIZE;
++ c->bDescriptorType = type;
++ /* wTotalLength is written later */
++ c->bNumInterfaces = config->next_interface_id;
++ c->bConfigurationValue = config->bConfigurationValue;
++ c->iConfiguration = config->iConfiguration;
++ c->bmAttributes = USB_CONFIG_ATT_ONE | config->bmAttributes;
++ c->bMaxPower = config->bMaxPower;
++
++ /* There may be e.g. OTG descriptors */
++ if (config->descriptors) {
++ status = usb_descriptor_fillbuf(next, len,
++ config->descriptors);
++ if (status < 0)
++ return status;
++ len -= status;
++ next += status;
++ }
++
++ /* add each function's descriptors */
++ list_for_each_entry(f, &config->functions, list) {
++ struct usb_descriptor_header **descriptors;
++
++ if (speed == USB_SPEED_HIGH)
++ descriptors = f->hs_descriptors;
++ else
++ descriptors = f->descriptors;
++ if (!descriptors)
++ continue;
++ status = usb_descriptor_fillbuf(next, len,
++ (const struct usb_descriptor_header **) descriptors);
++ if (status < 0)
++ return status;
++ len -= status;
++ next += status;
++ }
++
++ len = next - buf;
++ c->wTotalLength = cpu_to_le16(len);
++ return len;
++}
++
++static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
++{
++ struct usb_gadget *gadget = cdev->gadget;
++ struct usb_configuration *c;
++ u8 type = w_value >> 8;
++ enum usb_device_speed speed = USB_SPEED_UNKNOWN;
++
++ if (gadget_is_dualspeed(gadget)) {
++ int hs = 0;
++
++ if (gadget->speed == USB_SPEED_HIGH)
++ hs = 1;
++ if (type == USB_DT_OTHER_SPEED_CONFIG)
++ hs = !hs;
++ if (hs)
++ speed = USB_SPEED_HIGH;
++
++ }
++
++ /* This is a lookup by config *INDEX* */
++ w_value &= 0xff;
++ list_for_each_entry(c, &cdev->configs, list) {
++ /* ignore configs that won't work at this speed */
++ if (speed == USB_SPEED_HIGH) {
++ if (!c->highspeed)
++ continue;
++ } else {
++ if (!c->fullspeed)
++ continue;
++ }
++ if (w_value == 0)
++ return config_buf(c, speed, cdev->req->buf, type);
++ w_value--;
++ }
++ return -EINVAL;
++}
++
++static int count_configs(struct usb_composite_dev *cdev, unsigned type)
++{
++ struct usb_gadget *gadget = cdev->gadget;
++ struct usb_configuration *c;
++ unsigned count = 0;
++ int hs = 0;
++
++ if (gadget_is_dualspeed(gadget)) {
++ if (gadget->speed == USB_SPEED_HIGH)
++ hs = 1;
++ if (type == USB_DT_DEVICE_QUALIFIER)
++ hs = !hs;
++ }
++ list_for_each_entry(c, &cdev->configs, list) {
++ /* ignore configs that won't work at this speed */
++ if (hs) {
++ if (!c->highspeed)
++ continue;
++ } else {
++ if (!c->fullspeed)
++ continue;
++ }
++ count++;
++ }
++ return count;
++}
++
++static void device_qual(struct usb_composite_dev *cdev)
++{
++ struct usb_qualifier_descriptor *qual = cdev->req->buf;
++
++ qual->bLength = sizeof(*qual);
++ qual->bDescriptorType = USB_DT_DEVICE_QUALIFIER;
++ /* POLICY: same bcdUSB and device type info at both speeds */
++ qual->bcdUSB = cdev->desc.bcdUSB;
++ qual->bDeviceClass = cdev->desc.bDeviceClass;
++ qual->bDeviceSubClass = cdev->desc.bDeviceSubClass;
++ qual->bDeviceProtocol = cdev->desc.bDeviceProtocol;
++ /* ASSUME same EP0 fifo size at both speeds */
++ qual->bMaxPacketSize0 = cdev->desc.bMaxPacketSize0;
++ qual->bNumConfigurations = count_configs(cdev, USB_DT_DEVICE_QUALIFIER);
++ qual->bRESERVED = 0;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static void reset_config(struct usb_composite_dev *cdev)
++{
++ struct usb_function *f;
++
++ DBG(cdev, "reset config\n");
++
++ list_for_each_entry(f, &cdev->config->functions, list) {
++ if (f->disable)
++ f->disable(f);
++ }
++ cdev->config = NULL;
++}
++
++static int set_config(struct usb_composite_dev *cdev,
++ const struct usb_ctrlrequest *ctrl, unsigned number)
++{
++ struct usb_gadget *gadget = cdev->gadget;
++ struct usb_configuration *c = NULL;
++ int result = -EINVAL;
++ unsigned power = gadget_is_otg(gadget) ? 8 : 100;
++ int tmp;
++
++ if (cdev->config)
++ reset_config(cdev);
++
++ if (number) {
++ list_for_each_entry(c, &cdev->configs, list) {
++ if (c->bConfigurationValue == number) {
++ result = 0;
++ break;
++ }
++ }
++ if (result < 0)
++ goto done;
++ } else
++ result = 0;
++
++ INFO(cdev, "%s speed config #%d: %s\n",
++ ({ char *speed;
++ switch (gadget->speed) {
++ case USB_SPEED_LOW: speed = "low"; break;
++ case USB_SPEED_FULL: speed = "full"; break;
++ case USB_SPEED_HIGH: speed = "high"; break;
++ default: speed = "?"; break;
++ } ; speed; }), number, c ? c->label : "unconfigured");
++
++ if (!c)
++ goto done;
++
++ cdev->config = c;
++
++ /* Initialize all interfaces by setting them to altsetting zero. */
++ for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
++ struct usb_function *f = c->interface[tmp];
++
++ if (!f)
++ break;
++
++ result = f->set_alt(f, tmp, 0);
++ if (result < 0) {
++ DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n",
++ tmp, f->name, f, result);
++
++ reset_config(cdev);
++ goto done;
++ }
++ }
++
++ /* when we return, be sure our power usage is valid */
++ power = 2 * c->bMaxPower;
++done:
++ usb_gadget_vbus_draw(gadget, power);
++ return result;
++}
++
++/**
++ * usb_add_config() - add a configuration to a device.
++ * @cdev: wraps the USB gadget
++ * @config: the configuration, with bConfigurationValue assigned
++ * Context: single threaded during gadget setup
++ *
++ * One of the main tasks of a composite driver's bind() routine is to
++ * add each of the configurations it supports, using this routine.
++ *
++ * This function returns the value of the configuration's bind(), which
++ * is zero for success else a negative errno value. Binding configurations
++ * assigns global resources including string IDs, and per-configuration
++ * resources such as interface IDs and endpoints.
++ */
++int __init usb_add_config(struct usb_composite_dev *cdev,
++ struct usb_configuration *config)
++{
++ int status = -EINVAL;
++ struct usb_configuration *c;
++
++ DBG(cdev, "adding config #%u '%s'/%p\n",
++ config->bConfigurationValue,
++ config->label, config);
++
++ if (!config->bConfigurationValue || !config->bind)
++ goto done;
++
++ /* Prevent duplicate configuration identifiers */
++ list_for_each_entry(c, &cdev->configs, list) {
++ if (c->bConfigurationValue == config->bConfigurationValue) {
++ status = -EBUSY;
++ goto done;
++ }
++ }
++
++ config->cdev = cdev;
++ list_add_tail(&config->list, &cdev->configs);
++
++ INIT_LIST_HEAD(&config->functions);
++ config->next_interface_id = 0;
++
++ status = config->bind(config);
++ if (status < 0) {
++ list_del(&config->list);
++ config->cdev = NULL;
++ } else {
++ unsigned i;
++
++ DBG(cdev, "cfg %d/%p speeds:%s%s\n",
++ config->bConfigurationValue, config,
++ config->highspeed ? " high" : "",
++ config->fullspeed
++ ? (gadget_is_dualspeed(cdev->gadget)
++ ? " full"
++ : " full/low")
++ : "");
++
++ for (i = 0; i < MAX_CONFIG_INTERFACES; i++) {
++ struct usb_function *f = config->interface[i];
++
++ if (!f)
++ continue;
++ DBG(cdev, " interface %d = %s/%p\n",
++ i, f->name, f);
++ }
++ }
++
++ /* set_alt(), or next config->bind(), sets up
++ * ep->driver_data as needed.
++ */
++ usb_ep_autoconfig_reset(cdev->gadget);
++
++done:
++ if (status)
++ DBG(cdev, "added config '%s'/%u --> %d\n", config->label,
++ config->bConfigurationValue, status);
++ return status;
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* We support strings in multiple languages ... string descriptor zero
++ * says which languages are supported. The typical case will be that
++ * only one language (probably English) is used, with I18N handled on
++ * the host side.
++ */
++
++static void collect_langs(struct usb_gadget_strings **sp, __le16 *buf)
++{
++ const struct usb_gadget_strings *s;
++ u16 language;
++ __le16 *tmp;
++
++ while (*sp) {
++ s = *sp;
++ language = cpu_to_le16(s->language);
++ for (tmp = buf; *tmp && tmp < &buf[126]; tmp++) {
++ if (*tmp == language)
++ goto repeat;
++ }
++ *tmp++ = language;
++repeat:
++ sp++;
++ }
++}
++
++static int lookup_string(
++ struct usb_gadget_strings **sp,
++ void *buf,
++ u16 language,
++ int id
++)
++{
++ struct usb_gadget_strings *s;
++ int value;
++
++ while (*sp) {
++ s = *sp++;
++ if (s->language != language)
++ continue;
++ value = usb_gadget_get_string(s, id, buf);
++ if (value > 0)
++ return value;
++ }
++ return -EINVAL;
++}
++
++static int get_string(struct usb_composite_dev *cdev,
++ void *buf, u16 language, int id)
++{
++ struct usb_configuration *c;
++ struct usb_function *f;
++ int len;
++
++ /* Yes, not only is USB's I18N support probably more than most
++ * folk will ever care about ... also, it's all supported here.
++ * (Except for UTF8 support for Unicode's "Astral Planes".)
++ */
++
++ /* 0 == report all available language codes */
++ if (id == 0) {
++ struct usb_string_descriptor *s = buf;
++ struct usb_gadget_strings **sp;
++
++ memset(s, 0, 256);
++ s->bDescriptorType = USB_DT_STRING;
++
++ sp = composite->strings;
++ if (sp)
++ collect_langs(sp, s->wData);
++
++ list_for_each_entry(c, &cdev->configs, list) {
++ sp = c->strings;
++ if (sp)
++ collect_langs(sp, s->wData);
++
++ list_for_each_entry(f, &c->functions, list) {
++ sp = f->strings;
++ if (sp)
++ collect_langs(sp, s->wData);
++ }
++ }
++
++ for (len = 0; s->wData[len] && len <= 126; len++)
++ continue;
++ if (!len)
++ return -EINVAL;
++
++ s->bLength = 2 * (len + 1);
++ return s->bLength;
++ }
++
++ /* Otherwise, look up and return a specified string. String IDs
++ * are device-scoped, so we look up each string table we're told
++ * about. These lookups are infrequent; simpler-is-better here.
++ */
++ if (composite->strings) {
++ len = lookup_string(composite->strings, buf, language, id);
++ if (len > 0)
++ return len;
++ }
++ list_for_each_entry(c, &cdev->configs, list) {
++ if (c->strings) {
++ len = lookup_string(c->strings, buf, language, id);
++ if (len > 0)
++ return len;
++ }
++ list_for_each_entry(f, &c->functions, list) {
++ if (!f->strings)
++ continue;
++ len = lookup_string(f->strings, buf, language, id);
++ if (len > 0)
++ return len;
++ }
++ }
++ return -EINVAL;
++}
++
++/**
++ * usb_string_id() - allocate an unused string ID
++ * @cdev: the device whose string descriptor IDs are being allocated
++ * Context: single threaded during gadget setup
++ *
++ * @usb_string_id() is called from bind() callbacks to allocate
++ * string IDs. Drivers for functions, configurations, or gadgets will
++ * then store that ID in the appropriate descriptors and string table.
++ *
++ * All string identifier should be allocated using this routine, to
++ * ensure that for example different functions don't wrongly assign
++ * different meanings to the same identifier.
++ */
++int __init usb_string_id(struct usb_composite_dev *cdev)
++{
++ if (cdev->next_string_id < 254) {
++ /* string id 0 is reserved */
++ cdev->next_string_id++;
++ return cdev->next_string_id;
++ }
++ return -ENODEV;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
++{
++ if (req->status || req->actual != req->length)
++ DBG((struct usb_composite_dev *) ep->driver_data,
++ "setup complete --> %d, %d/%d\n",
++ req->status, req->actual, req->length);
++}
++
++/*
++ * The setup() callback implements all the ep0 functionality that's
++ * not handled lower down, in hardware or the hardware driver(like
++ * device and endpoint feature flags, and their status). It's all
++ * housekeeping for the gadget function we're implementing. Most of
++ * the work is in config and function specific setup.
++ */
++static int
++composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
++{
++ struct usb_composite_dev *cdev = get_gadget_data(gadget);
++ struct usb_request *req = cdev->req;
++ int value = -EOPNOTSUPP;
++ u16 w_index = le16_to_cpu(ctrl->wIndex);
++ u16 w_value = le16_to_cpu(ctrl->wValue);
++ u16 w_length = le16_to_cpu(ctrl->wLength);
++ struct usb_function *f = NULL;
++
++ /* partial re-init of the response message; the function or the
++ * gadget might need to intercept e.g. a control-OUT completion
++ * when we delegate to it.
++ */
++ req->zero = 0;
++ req->complete = composite_setup_complete;
++ req->length = USB_BUFSIZ;
++ gadget->ep0->driver_data = cdev;
++
++ switch (ctrl->bRequest) {
++
++ /* we handle all standard USB descriptors */
++ case USB_REQ_GET_DESCRIPTOR:
++ if (ctrl->bRequestType != USB_DIR_IN)
++ goto unknown;
++ switch (w_value >> 8) {
++
++ case USB_DT_DEVICE:
++ cdev->desc.bNumConfigurations =
++ count_configs(cdev, USB_DT_DEVICE);
++ value = min(w_length, (u16) sizeof cdev->desc);
++ memcpy(req->buf, &cdev->desc, value);
++ break;
++ case USB_DT_DEVICE_QUALIFIER:
++ if (!gadget_is_dualspeed(gadget))
++ break;
++ device_qual(cdev);
++ value = min_t(int, w_length,
++ sizeof(struct usb_qualifier_descriptor));
++ break;
++ case USB_DT_OTHER_SPEED_CONFIG:
++ if (!gadget_is_dualspeed(gadget))
++ break;
++ /* FALLTHROUGH */
++ case USB_DT_CONFIG:
++ value = config_desc(cdev, w_value);
++ if (value >= 0)
++ value = min(w_length, (u16) value);
++ break;
++ case USB_DT_STRING:
++ value = get_string(cdev, req->buf,
++ w_index, w_value & 0xff);
++ if (value >= 0)
++ value = min(w_length, (u16) value);
++ break;
++ }
++ break;
++
++ /* any number of configs can work */
++ case USB_REQ_SET_CONFIGURATION:
++ if (ctrl->bRequestType != 0)
++ goto unknown;
++ if (gadget_is_otg(gadget)) {
++ if (gadget->a_hnp_support)
++ DBG(cdev, "HNP available\n");
++ else if (gadget->a_alt_hnp_support)
++ DBG(cdev, "HNP on another port\n");
++ else
++ VDBG(cdev, "HNP inactive\n");
++ }
++ spin_lock(&cdev->lock);
++ value = set_config(cdev, ctrl, w_value);
++ spin_unlock(&cdev->lock);
++ break;
++ case USB_REQ_GET_CONFIGURATION:
++ if (ctrl->bRequestType != USB_DIR_IN)
++ goto unknown;
++ if (cdev->config)
++ *(u8 *)req->buf = cdev->config->bConfigurationValue;
++ else
++ *(u8 *)req->buf = 0;
++ value = min(w_length, (u16) 1);
++ break;
++
++ /* function drivers must handle get/set altsetting; if there's
++ * no get() method, we know only altsetting zero works.
++ */
++ case USB_REQ_SET_INTERFACE:
++ if (ctrl->bRequestType != USB_RECIP_INTERFACE)
++ goto unknown;
++ if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES)
++ break;
++ f = cdev->config->interface[w_index];
++ if (!f)
++ break;
++ if (w_value && !f->get_alt)
++ break;
++ value = f->set_alt(f, w_index, w_value);
++ break;
++ case USB_REQ_GET_INTERFACE:
++ if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
++ goto unknown;
++ if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES)
++ break;
++ f = cdev->config->interface[w_index];
++ if (!f)
++ break;
++ /* lots of interfaces only need altsetting zero... */
++ value = f->get_alt ? f->get_alt(f, w_index) : 0;
++ if (value < 0)
++ break;
++ *((u8 *)req->buf) = value;
++ value = min(w_length, (u16) 1);
++ break;
++ default:
++unknown:
++ VDBG(cdev,
++ "non-core control req%02x.%02x v%04x i%04x l%d\n",
++ ctrl->bRequestType, ctrl->bRequest,
++ w_value, w_index, w_length);
++
++ /* functions always handle their interfaces ... punt other
++ * recipients (endpoint, other, WUSB, ...) to the current
++ * configuration code.
++ *
++ * REVISIT it could make sense to let the composite device
++ * take such requests too, if that's ever needed: to work
++ * in config 0, etc.
++ */
++ if ((ctrl->bRequestType & USB_RECIP_MASK)
++ == USB_RECIP_INTERFACE) {
++ f = cdev->config->interface[w_index];
++ if (f && f->setup)
++ value = f->setup(f, ctrl);
++ else
++ f = NULL;
++ }
++ if (value < 0 && !f) {
++ struct usb_configuration *c;
++
++ c = cdev->config;
++ if (c && c->setup)
++ value = c->setup(c, ctrl);
++ }
++
++ goto done;
++ }
++
++ /* respond with data transfer before status phase? */
++ if (value >= 0) {
++ req->length = value;
++ req->zero = value < w_length;
++ value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
++ if (value < 0) {
++ DBG(cdev, "ep_queue --> %d\n", value);
++ req->status = 0;
++ composite_setup_complete(gadget->ep0, req);
++ }
++ }
++
++done:
++ /* device either stalls (value < 0) or reports success */
++ return value;
++}
++
++static void composite_disconnect(struct usb_gadget *gadget)
++{
++ struct usb_composite_dev *cdev = get_gadget_data(gadget);
++ unsigned long flags;
++
++ /* REVISIT: should we have config and device level
++ * disconnect callbacks?
++ */
++ spin_lock_irqsave(&cdev->lock, flags);
++ if (cdev->config)
++ reset_config(cdev);
++ spin_unlock_irqrestore(&cdev->lock, flags);
++}
++
++/*-------------------------------------------------------------------------*/
++
++static void /* __init_or_exit */
++composite_unbind(struct usb_gadget *gadget)
++{
++ struct usb_composite_dev *cdev = get_gadget_data(gadget);
++
++ /* composite_disconnect() must already have been called
++ * by the underlying peripheral controller driver!
++ * so there's no i/o concurrency that could affect the
++ * state protected by cdev->lock.
++ */
++ WARN_ON(cdev->config);
++
++ while (!list_empty(&cdev->configs)) {
++ struct usb_configuration *c;
++
++ c = list_first_entry(&cdev->configs,
++ struct usb_configuration, list);
++ while (!list_empty(&c->functions)) {
++ struct usb_function *f;
++
++ f = list_first_entry(&c->functions,
++ struct usb_function, list);
++ list_del(&f->list);
++ if (f->unbind) {
++ DBG(cdev, "unbind function '%s'/%p\n",
++ f->name, f);
++ f->unbind(c, f);
++ /* may free memory for "f" */
++ }
++ }
++ list_del(&c->list);
++ if (c->unbind) {
++ DBG(cdev, "unbind config '%s'/%p\n", c->label, c);
++ c->unbind(c);
++ /* may free memory for "c" */
++ }
++ }
++ if (composite->unbind)
++ composite->unbind(cdev);
++
++ if (cdev->req) {
++ kfree(cdev->req->buf);
++ usb_ep_free_request(gadget->ep0, cdev->req);
++ }
++ kfree(cdev);
++ set_gadget_data(gadget, NULL);
++ composite = NULL;
++}
++
++static void __init
++string_override_one(struct usb_gadget_strings *tab, u8 id, const char *s)
++{
++ struct usb_string *str = tab->strings;
++
++ for (str = tab->strings; str->s; str++) {
++ if (str->id == id) {
++ str->s = s;
++ return;
++ }
++ }
++}
++
++static void __init
++string_override(struct usb_gadget_strings **tab, u8 id, const char *s)
++{
++ while (*tab) {
++ string_override_one(*tab, id, s);
++ tab++;
++ }
++}
++
++static int __init composite_bind(struct usb_gadget *gadget)
++{
++ struct usb_composite_dev *cdev;
++ int status = -ENOMEM;
++
++ cdev = kzalloc(sizeof *cdev, GFP_KERNEL);
++ if (!cdev)
++ return status;
++
++ spin_lock_init(&cdev->lock);
++ cdev->gadget = gadget;
++ set_gadget_data(gadget, cdev);
++ INIT_LIST_HEAD(&cdev->configs);
++
++ /* preallocate control response and buffer */
++ cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
++ if (!cdev->req)
++ goto fail;
++ cdev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);
++ if (!cdev->req->buf)
++ goto fail;
++ cdev->req->complete = composite_setup_complete;
++ gadget->ep0->driver_data = cdev;
++
++ cdev->bufsiz = USB_BUFSIZ;
++ cdev->driver = composite;
++
++ usb_gadget_set_selfpowered(gadget);
++
++ /* interface and string IDs start at zero via kzalloc.
++ * we force endpoints to start unassigned; few controller
++ * drivers will zero ep->driver_data.
++ */
++ usb_ep_autoconfig_reset(cdev->gadget);
++
++ /* composite gadget needs to assign strings for whole device (like
++ * serial number), register function drivers, potentially update
++ * power state and consumption, etc
++ */
++ status = composite->bind(cdev);
++ if (status < 0)
++ goto fail;
++
++ cdev->desc = *composite->dev;
++ cdev->desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
++
++ /* standardized runtime overrides for device ID data */
++ if (idVendor)
++ cdev->desc.idVendor = cpu_to_le16(idVendor);
++ if (idProduct)
++ cdev->desc.idProduct = cpu_to_le16(idProduct);
++ if (bcdDevice)
++ cdev->desc.bcdDevice = cpu_to_le16(bcdDevice);
++
++ /* strings can't be assigned before bind() allocates the
++ * releavnt identifiers
++ */
++ if (cdev->desc.iManufacturer && iManufacturer)
++ string_override(composite->strings,
++ cdev->desc.iManufacturer, iManufacturer);
++ if (cdev->desc.iProduct && iProduct)
++ string_override(composite->strings,
++ cdev->desc.iProduct, iProduct);
++ if (cdev->desc.iSerialNumber && iSerialNumber)
++ string_override(composite->strings,
++ cdev->desc.iSerialNumber, iSerialNumber);
++
++ INFO(cdev, "%s ready\n", composite->name);
++ return 0;
++
++fail:
++ composite_unbind(gadget);
++ return status;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static void
++composite_suspend(struct usb_gadget *gadget)
++{
++ struct usb_composite_dev *cdev = get_gadget_data(gadget);
++ struct usb_function *f;
++
++ /* REVISIT: should we have config and device level
++ * suspend/resume callbacks?
++ */
++ DBG(cdev, "suspend\n");
++ if (cdev->config) {
++ list_for_each_entry(f, &cdev->config->functions, list) {
++ if (f->suspend)
++ f->suspend(f);
++ }
++ }
++}
++
++static void
++composite_resume(struct usb_gadget *gadget)
++{
++ struct usb_composite_dev *cdev = get_gadget_data(gadget);
++ struct usb_function *f;
++
++ /* REVISIT: should we have config and device level
++ * suspend/resume callbacks?
++ */
++ DBG(cdev, "resume\n");
++ if (cdev->config) {
++ list_for_each_entry(f, &cdev->config->functions, list) {
++ if (f->resume)
++ f->resume(f);
++ }
++ }
++}
++
++/*-------------------------------------------------------------------------*/
++
++static struct usb_gadget_driver composite_driver = {
++ .speed = USB_SPEED_HIGH,
++
++ .bind = composite_bind,
++ .unbind = __exit_p(composite_unbind),
++
++ .setup = composite_setup,
++ .disconnect = composite_disconnect,
++
++ .suspend = composite_suspend,
++ .resume = composite_resume,
++
++ .driver = {
++ .owner = THIS_MODULE,
++ },
++};
++
++/**
++ * usb_composite_register() - register a composite driver
++ * @driver: the driver to register
++ * Context: single threaded during gadget setup
++ *
++ * This function is used to register drivers using the composite driver
++ * framework. The return value is zero, or a negative errno value.
++ * Those values normally come from the driver's @bind method, which does
++ * all the work of setting up the driver to match the hardware.
++ *
++ * On successful return, the gadget is ready to respond to requests from
++ * the host, unless one of its components invokes usb_gadget_disconnect()
++ * while it was binding. That would usually be done in order to wait for
++ * some userspace participation.
++ */
++int __init usb_composite_register(struct usb_composite_driver *driver)
++{
++ if (!driver || !driver->dev || !driver->bind || composite)
++ return -EINVAL;
++
++ if (!driver->name)
++ driver->name = "composite";
++ composite_driver.function = (char *) driver->name;
++ composite_driver.driver.name = driver->name;
++ composite = driver;
++
++ return usb_gadget_register_driver(&composite_driver);
++}
++
++/**
++ * usb_composite_unregister() - unregister a composite driver
++ * @driver: the driver to unregister
++ *
++ * This function is used to unregister drivers using the composite
++ * driver framework.
++ */
++void __exit usb_composite_unregister(struct usb_composite_driver *driver)
++{
++ if (composite != driver)
++ return;
++ usb_gadget_unregister_driver(&composite_driver);
++}
+diff --git a/drivers/usb/gadget/config.c b/drivers/usb/gadget/config.c
+index a4e54b2..1ca1c32 100644
+--- a/drivers/usb/gadget/config.c
++++ b/drivers/usb/gadget/config.c
+@@ -96,7 +96,7 @@ int usb_gadget_config_buf(
+ /* config descriptor first */
+ if (length < USB_DT_CONFIG_SIZE || !desc)
+ return -EINVAL;
+- *cp = *config;
++ *cp = *config;
+
+ /* then interface/endpoint/class/vendor/... */
+ len = usb_descriptor_fillbuf(USB_DT_CONFIG_SIZE + (u8*)buf,
+@@ -115,3 +115,77 @@ int usb_gadget_config_buf(
+ return len;
+ }
+
++/**
++ * usb_copy_descriptors - copy a vector of USB descriptors
++ * @src: null-terminated vector to copy
++ * Context: initialization code, which may sleep
++ *
++ * This makes a copy of a vector of USB descriptors. Its primary use
++ * is to support usb_function objects which can have multiple copies,
++ * each needing different descriptors. Functions may have static
++ * tables of descriptors, which are used as templates and customized
++ * with identifiers (for interfaces, strings, endpoints, and more)
++ * as needed by a given function instance.
++ */
++struct usb_descriptor_header **__init
++usb_copy_descriptors(struct usb_descriptor_header **src)
++{
++ struct usb_descriptor_header **tmp;
++ unsigned bytes;
++ unsigned n_desc;
++ void *mem;
++ struct usb_descriptor_header **ret;
++
++ /* count descriptors and their sizes; then add vector size */
++ for (bytes = 0, n_desc = 0, tmp = src; *tmp; tmp++, n_desc++)
++ bytes += (*tmp)->bLength;
++ bytes += (n_desc + 1) * sizeof(*tmp);
++
++ mem = kmalloc(bytes, GFP_KERNEL);
++ if (!mem)
++ return NULL;
++
++ /* fill in pointers starting at "tmp",
++ * to descriptors copied starting at "mem";
++ * and return "ret"
++ */
++ tmp = mem;
++ ret = mem;
++ mem += (n_desc + 1) * sizeof(*tmp);
++ while (*src) {
++ memcpy(mem, *src, (*src)->bLength);
++ *tmp = mem;
++ tmp++;
++ mem += (*src)->bLength;
++ src++;
++ }
++ *tmp = NULL;
++
++ return ret;
++}
++
++/**
++ * usb_find_endpoint - find a copy of an endpoint descriptor
++ * @src: original vector of descriptors
++ * @copy: copy of @src
++ * @ep: endpoint descriptor found in @src
++ *
++ * This returns the copy of the @match descriptor made for @copy. Its
++ * intended use is to help remembering the endpoint descriptor to use
++ * when enabling a given endpoint.
++ */
++struct usb_endpoint_descriptor *__init
++usb_find_endpoint(
++ struct usb_descriptor_header **src,
++ struct usb_descriptor_header **copy,
++ struct usb_endpoint_descriptor *match
++)
++{
++ while (*src) {
++ if (*src == (void *) match)
++ return (void *)*copy;
++ src++;
++ copy++;
++ }
++ return NULL;
++}
+diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
+index 4203619..7600a0c 100644
+--- a/drivers/usb/gadget/dummy_hcd.c
++++ b/drivers/usb/gadget/dummy_hcd.c
+@@ -542,13 +542,14 @@ dummy_queue (struct usb_ep *_ep, struct usb_request *_req,
+ req->req.context = dum;
+ req->req.complete = fifo_complete;
+
++ list_add_tail(&req->queue, &ep->queue);
+ spin_unlock (&dum->lock);
+ _req->actual = _req->length;
+ _req->status = 0;
+ _req->complete (_ep, _req);
+ spin_lock (&dum->lock);
+- }
+- list_add_tail (&req->queue, &ep->queue);
++ } else
++ list_add_tail(&req->queue, &ep->queue);
+ spin_unlock_irqrestore (&dum->lock, flags);
+
+ /* real hardware would likely enable transfers here, in case
+@@ -862,7 +863,7 @@ static int dummy_udc_probe (struct platform_device *pdev)
+ /* maybe claim OTG support, though we won't complete HNP */
+ dum->gadget.is_otg = (dummy_to_hcd(dum)->self.otg_port != 0);
+
+- strcpy (dum->gadget.dev.bus_id, "gadget");
++ dev_set_name(&dum->gadget.dev, "gadget");
+ dum->gadget.dev.parent = &pdev->dev;
+ dum->gadget.dev.release = dummy_gadget_release;
+ rc = device_register (&dum->gadget.dev);
+@@ -1865,7 +1866,7 @@ static int dummy_hcd_probe(struct platform_device *pdev)
+
+ dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc);
+
+- hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, pdev->dev.bus_id);
++ hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, dev_name(&pdev->dev));
+ if (!hcd)
+ return -ENOMEM;
+ the_controller = hcd_to_dummy (hcd);
+diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
+index 8bdad22..9462e30 100644
+--- a/drivers/usb/gadget/epautoconf.c
++++ b/drivers/usb/gadget/epautoconf.c
+@@ -159,6 +159,7 @@ ep_matches (
+ /* MATCH!! */
+
+ /* report address */
++ desc->bEndpointAddress &= USB_DIR_IN;
+ if (isdigit (ep->name [2])) {
+ u8 num = simple_strtol (&ep->name [2], NULL, 10);
+ desc->bEndpointAddress |= num;
+diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
+index 8d61ea6..bcac2e6 100644
+--- a/drivers/usb/gadget/ether.c
++++ b/drivers/usb/gadget/ether.c
+@@ -1,8 +1,9 @@
+ /*
+ * ether.c -- Ethernet gadget driver, with CDC and non-CDC options
+ *
+- * Copyright (C) 2003-2005 David Brownell
++ * Copyright (C) 2003-2005,2008 David Brownell
+ * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
++ * Copyright (C) 2008 Nokia Corporation
+ *
+ * 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
+@@ -23,18 +24,9 @@
+
+ #include <linux/kernel.h>
+ #include <linux/utsname.h>
+-#include <linux/device.h>
+-#include <linux/ctype.h>
+-#include <linux/etherdevice.h>
+-#include <linux/ethtool.h>
+
+-#include <linux/usb/ch9.h>
+-#include <linux/usb/cdc.h>
+-#include <linux/usb/gadget.h>
++#include "u_ether.h"
+
+-#include "gadget_chips.h"
+-
+-/*-------------------------------------------------------------------------*/
+
+ /*
+ * Ethernet gadget driver -- with CDC and non-CDC options
+@@ -46,7 +38,11 @@
+ * this USB-IF standard as its open-systems interoperability solution;
+ * most host side USB stacks (except from Microsoft) support it.
+ *
+- * There's some hardware that can't talk CDC. We make that hardware
++ * This is sometimes called "CDC ECM" (Ethernet Control Model) to support
++ * TLA-soup. "CDC ACM" (Abstract Control Model) is for modems, and a new
++ * "CDC EEM" (Ethernet Emulation Model) is starting to spread.
++ *
++ * There's some hardware that can't talk CDC ECM. We make that hardware
+ * implement a "minimalist" vendor-agnostic CDC core: same framing, but
+ * link-level setup only requires activating the configuration. Only the
+ * endpoint descriptors, and product/vendor IDs, are relevant; no control
+@@ -64,70 +60,40 @@
+ * A third option is also in use. Rather than CDC Ethernet, or something
+ * simpler, Microsoft pushes their own approach: RNDIS. The published
+ * RNDIS specs are ambiguous and appear to be incomplete, and are also
+- * needlessly complex.
++ * needlessly complex. They borrow more from CDC ACM than CDC ECM.
+ */
+
+ #define DRIVER_DESC "Ethernet Gadget"
+-#define DRIVER_VERSION "May Day 2005"
+-
+-static const char shortname [] = "ether";
+-static const char driver_desc [] = DRIVER_DESC;
+-
+-#define RX_EXTRA 20 /* guard against rx overflows */
+-
+-#include "rndis.h"
++#define DRIVER_VERSION "Memorial Day 2008"
+
+-#ifndef CONFIG_USB_ETH_RNDIS
+-#define rndis_uninit(x) do{}while(0)
+-#define rndis_deregister(c) do{}while(0)
+-#define rndis_exit() do{}while(0)
++#ifdef CONFIG_USB_ETH_RNDIS
++#define PREFIX "RNDIS/"
++#else
++#define PREFIX ""
+ #endif
+
+-/* CDC and RNDIS support the same host-chosen outgoing packet filters. */
+-#define DEFAULT_FILTER (USB_CDC_PACKET_TYPE_BROADCAST \
+- |USB_CDC_PACKET_TYPE_ALL_MULTICAST \
+- |USB_CDC_PACKET_TYPE_PROMISCUOUS \
+- |USB_CDC_PACKET_TYPE_DIRECTED)
+-
+-
+-/*-------------------------------------------------------------------------*/
+-
+-struct eth_dev {
+- spinlock_t lock;
+- struct usb_gadget *gadget;
+- struct usb_request *req; /* for control responses */
+- struct usb_request *stat_req; /* for cdc & rndis status */
+-
+- u8 config;
+- struct usb_ep *in_ep, *out_ep, *status_ep;
+- const struct usb_endpoint_descriptor
+- *in, *out, *status;
+-
+- spinlock_t req_lock;
+- struct list_head tx_reqs, rx_reqs;
+-
+- struct net_device *net;
+- struct net_device_stats stats;
+- atomic_t tx_qlen;
+-
+- struct work_struct work;
+- unsigned zlp:1;
+- unsigned cdc:1;
+- unsigned rndis:1;
+- unsigned suspended:1;
+- u16 cdc_filter;
+- unsigned long todo;
+-#define WORK_RX_MEMORY 0
+- int rndis_config;
+- u8 host_mac [ETH_ALEN];
+-};
+-
+-/* This version autoconfigures as much as possible at run-time.
++/*
++ * This driver aims for interoperability by using CDC ECM unless
++ *
++ * can_support_ecm()
++ *
++ * returns false, in which case it supports the CDC Subset. By default,
++ * that returns true; most hardware has no problems with CDC ECM, that's
++ * a good default. Previous versions of this driver had no default; this
++ * version changes that, removing overhead for new controller support.
+ *
+- * It also ASSUMES a self-powered device, without remote wakeup,
+- * although remote wakeup support would make sense.
++ * IF YOUR HARDWARE CAN'T SUPPORT CDC ECM, UPDATE THAT ROUTINE!
+ */
+
++static inline bool has_rndis(void)
++{
++#ifdef CONFIG_USB_ETH_RNDIS
++ return true;
++#else
++ return false;
++#endif
++}
++
+ /*-------------------------------------------------------------------------*/
+
+ /* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
+@@ -137,8 +103,8 @@ struct eth_dev {
+ /* Thanks to NetChip Technologies for donating this product ID.
+ * It's for devices with only CDC Ethernet configurations.
+ */
+-#define CDC_VENDOR_NUM 0x0525 /* NetChip */
+-#define CDC_PRODUCT_NUM 0xa4a1 /* Linux-USB Ethernet Gadget */
++#define CDC_VENDOR_NUM 0x0525 /* NetChip */
++#define CDC_PRODUCT_NUM 0xa4a1 /* Linux-USB Ethernet Gadget */
+
+ /* For hardware that can't talk CDC, we use the same vendor ID that
+ * ARM Linux has used for ethernet-over-usb, both with sa1100 and
+@@ -162,274 +128,9 @@ struct eth_dev {
+ #define RNDIS_VENDOR_NUM 0x0525 /* NetChip */
+ #define RNDIS_PRODUCT_NUM 0xa4a2 /* Ethernet/RNDIS Gadget */
+
+-
+-/* Some systems will want different product identifers published in the
+- * device descriptor, either numbers or strings or both. These string
+- * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
+- */
+-
+-static ushort idVendor;
+-module_param(idVendor, ushort, S_IRUGO);
+-MODULE_PARM_DESC(idVendor, "USB Vendor ID");
+-
+-static ushort idProduct;
+-module_param(idProduct, ushort, S_IRUGO);
+-MODULE_PARM_DESC(idProduct, "USB Product ID");
+-
+-static ushort bcdDevice;
+-module_param(bcdDevice, ushort, S_IRUGO);
+-MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
+-
+-static char *iManufacturer;
+-module_param(iManufacturer, charp, S_IRUGO);
+-MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
+-
+-static char *iProduct;
+-module_param(iProduct, charp, S_IRUGO);
+-MODULE_PARM_DESC(iProduct, "USB Product string");
+-
+-static char *iSerialNumber;
+-module_param(iSerialNumber, charp, S_IRUGO);
+-MODULE_PARM_DESC(iSerialNumber, "SerialNumber");
+-
+-/* initial value, changed by "ifconfig usb0 hw ether xx:xx:xx:xx:xx:xx" */
+-static char *dev_addr;
+-module_param(dev_addr, charp, S_IRUGO);
+-MODULE_PARM_DESC(dev_addr, "Device Ethernet Address");
+-
+-/* this address is invisible to ifconfig */
+-static char *host_addr;
+-module_param(host_addr, charp, S_IRUGO);
+-MODULE_PARM_DESC(host_addr, "Host Ethernet Address");
+-
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/* Include CDC support if we could run on CDC-capable hardware. */
+-
+-#ifdef CONFIG_USB_GADGET_NET2280
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_DUMMY_HCD
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_GOKU
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_LH7A40X
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_MQ11XX
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_OMAP
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_N9604
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_S3C2410
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_AT91
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_MUSBHSFC
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_ATMEL_USBA
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_FSL_USB2
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-/* For CDC-incapable hardware, choose the simple cdc subset.
+- * Anything that talks bulk (without notable bugs) can do this.
+- */
+-#ifdef CONFIG_USB_GADGET_PXA2XX
+-#define DEV_CONFIG_SUBSET
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_PXA27X
+-#define DEV_CONFIG_SUBSET
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_SUPERH
+-#define DEV_CONFIG_SUBSET
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_SA1100
+-/* use non-CDC for backwards compatibility */
+-#define DEV_CONFIG_SUBSET
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_M66592
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-#ifdef CONFIG_USB_GADGET_AMD5536UDC
+-#define DEV_CONFIG_CDC
+-#endif
+-
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/* "main" config is either CDC, or its simple subset */
+-static inline int is_cdc(struct eth_dev *dev)
+-{
+-#if !defined(DEV_CONFIG_SUBSET)
+- return 1; /* only cdc possible */
+-#elif !defined (DEV_CONFIG_CDC)
+- return 0; /* only subset possible */
+-#else
+- return dev->cdc; /* depends on what hardware we found */
+-#endif
+-}
+-
+-/* "secondary" RNDIS config may sometimes be activated */
+-static inline int rndis_active(struct eth_dev *dev)
+-{
+-#ifdef CONFIG_USB_ETH_RNDIS
+- return dev->rndis;
+-#else
+- return 0;
+-#endif
+-}
+-
+-#define subset_active(dev) (!is_cdc(dev) && !rndis_active(dev))
+-#define cdc_active(dev) ( is_cdc(dev) && !rndis_active(dev))
+-
+-
+-
+-#define DEFAULT_QLEN 2 /* double buffering by default */
+-
+-/* peak bulk transfer bits-per-second */
+-#define HS_BPS (13 * 512 * 8 * 1000 * 8)
+-#define FS_BPS (19 * 64 * 1 * 1000 * 8)
+-
+-#ifdef CONFIG_USB_GADGET_DUALSPEED
+-#define DEVSPEED USB_SPEED_HIGH
+-
+-static unsigned qmult = 5;
+-module_param (qmult, uint, S_IRUGO|S_IWUSR);
+-
+-
+-/* for dual-speed hardware, use deeper queues at highspeed */
+-#define qlen(gadget) \
+- (DEFAULT_QLEN*((gadget->speed == USB_SPEED_HIGH) ? qmult : 1))
+-
+-static inline int BITRATE(struct usb_gadget *g)
+-{
+- return (g->speed == USB_SPEED_HIGH) ? HS_BPS : FS_BPS;
+-}
+-
+-#else /* full speed (low speed doesn't do bulk) */
+-
+-#define qmult 1
+-
+-#define DEVSPEED USB_SPEED_FULL
+-
+-#define qlen(gadget) DEFAULT_QLEN
+-
+-static inline int BITRATE(struct usb_gadget *g)
+-{
+- return FS_BPS;
+-}
+-#endif
+-
+-
+-/*-------------------------------------------------------------------------*/
+-
+-#define xprintk(d,level,fmt,args...) \
+- printk(level "%s: " fmt , (d)->net->name , ## args)
+-
+-#ifdef DEBUG
+-#undef DEBUG
+-#define DEBUG(dev,fmt,args...) \
+- xprintk(dev , KERN_DEBUG , fmt , ## args)
+-#else
+-#define DEBUG(dev,fmt,args...) \
+- do { } while (0)
+-#endif /* DEBUG */
+-
+-#ifdef VERBOSE_DEBUG
+-#define VDEBUG DEBUG
+-#else
+-#define VDEBUG(dev,fmt,args...) \
+- do { } while (0)
+-#endif /* DEBUG */
+-
+-#define ERROR(dev,fmt,args...) \
+- xprintk(dev , KERN_ERR , fmt , ## args)
+-#define WARN(dev,fmt,args...) \
+- xprintk(dev , KERN_WARNING , fmt , ## args)
+-#define INFO(dev,fmt,args...) \
+- xprintk(dev , KERN_INFO , fmt , ## args)
+-
+ /*-------------------------------------------------------------------------*/
+
+-/* USB DRIVER HOOKUP (to the hardware driver, below us), mostly
+- * ep0 implementation: descriptors, config management, setup().
+- * also optional class-specific notification interrupt transfer.
+- */
+-
+-/*
+- * DESCRIPTORS ... most are static, but strings and (full) configuration
+- * descriptors are built on demand. For now we do either full CDC, or
+- * our simple subset, with RNDIS as an optional second configuration.
+- *
+- * RNDIS includes some CDC ACM descriptors ... like CDC Ethernet. But
+- * the class descriptors match a modem (they're ignored; it's really just
+- * Ethernet functionality), they don't need the NOP altsetting, and the
+- * status transfer endpoint isn't optional.
+- */
+-
+-#define STRING_MANUFACTURER 1
+-#define STRING_PRODUCT 2
+-#define STRING_ETHADDR 3
+-#define STRING_DATA 4
+-#define STRING_CONTROL 5
+-#define STRING_RNDIS_CONTROL 6
+-#define STRING_CDC 7
+-#define STRING_SUBSET 8
+-#define STRING_RNDIS 9
+-#define STRING_SERIALNUMBER 10
+-
+-/* holds our biggest descriptor (or RNDIS response) */
+-#define USB_BUFSIZ 256
+-
+-/*
+- * This device advertises one configuration, eth_config, unless RNDIS
+- * is enabled (rndis_config) on hardware supporting at least two configs.
+- *
+- * NOTE: Controllers like superh_udc should probably be able to use
+- * an RNDIS-only configuration.
+- *
+- * FIXME define some higher-powered configurations to make it easier
+- * to recharge batteries ...
+- */
+-
+-#define DEV_CONFIG_VALUE 1 /* cdc or subset */
+-#define DEV_RNDIS_CONFIG_VALUE 2 /* rndis; optional */
+-
+-static struct usb_device_descriptor
+-device_desc = {
++static struct usb_device_descriptor device_desc = {
+ .bLength = sizeof device_desc,
+ .bDescriptorType = USB_DT_DEVICE,
+
+@@ -438,2220 +139,234 @@ device_desc = {
+ .bDeviceClass = USB_CLASS_COMM,
+ .bDeviceSubClass = 0,
+ .bDeviceProtocol = 0,
++ /* .bMaxPacketSize0 = f(hardware) */
+
++ /* Vendor and product id defaults change according to what configs
++ * we support. (As does bNumConfigurations.) These values can
++ * also be overridden by module parameters.
++ */
+ .idVendor = __constant_cpu_to_le16 (CDC_VENDOR_NUM),
+ .idProduct = __constant_cpu_to_le16 (CDC_PRODUCT_NUM),
+- .iManufacturer = STRING_MANUFACTURER,
+- .iProduct = STRING_PRODUCT,
++ /* .bcdDevice = f(hardware) */
++ /* .iManufacturer = DYNAMIC */
++ /* .iProduct = DYNAMIC */
++ /* NO SERIAL NUMBER */
+ .bNumConfigurations = 1,
+ };
+
+-static struct usb_otg_descriptor
+-otg_descriptor = {
++static struct usb_otg_descriptor otg_descriptor = {
+ .bLength = sizeof otg_descriptor,
+ .bDescriptorType = USB_DT_OTG,
+
+- .bmAttributes = USB_OTG_SRP,
+-};
+-
+-static struct usb_config_descriptor
+-eth_config = {
+- .bLength = sizeof eth_config,
+- .bDescriptorType = USB_DT_CONFIG,
+-
+- /* compute wTotalLength on the fly */
+- .bNumInterfaces = 2,
+- .bConfigurationValue = DEV_CONFIG_VALUE,
+- .iConfiguration = STRING_CDC,
+- .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
+- .bMaxPower = 50,
+-};
+-
+-#ifdef CONFIG_USB_ETH_RNDIS
+-static struct usb_config_descriptor
+-rndis_config = {
+- .bLength = sizeof rndis_config,
+- .bDescriptorType = USB_DT_CONFIG,
+-
+- /* compute wTotalLength on the fly */
+- .bNumInterfaces = 2,
+- .bConfigurationValue = DEV_RNDIS_CONFIG_VALUE,
+- .iConfiguration = STRING_RNDIS,
+- .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
+- .bMaxPower = 50,
+-};
+-#endif
+-
+-/*
+- * Compared to the simple CDC subset, the full CDC Ethernet model adds
+- * three class descriptors, two interface descriptors, optional status
+- * endpoint. Both have a "data" interface and two bulk endpoints.
+- * There are also differences in how control requests are handled.
+- *
+- * RNDIS shares a lot with CDC-Ethernet, since it's a variant of the
+- * CDC-ACM (modem) spec. Unfortunately MSFT's RNDIS driver is buggy; it
+- * may hang or oops. Since bugfixes (or accurate specs, letting Linux
+- * work around those bugs) are unlikely to ever come from MSFT, you may
+- * wish to avoid using RNDIS.
+- *
+- * MCCI offers an alternative to RNDIS if you need to connect to Windows
+- * but have hardware that can't support CDC Ethernet. We add descriptors
+- * to present the CDC Subset as a (nonconformant) CDC MDLM variant called
+- * "SAFE". That borrows from both CDC Ethernet and CDC MDLM. You can
+- * get those drivers from MCCI, or bundled with various products.
+- */
+-
+-#ifdef DEV_CONFIG_CDC
+-static struct usb_interface_descriptor
+-control_intf = {
+- .bLength = sizeof control_intf,
+- .bDescriptorType = USB_DT_INTERFACE,
+-
+- .bInterfaceNumber = 0,
+- /* status endpoint is optional; this may be patched later */
+- .bNumEndpoints = 1,
+- .bInterfaceClass = USB_CLASS_COMM,
+- .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
+- .bInterfaceProtocol = USB_CDC_PROTO_NONE,
+- .iInterface = STRING_CONTROL,
+-};
+-#endif
+-
+-#ifdef CONFIG_USB_ETH_RNDIS
+-static const struct usb_interface_descriptor
+-rndis_control_intf = {
+- .bLength = sizeof rndis_control_intf,
+- .bDescriptorType = USB_DT_INTERFACE,
+-
+- .bInterfaceNumber = 0,
+- .bNumEndpoints = 1,
+- .bInterfaceClass = USB_CLASS_COMM,
+- .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
+- .bInterfaceProtocol = USB_CDC_ACM_PROTO_VENDOR,
+- .iInterface = STRING_RNDIS_CONTROL,
+-};
+-#endif
+-
+-static const struct usb_cdc_header_desc header_desc = {
+- .bLength = sizeof header_desc,
+- .bDescriptorType = USB_DT_CS_INTERFACE,
+- .bDescriptorSubType = USB_CDC_HEADER_TYPE,
+-
+- .bcdCDC = __constant_cpu_to_le16 (0x0110),
+-};
+-
+-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
+-
+-static const struct usb_cdc_union_desc union_desc = {
+- .bLength = sizeof union_desc,
+- .bDescriptorType = USB_DT_CS_INTERFACE,
+- .bDescriptorSubType = USB_CDC_UNION_TYPE,
+-
+- .bMasterInterface0 = 0, /* index of control interface */
+- .bSlaveInterface0 = 1, /* index of DATA interface */
+-};
+-
+-#endif /* CDC || RNDIS */
+-
+-#ifdef CONFIG_USB_ETH_RNDIS
+-
+-static const struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor = {
+- .bLength = sizeof call_mgmt_descriptor,
+- .bDescriptorType = USB_DT_CS_INTERFACE,
+- .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,
+-
+- .bmCapabilities = 0x00,
+- .bDataInterface = 0x01,
+-};
+-
+-static const struct usb_cdc_acm_descriptor acm_descriptor = {
+- .bLength = sizeof acm_descriptor,
+- .bDescriptorType = USB_DT_CS_INTERFACE,
+- .bDescriptorSubType = USB_CDC_ACM_TYPE,
+-
+- .bmCapabilities = 0x00,
+-};
+-
+-#endif
+-
+-#ifndef DEV_CONFIG_CDC
+-
+-/* "SAFE" loosely follows CDC WMC MDLM, violating the spec in various
+- * ways: data endpoints live in the control interface, there's no data
+- * interface, and it's not used to talk to a cell phone radio.
+- */
+-
+-static const struct usb_cdc_mdlm_desc mdlm_desc = {
+- .bLength = sizeof mdlm_desc,
+- .bDescriptorType = USB_DT_CS_INTERFACE,
+- .bDescriptorSubType = USB_CDC_MDLM_TYPE,
+-
+- .bcdVersion = __constant_cpu_to_le16(0x0100),
+- .bGUID = {
+- 0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,
+- 0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,
+- },
+-};
+-
+-/* since "usb_cdc_mdlm_detail_desc" is a variable length structure, we
+- * can't really use its struct. All we do here is say that we're using
+- * the submode of "SAFE" which directly matches the CDC Subset.
+- */
+-static const u8 mdlm_detail_desc[] = {
+- 6,
+- USB_DT_CS_INTERFACE,
+- USB_CDC_MDLM_DETAIL_TYPE,
+-
+- 0, /* "SAFE" */
+- 0, /* network control capabilities (none) */
+- 0, /* network data capabilities ("raw" encapsulation) */
+-};
+-
+-#endif
+-
+-static const struct usb_cdc_ether_desc ether_desc = {
+- .bLength = sizeof ether_desc,
+- .bDescriptorType = USB_DT_CS_INTERFACE,
+- .bDescriptorSubType = USB_CDC_ETHERNET_TYPE,
+-
+- /* this descriptor actually adds value, surprise! */
+- .iMACAddress = STRING_ETHADDR,
+- .bmEthernetStatistics = __constant_cpu_to_le32 (0), /* no statistics */
+- .wMaxSegmentSize = __constant_cpu_to_le16 (ETH_FRAME_LEN),
+- .wNumberMCFilters = __constant_cpu_to_le16 (0),
+- .bNumberPowerFilters = 0,
+-};
+-
+-
+-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
+-
+-/* include the status endpoint if we can, even where it's optional.
+- * use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
+- * packet, to simplify cancellation; and a big transfer interval, to
+- * waste less bandwidth.
+- *
+- * some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even
+- * if they ignore the connect/disconnect notifications that real aether
+- * can provide. more advanced cdc configurations might want to support
+- * encapsulated commands (vendor-specific, using control-OUT).
+- *
+- * RNDIS requires the status endpoint, since it uses that encapsulation
+- * mechanism for its funky RPC scheme.
+- */
+-
+-#define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */
+-#define STATUS_BYTECOUNT 16 /* 8 byte header + data */
+-
+-static struct usb_endpoint_descriptor
+-fs_status_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+-
+- .bEndpointAddress = USB_DIR_IN,
+- .bmAttributes = USB_ENDPOINT_XFER_INT,
+- .wMaxPacketSize = __constant_cpu_to_le16 (STATUS_BYTECOUNT),
+- .bInterval = 1 << LOG2_STATUS_INTERVAL_MSEC,
+-};
+-#endif
+-
+-#ifdef DEV_CONFIG_CDC
+-
+-/* the default data interface has no endpoints ... */
+-
+-static const struct usb_interface_descriptor
+-data_nop_intf = {
+- .bLength = sizeof data_nop_intf,
+- .bDescriptorType = USB_DT_INTERFACE,
+-
+- .bInterfaceNumber = 1,
+- .bAlternateSetting = 0,
+- .bNumEndpoints = 0,
+- .bInterfaceClass = USB_CLASS_CDC_DATA,
+- .bInterfaceSubClass = 0,
+- .bInterfaceProtocol = 0,
+-};
+-
+-/* ... but the "real" data interface has two bulk endpoints */
+-
+-static const struct usb_interface_descriptor
+-data_intf = {
+- .bLength = sizeof data_intf,
+- .bDescriptorType = USB_DT_INTERFACE,
+-
+- .bInterfaceNumber = 1,
+- .bAlternateSetting = 1,
+- .bNumEndpoints = 2,
+- .bInterfaceClass = USB_CLASS_CDC_DATA,
+- .bInterfaceSubClass = 0,
+- .bInterfaceProtocol = 0,
+- .iInterface = STRING_DATA,
+-};
+-
+-#endif
+-
+-#ifdef CONFIG_USB_ETH_RNDIS
+-
+-/* RNDIS doesn't activate by changing to the "real" altsetting */
+-
+-static const struct usb_interface_descriptor
+-rndis_data_intf = {
+- .bLength = sizeof rndis_data_intf,
+- .bDescriptorType = USB_DT_INTERFACE,
+-
+- .bInterfaceNumber = 1,
+- .bAlternateSetting = 0,
+- .bNumEndpoints = 2,
+- .bInterfaceClass = USB_CLASS_CDC_DATA,
+- .bInterfaceSubClass = 0,
+- .bInterfaceProtocol = 0,
+- .iInterface = STRING_DATA,
+-};
+-
+-#endif
+-
+-#ifdef DEV_CONFIG_SUBSET
+-
+-/*
+- * "Simple" CDC-subset option is a simple vendor-neutral model that most
+- * full speed controllers can handle: one interface, two bulk endpoints.
+- *
+- * To assist host side drivers, we fancy it up a bit, and add descriptors
+- * so some host side drivers will understand it as a "SAFE" variant.
+- */
+-
+-static const struct usb_interface_descriptor
+-subset_data_intf = {
+- .bLength = sizeof subset_data_intf,
+- .bDescriptorType = USB_DT_INTERFACE,
+-
+- .bInterfaceNumber = 0,
+- .bAlternateSetting = 0,
+- .bNumEndpoints = 2,
+- .bInterfaceClass = USB_CLASS_COMM,
+- .bInterfaceSubClass = USB_CDC_SUBCLASS_MDLM,
+- .bInterfaceProtocol = 0,
+- .iInterface = STRING_DATA,
+-};
+-
+-#endif /* SUBSET */
+-
+-
+-static struct usb_endpoint_descriptor
+-fs_source_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+-
+- .bEndpointAddress = USB_DIR_IN,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+-};
+-
+-static struct usb_endpoint_descriptor
+-fs_sink_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+-
+- .bEndpointAddress = USB_DIR_OUT,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ /* REVISIT SRP-only hardware is possible, although
++ * it would not be called "OTG" ...
++ */
++ .bmAttributes = USB_OTG_SRP | USB_OTG_HNP,
+ };
+
+-static const struct usb_descriptor_header *fs_eth_function [11] = {
++static const struct usb_descriptor_header *otg_desc[] = {
+ (struct usb_descriptor_header *) &otg_descriptor,
+-#ifdef DEV_CONFIG_CDC
+- /* "cdc" mode descriptors */
+- (struct usb_descriptor_header *) &control_intf,
+- (struct usb_descriptor_header *) &header_desc,
+- (struct usb_descriptor_header *) &union_desc,
+- (struct usb_descriptor_header *) ðer_desc,
+- /* NOTE: status endpoint may need to be removed */
+- (struct usb_descriptor_header *) &fs_status_desc,
+- /* data interface, with altsetting */
+- (struct usb_descriptor_header *) &data_nop_intf,
+- (struct usb_descriptor_header *) &data_intf,
+- (struct usb_descriptor_header *) &fs_source_desc,
+- (struct usb_descriptor_header *) &fs_sink_desc,
+ NULL,
+-#endif /* DEV_CONFIG_CDC */
+ };
+
+-static inline void __init fs_subset_descriptors(void)
+-{
+-#ifdef DEV_CONFIG_SUBSET
+- /* behavior is "CDC Subset"; extra descriptors say "SAFE" */
+- fs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
+- fs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;
+- fs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;
+- fs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;
+- fs_eth_function[5] = (struct usb_descriptor_header *) ðer_desc;
+- fs_eth_function[6] = (struct usb_descriptor_header *) &fs_source_desc;
+- fs_eth_function[7] = (struct usb_descriptor_header *) &fs_sink_desc;
+- fs_eth_function[8] = NULL;
+-#else
+- fs_eth_function[1] = NULL;
+-#endif
+-}
+
+-#ifdef CONFIG_USB_ETH_RNDIS
+-static const struct usb_descriptor_header *fs_rndis_function [] = {
+- (struct usb_descriptor_header *) &otg_descriptor,
+- /* control interface matches ACM, not Ethernet */
+- (struct usb_descriptor_header *) &rndis_control_intf,
+- (struct usb_descriptor_header *) &header_desc,
+- (struct usb_descriptor_header *) &call_mgmt_descriptor,
+- (struct usb_descriptor_header *) &acm_descriptor,
+- (struct usb_descriptor_header *) &union_desc,
+- (struct usb_descriptor_header *) &fs_status_desc,
+- /* data interface has no altsetting */
+- (struct usb_descriptor_header *) &rndis_data_intf,
+- (struct usb_descriptor_header *) &fs_source_desc,
+- (struct usb_descriptor_header *) &fs_sink_desc,
+- NULL,
+-};
+-#endif
+-
+-/*
+- * usb 2.0 devices need to expose both high speed and full speed
+- * descriptors, unless they only run at full speed.
+- */
+-
+-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
+-static struct usb_endpoint_descriptor
+-hs_status_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+-
+- .bmAttributes = USB_ENDPOINT_XFER_INT,
+- .wMaxPacketSize = __constant_cpu_to_le16 (STATUS_BYTECOUNT),
+- .bInterval = LOG2_STATUS_INTERVAL_MSEC + 4,
+-};
+-#endif /* DEV_CONFIG_CDC */
+-
+-static struct usb_endpoint_descriptor
+-hs_source_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+-
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .wMaxPacketSize = __constant_cpu_to_le16 (512),
+-};
+-
+-static struct usb_endpoint_descriptor
+-hs_sink_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+-
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .wMaxPacketSize = __constant_cpu_to_le16 (512),
+-};
++/* string IDs are assigned dynamically */
+
+-static struct usb_qualifier_descriptor
+-dev_qualifier = {
+- .bLength = sizeof dev_qualifier,
+- .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
++#define STRING_MANUFACTURER_IDX 0
++#define STRING_PRODUCT_IDX 1
+
+- .bcdUSB = __constant_cpu_to_le16 (0x0200),
+- .bDeviceClass = USB_CLASS_COMM,
++static char manufacturer[50];
+
+- .bNumConfigurations = 1,
++static struct usb_string strings_dev[] = {
++ [STRING_MANUFACTURER_IDX].s = manufacturer,
++ [STRING_PRODUCT_IDX].s = PREFIX DRIVER_DESC,
++ { } /* end of list */
+ };
+
+-static const struct usb_descriptor_header *hs_eth_function [11] = {
+- (struct usb_descriptor_header *) &otg_descriptor,
+-#ifdef DEV_CONFIG_CDC
+- /* "cdc" mode descriptors */
+- (struct usb_descriptor_header *) &control_intf,
+- (struct usb_descriptor_header *) &header_desc,
+- (struct usb_descriptor_header *) &union_desc,
+- (struct usb_descriptor_header *) ðer_desc,
+- /* NOTE: status endpoint may need to be removed */
+- (struct usb_descriptor_header *) &hs_status_desc,
+- /* data interface, with altsetting */
+- (struct usb_descriptor_header *) &data_nop_intf,
+- (struct usb_descriptor_header *) &data_intf,
+- (struct usb_descriptor_header *) &hs_source_desc,
+- (struct usb_descriptor_header *) &hs_sink_desc,
+- NULL,
+-#endif /* DEV_CONFIG_CDC */
++static struct usb_gadget_strings stringtab_dev = {
++ .language = 0x0409, /* en-us */
++ .strings = strings_dev,
+ };
+
+-static inline void __init hs_subset_descriptors(void)
+-{
+-#ifdef DEV_CONFIG_SUBSET
+- /* behavior is "CDC Subset"; extra descriptors say "SAFE" */
+- hs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
+- hs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;
+- hs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;
+- hs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;
+- hs_eth_function[5] = (struct usb_descriptor_header *) ðer_desc;
+- hs_eth_function[6] = (struct usb_descriptor_header *) &hs_source_desc;
+- hs_eth_function[7] = (struct usb_descriptor_header *) &hs_sink_desc;
+- hs_eth_function[8] = NULL;
+-#else
+- hs_eth_function[1] = NULL;
+-#endif
+-}
+-
+-#ifdef CONFIG_USB_ETH_RNDIS
+-static const struct usb_descriptor_header *hs_rndis_function [] = {
+- (struct usb_descriptor_header *) &otg_descriptor,
+- /* control interface matches ACM, not Ethernet */
+- (struct usb_descriptor_header *) &rndis_control_intf,
+- (struct usb_descriptor_header *) &header_desc,
+- (struct usb_descriptor_header *) &call_mgmt_descriptor,
+- (struct usb_descriptor_header *) &acm_descriptor,
+- (struct usb_descriptor_header *) &union_desc,
+- (struct usb_descriptor_header *) &hs_status_desc,
+- /* data interface has no altsetting */
+- (struct usb_descriptor_header *) &rndis_data_intf,
+- (struct usb_descriptor_header *) &hs_source_desc,
+- (struct usb_descriptor_header *) &hs_sink_desc,
++static struct usb_gadget_strings *dev_strings[] = {
++ &stringtab_dev,
+ NULL,
+ };
+-#endif
+-
+-
+-/* maxpacket and other transfer characteristics vary by speed. */
+-static inline struct usb_endpoint_descriptor *
+-ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
+- struct usb_endpoint_descriptor *fs)
+-{
+- if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+- return hs;
+- return fs;
+-}
+
++static u8 hostaddr[ETH_ALEN];
+
+ /*-------------------------------------------------------------------------*/
+
+-/* descriptors that are built on-demand */
+-
+-static char manufacturer [50];
+-static char product_desc [40] = DRIVER_DESC;
+-static char serial_number [20];
+-
+-/* address that the host will use ... usually assigned at random */
+-static char ethaddr [2 * ETH_ALEN + 1];
+-
+-/* static strings, in UTF-8 */
+-static struct usb_string strings [] = {
+- { STRING_MANUFACTURER, manufacturer, },
+- { STRING_PRODUCT, product_desc, },
+- { STRING_SERIALNUMBER, serial_number, },
+- { STRING_DATA, "Ethernet Data", },
+- { STRING_ETHADDR, ethaddr, },
+-#ifdef DEV_CONFIG_CDC
+- { STRING_CDC, "CDC Ethernet", },
+- { STRING_CONTROL, "CDC Communications Control", },
+-#endif
+-#ifdef DEV_CONFIG_SUBSET
+- { STRING_SUBSET, "CDC Ethernet Subset", },
+-#endif
+-#ifdef CONFIG_USB_ETH_RNDIS
+- { STRING_RNDIS, "RNDIS", },
+- { STRING_RNDIS_CONTROL, "RNDIS Communications Control", },
+-#endif
+- { } /* end of list */
+-};
+-
+-static struct usb_gadget_strings stringtab = {
+- .language = 0x0409, /* en-us */
+- .strings = strings,
+-};
+-
+ /*
+- * one config, two interfaces: control, data.
+- * complications: class descriptors, and an altsetting.
+- */
+-static int
+-config_buf(struct usb_gadget *g, u8 *buf, u8 type, unsigned index, int is_otg)
+-{
+- int len;
+- const struct usb_config_descriptor *config;
+- const struct usb_descriptor_header **function;
+- int hs = 0;
+-
+- if (gadget_is_dualspeed(g)) {
+- hs = (g->speed == USB_SPEED_HIGH);
+- if (type == USB_DT_OTHER_SPEED_CONFIG)
+- hs = !hs;
+- }
+-#define which_fn(t) (hs ? hs_ ## t ## _function : fs_ ## t ## _function)
+-
+- if (index >= device_desc.bNumConfigurations)
+- return -EINVAL;
+-
+-#ifdef CONFIG_USB_ETH_RNDIS
+- /* list the RNDIS config first, to make Microsoft's drivers
+- * happy. DOCSIS 1.0 needs this too.
+- */
+- if (device_desc.bNumConfigurations == 2 && index == 0) {
+- config = &rndis_config;
+- function = which_fn (rndis);
+- } else
+-#endif
+- {
+- config = ð_config;
+- function = which_fn (eth);
+- }
+-
+- /* for now, don't advertise srp-only devices */
+- if (!is_otg)
+- function++;
+-
+- len = usb_gadget_config_buf (config, buf, USB_BUFSIZ, function);
+- if (len < 0)
+- return len;
+- ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
+- return len;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static void eth_start (struct eth_dev *dev, gfp_t gfp_flags);
+-static int alloc_requests (struct eth_dev *dev, unsigned n, gfp_t gfp_flags);
+-
+-static int
+-set_ether_config (struct eth_dev *dev, gfp_t gfp_flags)
+-{
+- int result = 0;
+- struct usb_gadget *gadget = dev->gadget;
+-
+-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
+- /* status endpoint used for RNDIS and (optionally) CDC */
+- if (!subset_active(dev) && dev->status_ep) {
+- dev->status = ep_desc (gadget, &hs_status_desc,
+- &fs_status_desc);
+- dev->status_ep->driver_data = dev;
+-
+- result = usb_ep_enable (dev->status_ep, dev->status);
+- if (result != 0) {
+- DEBUG (dev, "enable %s --> %d\n",
+- dev->status_ep->name, result);
+- goto done;
+- }
+- }
+-#endif
+-
+- dev->in = ep_desc(gadget, &hs_source_desc, &fs_source_desc);
+- dev->in_ep->driver_data = dev;
+-
+- dev->out = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);
+- dev->out_ep->driver_data = dev;
+-
+- /* With CDC, the host isn't allowed to use these two data
+- * endpoints in the default altsetting for the interface.
+- * so we don't activate them yet. Reset from SET_INTERFACE.
+- *
+- * Strictly speaking RNDIS should work the same: activation is
+- * a side effect of setting a packet filter. Deactivation is
+- * from REMOTE_NDIS_HALT_MSG, reset from REMOTE_NDIS_RESET_MSG.
+- */
+- if (!cdc_active(dev)) {
+- result = usb_ep_enable (dev->in_ep, dev->in);
+- if (result != 0) {
+- DEBUG(dev, "enable %s --> %d\n",
+- dev->in_ep->name, result);
+- goto done;
+- }
+-
+- result = usb_ep_enable (dev->out_ep, dev->out);
+- if (result != 0) {
+- DEBUG (dev, "enable %s --> %d\n",
+- dev->out_ep->name, result);
+- goto done;
+- }
+- }
+-
+-done:
+- if (result == 0)
+- result = alloc_requests (dev, qlen (gadget), gfp_flags);
+-
+- /* on error, disable any endpoints */
+- if (result < 0) {
+- if (!subset_active(dev) && dev->status_ep)
+- (void) usb_ep_disable (dev->status_ep);
+- dev->status = NULL;
+- (void) usb_ep_disable (dev->in_ep);
+- (void) usb_ep_disable (dev->out_ep);
+- dev->in = NULL;
+- dev->out = NULL;
+- }
+-
+- /* activate non-CDC configs right away
+- * this isn't strictly according to the RNDIS spec
+- */
+- else if (!cdc_active (dev)) {
+- netif_carrier_on (dev->net);
+- if (netif_running (dev->net)) {
+- spin_unlock (&dev->lock);
+- eth_start (dev, GFP_ATOMIC);
+- spin_lock (&dev->lock);
+- }
+- }
+-
+- if (result == 0)
+- DEBUG (dev, "qlen %d\n", qlen (gadget));
+-
+- /* caller is responsible for cleanup on error */
+- return result;
+-}
+-
+-static void eth_reset_config (struct eth_dev *dev)
+-{
+- struct usb_request *req;
+-
+- if (dev->config == 0)
+- return;
+-
+- DEBUG (dev, "%s\n", __func__);
+-
+- netif_stop_queue (dev->net);
+- netif_carrier_off (dev->net);
+- rndis_uninit(dev->rndis_config);
+-
+- /* disable endpoints, forcing (synchronous) completion of
+- * pending i/o. then free the requests.
+- */
+- if (dev->in) {
+- usb_ep_disable (dev->in_ep);
+- spin_lock(&dev->req_lock);
+- while (likely (!list_empty (&dev->tx_reqs))) {
+- req = container_of (dev->tx_reqs.next,
+- struct usb_request, list);
+- list_del (&req->list);
+-
+- spin_unlock(&dev->req_lock);
+- usb_ep_free_request (dev->in_ep, req);
+- spin_lock(&dev->req_lock);
+- }
+- spin_unlock(&dev->req_lock);
+- }
+- if (dev->out) {
+- usb_ep_disable (dev->out_ep);
+- spin_lock(&dev->req_lock);
+- while (likely (!list_empty (&dev->rx_reqs))) {
+- req = container_of (dev->rx_reqs.next,
+- struct usb_request, list);
+- list_del (&req->list);
+-
+- spin_unlock(&dev->req_lock);
+- usb_ep_free_request (dev->out_ep, req);
+- spin_lock(&dev->req_lock);
+- }
+- spin_unlock(&dev->req_lock);
+- }
+-
+- if (dev->status) {
+- usb_ep_disable (dev->status_ep);
+- }
+- dev->rndis = 0;
+- dev->cdc_filter = 0;
+- dev->config = 0;
+-}
+-
+-/* change our operational config. must agree with the code
+- * that returns config descriptors, and altsetting code.
++ * We may not have an RNDIS configuration, but if we do it needs to be
++ * the first one present. That's to make Microsoft's drivers happy,
++ * and to follow DOCSIS 1.0 (cable modem standard).
+ */
+-static int
+-eth_set_config (struct eth_dev *dev, unsigned number, gfp_t gfp_flags)
++static int __init rndis_do_config(struct usb_configuration *c)
+ {
+- int result = 0;
+- struct usb_gadget *gadget = dev->gadget;
+-
+- if (gadget_is_sa1100 (gadget)
+- && dev->config
+- && atomic_read (&dev->tx_qlen) != 0) {
+- /* tx fifo is full, but we can't clear it...*/
+- INFO (dev, "can't change configurations\n");
+- return -ESPIPE;
+- }
+- eth_reset_config (dev);
+-
+- switch (number) {
+- case DEV_CONFIG_VALUE:
+- result = set_ether_config (dev, gfp_flags);
+- break;
+-#ifdef CONFIG_USB_ETH_RNDIS
+- case DEV_RNDIS_CONFIG_VALUE:
+- dev->rndis = 1;
+- result = set_ether_config (dev, gfp_flags);
+- break;
+-#endif
+- default:
+- result = -EINVAL;
+- /* FALL THROUGH */
+- case 0:
+- break;
+- }
+-
+- if (result) {
+- if (number)
+- eth_reset_config (dev);
+- usb_gadget_vbus_draw(dev->gadget,
+- gadget_is_otg(dev->gadget) ? 8 : 100);
+- } else {
+- char *speed;
+- unsigned power;
+-
+- power = 2 * eth_config.bMaxPower;
+- usb_gadget_vbus_draw(dev->gadget, power);
++ /* FIXME alloc iConfiguration string, set it in c->strings */
+
+- switch (gadget->speed) {
+- case USB_SPEED_FULL: speed = "full"; break;
+-#ifdef CONFIG_USB_GADGET_DUALSPEED
+- case USB_SPEED_HIGH: speed = "high"; break;
+-#endif
+- default: speed = "?"; break;
+- }
+-
+- dev->config = number;
+- INFO (dev, "%s speed config #%d: %d mA, %s, using %s\n",
+- speed, number, power, driver_desc,
+- rndis_active(dev)
+- ? "RNDIS"
+- : (cdc_active(dev)
+- ? "CDC Ethernet"
+- : "CDC Ethernet Subset"));
++ if (gadget_is_otg(c->cdev->gadget)) {
++ c->descriptors = otg_desc;
++ c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+ }
+- return result;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-#ifdef DEV_CONFIG_CDC
+
+-/* The interrupt endpoint is used in CDC networking models (Ethernet, ATM)
+- * only to notify the host about link status changes (which we support) or
+- * report completion of some encapsulated command (as used in RNDIS). Since
+- * we want this CDC Ethernet code to be vendor-neutral, we don't use that
+- * command mechanism; and only one status request is ever queued.
+- */
+-
+-static void eth_status_complete (struct usb_ep *ep, struct usb_request *req)
+-{
+- struct usb_cdc_notification *event = req->buf;
+- int value = req->status;
+- struct eth_dev *dev = ep->driver_data;
+-
+- /* issue the second notification if host reads the first */
+- if (event->bNotificationType == USB_CDC_NOTIFY_NETWORK_CONNECTION
+- && value == 0) {
+- __le32 *data = req->buf + sizeof *event;
+-
+- event->bmRequestType = 0xA1;
+- event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
+- event->wValue = __constant_cpu_to_le16 (0);
+- event->wIndex = __constant_cpu_to_le16 (1);
+- event->wLength = __constant_cpu_to_le16 (8);
+-
+- /* SPEED_CHANGE data is up/down speeds in bits/sec */
+- data [0] = data [1] = cpu_to_le32 (BITRATE (dev->gadget));
+-
+- req->length = STATUS_BYTECOUNT;
+- value = usb_ep_queue (ep, req, GFP_ATOMIC);
+- DEBUG (dev, "send SPEED_CHANGE --> %d\n", value);
+- if (value == 0)
+- return;
+- } else if (value != -ECONNRESET)
+- DEBUG (dev, "event %02x --> %d\n",
+- event->bNotificationType, value);
+- req->context = NULL;
++ return rndis_bind_config(c, hostaddr);
+ }
+
+-static void issue_start_status (struct eth_dev *dev)
+-{
+- struct usb_request *req = dev->stat_req;
+- struct usb_cdc_notification *event;
+- int value;
+-
+- DEBUG (dev, "%s, flush old status first\n", __func__);
+-
+- /* flush old status
+- *
+- * FIXME ugly idiom, maybe we'd be better with just
+- * a "cancel the whole queue" primitive since any
+- * unlink-one primitive has way too many error modes.
+- * here, we "know" toggle is already clear...
+- *
+- * FIXME iff req->context != null just dequeue it
+- */
+- usb_ep_disable (dev->status_ep);
+- usb_ep_enable (dev->status_ep, dev->status);
+-
+- /* 3.8.1 says to issue first NETWORK_CONNECTION, then
+- * a SPEED_CHANGE. could be useful in some configs.
+- */
+- event = req->buf;
+- event->bmRequestType = 0xA1;
+- event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
+- event->wValue = __constant_cpu_to_le16 (1); /* connected */
+- event->wIndex = __constant_cpu_to_le16 (1);
+- event->wLength = 0;
+-
+- req->length = sizeof *event;
+- req->complete = eth_status_complete;
+- req->context = dev;
+-
+- value = usb_ep_queue (dev->status_ep, req, GFP_ATOMIC);
+- if (value < 0)
+- DEBUG (dev, "status buf queue --> %d\n", value);
+-}
+-
+-#endif
++static struct usb_configuration rndis_config_driver = {
++ .label = "RNDIS",
++ .bind = rndis_do_config,
++ .bConfigurationValue = 2,
++ /* .iConfiguration = DYNAMIC */
++ .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
++ .bMaxPower = 1, /* 2 mA, minimal */
++};
+
+ /*-------------------------------------------------------------------------*/
+
+-static void eth_setup_complete (struct usb_ep *ep, struct usb_request *req)
+-{
+- if (req->status || req->actual != req->length)
+- DEBUG ((struct eth_dev *) ep->driver_data,
+- "setup complete --> %d, %d/%d\n",
+- req->status, req->actual, req->length);
+-}
+-
+-#ifdef CONFIG_USB_ETH_RNDIS
+-
+-static void rndis_response_complete (struct usb_ep *ep, struct usb_request *req)
+-{
+- if (req->status || req->actual != req->length)
+- DEBUG ((struct eth_dev *) ep->driver_data,
+- "rndis response complete --> %d, %d/%d\n",
+- req->status, req->actual, req->length);
+-
+- /* done sending after USB_CDC_GET_ENCAPSULATED_RESPONSE */
+-}
+-
+-static void rndis_command_complete (struct usb_ep *ep, struct usb_request *req)
+-{
+- struct eth_dev *dev = ep->driver_data;
+- int status;
+-
+- /* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */
+- spin_lock(&dev->lock);
+- status = rndis_msg_parser (dev->rndis_config, (u8 *) req->buf);
+- if (status < 0)
+- ERROR(dev, "%s: rndis parse error %d\n", __func__, status);
+- spin_unlock(&dev->lock);
+-}
+-
+-#endif /* RNDIS */
+-
+ /*
+- * The setup() callback implements all the ep0 functionality that's not
+- * handled lower down. CDC has a number of less-common features:
+- *
+- * - two interfaces: control, and ethernet data
+- * - Ethernet data interface has two altsettings: default, and active
+- * - class-specific descriptors for the control interface
+- * - class-specific control requests
++ * We _always_ have an ECM or CDC Subset configuration.
+ */
+-static int
+-eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
++static int __init eth_do_config(struct usb_configuration *c)
+ {
+- struct eth_dev *dev = get_gadget_data (gadget);
+- struct usb_request *req = dev->req;
+- int value = -EOPNOTSUPP;
+- u16 wIndex = le16_to_cpu(ctrl->wIndex);
+- u16 wValue = le16_to_cpu(ctrl->wValue);
+- u16 wLength = le16_to_cpu(ctrl->wLength);
+-
+- /* descriptors just go into the pre-allocated ep0 buffer,
+- * while config change events may enable network traffic.
+- */
+- req->complete = eth_setup_complete;
+- switch (ctrl->bRequest) {
+-
+- case USB_REQ_GET_DESCRIPTOR:
+- if (ctrl->bRequestType != USB_DIR_IN)
+- break;
+- switch (wValue >> 8) {
+-
+- case USB_DT_DEVICE:
+- value = min (wLength, (u16) sizeof device_desc);
+- memcpy (req->buf, &device_desc, value);
+- break;
+- case USB_DT_DEVICE_QUALIFIER:
+- if (!gadget_is_dualspeed(gadget))
+- break;
+- value = min (wLength, (u16) sizeof dev_qualifier);
+- memcpy (req->buf, &dev_qualifier, value);
+- break;
+-
+- case USB_DT_OTHER_SPEED_CONFIG:
+- if (!gadget_is_dualspeed(gadget))
+- break;
+- // FALLTHROUGH
+- case USB_DT_CONFIG:
+- value = config_buf(gadget, req->buf,
+- wValue >> 8,
+- wValue & 0xff,
+- gadget_is_otg(gadget));
+- if (value >= 0)
+- value = min (wLength, (u16) value);
+- break;
+-
+- case USB_DT_STRING:
+- value = usb_gadget_get_string (&stringtab,
+- wValue & 0xff, req->buf);
+- if (value >= 0)
+- value = min (wLength, (u16) value);
+- break;
+- }
+- break;
+-
+- case USB_REQ_SET_CONFIGURATION:
+- if (ctrl->bRequestType != 0)
+- break;
+- if (gadget->a_hnp_support)
+- DEBUG (dev, "HNP available\n");
+- else if (gadget->a_alt_hnp_support)
+- DEBUG (dev, "HNP needs a different root port\n");
+- spin_lock (&dev->lock);
+- value = eth_set_config (dev, wValue, GFP_ATOMIC);
+- spin_unlock (&dev->lock);
+- break;
+- case USB_REQ_GET_CONFIGURATION:
+- if (ctrl->bRequestType != USB_DIR_IN)
+- break;
+- *(u8 *)req->buf = dev->config;
+- value = min (wLength, (u16) 1);
+- break;
+-
+- case USB_REQ_SET_INTERFACE:
+- if (ctrl->bRequestType != USB_RECIP_INTERFACE
+- || !dev->config
+- || wIndex > 1)
+- break;
+- if (!cdc_active(dev) && wIndex != 0)
+- break;
+- spin_lock (&dev->lock);
+-
+- /* PXA hardware partially handles SET_INTERFACE;
+- * we need to kluge around that interference.
+- */
+- if (gadget_is_pxa (gadget)) {
+- value = eth_set_config (dev, DEV_CONFIG_VALUE,
+- GFP_ATOMIC);
+- goto done_set_intf;
+- }
+-
+-#ifdef DEV_CONFIG_CDC
+- switch (wIndex) {
+- case 0: /* control/master intf */
+- if (wValue != 0)
+- break;
+- if (dev->status) {
+- usb_ep_disable (dev->status_ep);
+- usb_ep_enable (dev->status_ep, dev->status);
+- }
+- value = 0;
+- break;
+- case 1: /* data intf */
+- if (wValue > 1)
+- break;
+- usb_ep_disable (dev->in_ep);
+- usb_ep_disable (dev->out_ep);
+-
+- /* CDC requires the data transfers not be done from
+- * the default interface setting ... also, setting
+- * the non-default interface resets filters etc.
+- */
+- if (wValue == 1) {
+- if (!cdc_active (dev))
+- break;
+- usb_ep_enable (dev->in_ep, dev->in);
+- usb_ep_enable (dev->out_ep, dev->out);
+- dev->cdc_filter = DEFAULT_FILTER;
+- netif_carrier_on (dev->net);
+- if (dev->status)
+- issue_start_status (dev);
+- if (netif_running (dev->net)) {
+- spin_unlock (&dev->lock);
+- eth_start (dev, GFP_ATOMIC);
+- spin_lock (&dev->lock);
+- }
+- } else {
+- netif_stop_queue (dev->net);
+- netif_carrier_off (dev->net);
+- }
+- value = 0;
+- break;
+- }
+-#else
+- /* FIXME this is wrong, as is the assumption that
+- * all non-PXA hardware talks real CDC ...
+- */
+- dev_warn (&gadget->dev, "set_interface ignored!\n");
+-#endif /* DEV_CONFIG_CDC */
+-
+-done_set_intf:
+- spin_unlock (&dev->lock);
+- break;
+- case USB_REQ_GET_INTERFACE:
+- if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)
+- || !dev->config
+- || wIndex > 1)
+- break;
+- if (!(cdc_active(dev) || rndis_active(dev)) && wIndex != 0)
+- break;
+-
+- /* for CDC, iff carrier is on, data interface is active. */
+- if (rndis_active(dev) || wIndex != 1)
+- *(u8 *)req->buf = 0;
+- else
+- *(u8 *)req->buf = netif_carrier_ok (dev->net) ? 1 : 0;
+- value = min (wLength, (u16) 1);
+- break;
+-
+-#ifdef DEV_CONFIG_CDC
+- case USB_CDC_SET_ETHERNET_PACKET_FILTER:
+- /* see 6.2.30: no data, wIndex = interface,
+- * wValue = packet filter bitmap
+- */
+- if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)
+- || !cdc_active(dev)
+- || wLength != 0
+- || wIndex > 1)
+- break;
+- DEBUG (dev, "packet filter %02x\n", wValue);
+- dev->cdc_filter = wValue;
+- value = 0;
+- break;
+-
+- /* and potentially:
+- * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
+- * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
+- * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
+- * case USB_CDC_GET_ETHERNET_STATISTIC:
+- */
+-
+-#endif /* DEV_CONFIG_CDC */
++ /* FIXME alloc iConfiguration string, set it in c->strings */
+
+-#ifdef CONFIG_USB_ETH_RNDIS
+- /* RNDIS uses the CDC command encapsulation mechanism to implement
+- * an RPC scheme, with much getting/setting of attributes by OID.
+- */
+- case USB_CDC_SEND_ENCAPSULATED_COMMAND:
+- if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)
+- || !rndis_active(dev)
+- || wLength > USB_BUFSIZ
+- || wValue
+- || rndis_control_intf.bInterfaceNumber
+- != wIndex)
+- break;
+- /* read the request, then process it */
+- value = wLength;
+- req->complete = rndis_command_complete;
+- /* later, rndis_control_ack () sends a notification */
+- break;
+-
+- case USB_CDC_GET_ENCAPSULATED_RESPONSE:
+- if ((USB_DIR_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE)
+- == ctrl->bRequestType
+- && rndis_active(dev)
+- // && wLength >= 0x0400
+- && !wValue
+- && rndis_control_intf.bInterfaceNumber
+- == wIndex) {
+- u8 *buf;
+- u32 n;
+-
+- /* return the result */
+- buf = rndis_get_next_response(dev->rndis_config, &n);
+- if (buf) {
+- memcpy(req->buf, buf, n);
+- req->complete = rndis_response_complete;
+- rndis_free_response(dev->rndis_config, buf);
+- value = n;
+- }
+- /* else stalls ... spec says to avoid that */
+- }
+- break;
+-#endif /* RNDIS */
+-
+- default:
+- VDEBUG (dev,
+- "unknown control req%02x.%02x v%04x i%04x l%d\n",
+- ctrl->bRequestType, ctrl->bRequest,
+- wValue, wIndex, wLength);
++ if (gadget_is_otg(c->cdev->gadget)) {
++ c->descriptors = otg_desc;
++ c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+ }
+
+- /* respond with data transfer before status phase? */
+- if (value >= 0) {
+- req->length = value;
+- req->zero = value < wLength
+- && (value % gadget->ep0->maxpacket) == 0;
+- value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
+- if (value < 0) {
+- DEBUG (dev, "ep_queue --> %d\n", value);
+- req->status = 0;
+- eth_setup_complete (gadget->ep0, req);
+- }
+- }
+-
+- /* host either stalls (value < 0) or reports success */
+- return value;
+-}
+-
+-static void
+-eth_disconnect (struct usb_gadget *gadget)
+-{
+- struct eth_dev *dev = get_gadget_data (gadget);
+- unsigned long flags;
+-
+- spin_lock_irqsave (&dev->lock, flags);
+- netif_stop_queue (dev->net);
+- netif_carrier_off (dev->net);
+- eth_reset_config (dev);
+- spin_unlock_irqrestore (&dev->lock, flags);
+-
+- /* FIXME RNDIS should enter RNDIS_UNINITIALIZED */
+-
+- /* next we may get setup() calls to enumerate new connections;
+- * or an unbind() during shutdown (including removing module).
+- */
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/* NETWORK DRIVER HOOKUP (to the layer above this driver) */
+-
+-static int eth_change_mtu (struct net_device *net, int new_mtu)
+-{
+- struct eth_dev *dev = netdev_priv(net);
+-
+- if (dev->rndis)
+- return -EBUSY;
+-
+- if (new_mtu <= ETH_HLEN || new_mtu > ETH_FRAME_LEN)
+- return -ERANGE;
+- /* no zero-length packet read wanted after mtu-sized packets */
+- if (((new_mtu + sizeof (struct ethhdr)) % dev->in_ep->maxpacket) == 0)
+- return -EDOM;
+- net->mtu = new_mtu;
+- return 0;
+-}
+-
+-static struct net_device_stats *eth_get_stats (struct net_device *net)
+-{
+- return &((struct eth_dev *)netdev_priv(net))->stats;
+-}
+-
+-static void eth_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *p)
+-{
+- struct eth_dev *dev = netdev_priv(net);
+- strlcpy(p->driver, shortname, sizeof p->driver);
+- strlcpy(p->version, DRIVER_VERSION, sizeof p->version);
+- strlcpy(p->fw_version, dev->gadget->name, sizeof p->fw_version);
+- strlcpy (p->bus_info, dev->gadget->dev.bus_id, sizeof p->bus_info);
+-}
+-
+-static u32 eth_get_link(struct net_device *net)
+-{
+- struct eth_dev *dev = netdev_priv(net);
+- return dev->gadget->speed != USB_SPEED_UNKNOWN;
+-}
+-
+-static struct ethtool_ops ops = {
+- .get_drvinfo = eth_get_drvinfo,
+- .get_link = eth_get_link
+-};
+-
+-static void defer_kevent (struct eth_dev *dev, int flag)
+-{
+- if (test_and_set_bit (flag, &dev->todo))
+- return;
+- if (!schedule_work (&dev->work))
+- ERROR (dev, "kevent %d may have been dropped\n", flag);
++ if (can_support_ecm(c->cdev->gadget))
++ return ecm_bind_config(c, hostaddr);
+ else
+- DEBUG (dev, "kevent %d scheduled\n", flag);
+-}
+-
+-static void rx_complete (struct usb_ep *ep, struct usb_request *req);
+-
+-static int
+-rx_submit (struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags)
+-{
+- struct sk_buff *skb;
+- int retval = -ENOMEM;
+- size_t size;
+-
+- /* Padding up to RX_EXTRA handles minor disagreements with host.
+- * Normally we use the USB "terminate on short read" convention;
+- * so allow up to (N*maxpacket), since that memory is normally
+- * already allocated. Some hardware doesn't deal well with short
+- * reads (e.g. DMA must be N*maxpacket), so for now don't trim a
+- * byte off the end (to force hardware errors on overflow).
+- *
+- * RNDIS uses internal framing, and explicitly allows senders to
+- * pad to end-of-packet. That's potentially nice for speed,
+- * but means receivers can't recover synch on their own.
+- */
+- size = (sizeof (struct ethhdr) + dev->net->mtu + RX_EXTRA);
+- size += dev->out_ep->maxpacket - 1;
+- if (rndis_active(dev))
+- size += sizeof (struct rndis_packet_msg_type);
+- size -= size % dev->out_ep->maxpacket;
+-
+- skb = alloc_skb(size + NET_IP_ALIGN, gfp_flags);
+- if (skb == NULL) {
+- DEBUG (dev, "no rx skb\n");
+- goto enomem;
+- }
+-
+- /* Some platforms perform better when IP packets are aligned,
+- * but on at least one, checksumming fails otherwise. Note:
+- * RNDIS headers involve variable numbers of LE32 values.
+- */
+- skb_reserve(skb, NET_IP_ALIGN);
+-
+- req->buf = skb->data;
+- req->length = size;
+- req->complete = rx_complete;
+- req->context = skb;
+-
+- retval = usb_ep_queue (dev->out_ep, req, gfp_flags);
+- if (retval == -ENOMEM)
+-enomem:
+- defer_kevent (dev, WORK_RX_MEMORY);
+- if (retval) {
+- DEBUG (dev, "rx submit --> %d\n", retval);
+- if (skb)
+- dev_kfree_skb_any(skb);
+- spin_lock(&dev->req_lock);
+- list_add (&req->list, &dev->rx_reqs);
+- spin_unlock(&dev->req_lock);
+- }
+- return retval;
+-}
+-
+-static void rx_complete (struct usb_ep *ep, struct usb_request *req)
+-{
+- struct sk_buff *skb = req->context;
+- struct eth_dev *dev = ep->driver_data;
+- int status = req->status;
+-
+- switch (status) {
+-
+- /* normal completion */
+- case 0:
+- skb_put (skb, req->actual);
+- /* we know MaxPacketsPerTransfer == 1 here */
+- if (rndis_active(dev))
+- status = rndis_rm_hdr (skb);
+- if (status < 0
+- || ETH_HLEN > skb->len
+- || skb->len > ETH_FRAME_LEN) {
+- dev->stats.rx_errors++;
+- dev->stats.rx_length_errors++;
+- DEBUG (dev, "rx length %d\n", skb->len);
+- break;
+- }
+-
+- skb->protocol = eth_type_trans (skb, dev->net);
+- dev->stats.rx_packets++;
+- dev->stats.rx_bytes += skb->len;
+-
+- /* no buffer copies needed, unless hardware can't
+- * use skb buffers.
+- */
+- status = netif_rx (skb);
+- skb = NULL;
+- break;
+-
+- /* software-driven interface shutdown */
+- case -ECONNRESET: // unlink
+- case -ESHUTDOWN: // disconnect etc
+- VDEBUG (dev, "rx shutdown, code %d\n", status);
+- goto quiesce;
+-
+- /* for hardware automagic (such as pxa) */
+- case -ECONNABORTED: // endpoint reset
+- DEBUG (dev, "rx %s reset\n", ep->name);
+- defer_kevent (dev, WORK_RX_MEMORY);
+-quiesce:
+- dev_kfree_skb_any (skb);
+- goto clean;
+-
+- /* data overrun */
+- case -EOVERFLOW:
+- dev->stats.rx_over_errors++;
+- // FALLTHROUGH
+-
+- default:
+- dev->stats.rx_errors++;
+- DEBUG (dev, "rx status %d\n", status);
+- break;
+- }
+-
+- if (skb)
+- dev_kfree_skb_any (skb);
+- if (!netif_running (dev->net)) {
+-clean:
+- spin_lock(&dev->req_lock);
+- list_add (&req->list, &dev->rx_reqs);
+- spin_unlock(&dev->req_lock);
+- req = NULL;
+- }
+- if (req)
+- rx_submit (dev, req, GFP_ATOMIC);
+-}
+-
+-static int prealloc (struct list_head *list, struct usb_ep *ep,
+- unsigned n, gfp_t gfp_flags)
+-{
+- unsigned i;
+- struct usb_request *req;
+-
+- if (!n)
+- return -ENOMEM;
+-
+- /* queue/recycle up to N requests */
+- i = n;
+- list_for_each_entry (req, list, list) {
+- if (i-- == 0)
+- goto extra;
+- }
+- while (i--) {
+- req = usb_ep_alloc_request (ep, gfp_flags);
+- if (!req)
+- return list_empty (list) ? -ENOMEM : 0;
+- list_add (&req->list, list);
+- }
+- return 0;
+-
+-extra:
+- /* free extras */
+- for (;;) {
+- struct list_head *next;
+-
+- next = req->list.next;
+- list_del (&req->list);
+- usb_ep_free_request (ep, req);
+-
+- if (next == list)
+- break;
+-
+- req = container_of (next, struct usb_request, list);
+- }
+- return 0;
+-}
+-
+-static int alloc_requests (struct eth_dev *dev, unsigned n, gfp_t gfp_flags)
+-{
+- int status;
+-
+- spin_lock(&dev->req_lock);
+- status = prealloc (&dev->tx_reqs, dev->in_ep, n, gfp_flags);
+- if (status < 0)
+- goto fail;
+- status = prealloc (&dev->rx_reqs, dev->out_ep, n, gfp_flags);
+- if (status < 0)
+- goto fail;
+- goto done;
+-fail:
+- DEBUG (dev, "can't alloc requests\n");
+-done:
+- spin_unlock(&dev->req_lock);
+- return status;
+-}
+-
+-static void rx_fill (struct eth_dev *dev, gfp_t gfp_flags)
+-{
+- struct usb_request *req;
+- unsigned long flags;
+-
+- /* fill unused rxq slots with some skb */
+- spin_lock_irqsave(&dev->req_lock, flags);
+- while (!list_empty (&dev->rx_reqs)) {
+- req = container_of (dev->rx_reqs.next,
+- struct usb_request, list);
+- list_del_init (&req->list);
+- spin_unlock_irqrestore(&dev->req_lock, flags);
+-
+- if (rx_submit (dev, req, gfp_flags) < 0) {
+- defer_kevent (dev, WORK_RX_MEMORY);
+- return;
+- }
+-
+- spin_lock_irqsave(&dev->req_lock, flags);
+- }
+- spin_unlock_irqrestore(&dev->req_lock, flags);
+-}
+-
+-static void eth_work (struct work_struct *work)
+-{
+- struct eth_dev *dev = container_of(work, struct eth_dev, work);
+-
+- if (test_and_clear_bit (WORK_RX_MEMORY, &dev->todo)) {
+- if (netif_running (dev->net))
+- rx_fill (dev, GFP_KERNEL);
+- }
+-
+- if (dev->todo)
+- DEBUG (dev, "work done, flags = 0x%lx\n", dev->todo);
+-}
+-
+-static void tx_complete (struct usb_ep *ep, struct usb_request *req)
+-{
+- struct sk_buff *skb = req->context;
+- struct eth_dev *dev = ep->driver_data;
+-
+- switch (req->status) {
+- default:
+- dev->stats.tx_errors++;
+- VDEBUG (dev, "tx err %d\n", req->status);
+- /* FALLTHROUGH */
+- case -ECONNRESET: // unlink
+- case -ESHUTDOWN: // disconnect etc
+- break;
+- case 0:
+- dev->stats.tx_bytes += skb->len;
+- }
+- dev->stats.tx_packets++;
+-
+- spin_lock(&dev->req_lock);
+- list_add (&req->list, &dev->tx_reqs);
+- spin_unlock(&dev->req_lock);
+- dev_kfree_skb_any (skb);
+-
+- atomic_dec (&dev->tx_qlen);
+- if (netif_carrier_ok (dev->net))
+- netif_wake_queue (dev->net);
+-}
+-
+-static inline int eth_is_promisc (struct eth_dev *dev)
+-{
+- /* no filters for the CDC subset; always promisc */
+- if (subset_active (dev))
+- return 1;
+- return dev->cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;
+-}
+-
+-static int eth_start_xmit (struct sk_buff *skb, struct net_device *net)
+-{
+- struct eth_dev *dev = netdev_priv(net);
+- int length = skb->len;
+- int retval;
+- struct usb_request *req = NULL;
+- unsigned long flags;
+-
+- /* apply outgoing CDC or RNDIS filters */
+- if (!eth_is_promisc (dev)) {
+- u8 *dest = skb->data;
+-
+- if (is_multicast_ether_addr(dest)) {
+- u16 type;
+-
+- /* ignores USB_CDC_PACKET_TYPE_MULTICAST and host
+- * SET_ETHERNET_MULTICAST_FILTERS requests
+- */
+- if (is_broadcast_ether_addr(dest))
+- type = USB_CDC_PACKET_TYPE_BROADCAST;
+- else
+- type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;
+- if (!(dev->cdc_filter & type)) {
+- dev_kfree_skb_any (skb);
+- return 0;
+- }
+- }
+- /* ignores USB_CDC_PACKET_TYPE_DIRECTED */
+- }
+-
+- spin_lock_irqsave(&dev->req_lock, flags);
+- /*
+- * this freelist can be empty if an interrupt triggered disconnect()
+- * and reconfigured the gadget (shutting down this queue) after the
+- * network stack decided to xmit but before we got the spinlock.
+- */
+- if (list_empty(&dev->tx_reqs)) {
+- spin_unlock_irqrestore(&dev->req_lock, flags);
+- return 1;
+- }
+-
+- req = container_of (dev->tx_reqs.next, struct usb_request, list);
+- list_del (&req->list);
+-
+- /* temporarily stop TX queue when the freelist empties */
+- if (list_empty (&dev->tx_reqs))
+- netif_stop_queue (net);
+- spin_unlock_irqrestore(&dev->req_lock, flags);
+-
+- /* no buffer copies needed, unless the network stack did it
+- * or the hardware can't use skb buffers.
+- * or there's not enough space for any RNDIS headers we need
+- */
+- if (rndis_active(dev)) {
+- struct sk_buff *skb_rndis;
+-
+- skb_rndis = skb_realloc_headroom (skb,
+- sizeof (struct rndis_packet_msg_type));
+- if (!skb_rndis)
+- goto drop;
+-
+- dev_kfree_skb_any (skb);
+- skb = skb_rndis;
+- rndis_add_hdr (skb);
+- length = skb->len;
+- }
+- req->buf = skb->data;
+- req->context = skb;
+- req->complete = tx_complete;
+-
+- /* use zlp framing on tx for strict CDC-Ether conformance,
+- * though any robust network rx path ignores extra padding.
+- * and some hardware doesn't like to write zlps.
+- */
+- req->zero = 1;
+- if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)
+- length++;
+-
+- req->length = length;
+-
+- /* throttle highspeed IRQ rate back slightly */
+- if (gadget_is_dualspeed(dev->gadget))
+- req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
+- ? ((atomic_read(&dev->tx_qlen) % qmult) != 0)
+- : 0;
+-
+- retval = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);
+- switch (retval) {
+- default:
+- DEBUG (dev, "tx queue err %d\n", retval);
+- break;
+- case 0:
+- net->trans_start = jiffies;
+- atomic_inc (&dev->tx_qlen);
+- }
+-
+- if (retval) {
+-drop:
+- dev->stats.tx_dropped++;
+- dev_kfree_skb_any (skb);
+- spin_lock_irqsave(&dev->req_lock, flags);
+- if (list_empty (&dev->tx_reqs))
+- netif_start_queue (net);
+- list_add (&req->list, &dev->tx_reqs);
+- spin_unlock_irqrestore(&dev->req_lock, flags);
+- }
+- return 0;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-#ifdef CONFIG_USB_ETH_RNDIS
+-
+-/* The interrupt endpoint is used in RNDIS to notify the host when messages
+- * other than data packets are available ... notably the REMOTE_NDIS_*_CMPLT
+- * messages, but also REMOTE_NDIS_INDICATE_STATUS_MSG and potentially even
+- * REMOTE_NDIS_KEEPALIVE_MSG.
+- *
+- * The RNDIS control queue is processed by GET_ENCAPSULATED_RESPONSE, and
+- * normally just one notification will be queued.
+- */
+-
+-static struct usb_request *eth_req_alloc (struct usb_ep *, unsigned, gfp_t);
+-static void eth_req_free (struct usb_ep *ep, struct usb_request *req);
+-
+-static void
+-rndis_control_ack_complete (struct usb_ep *ep, struct usb_request *req)
+-{
+- struct eth_dev *dev = ep->driver_data;
+-
+- if (req->status || req->actual != req->length)
+- DEBUG (dev,
+- "rndis control ack complete --> %d, %d/%d\n",
+- req->status, req->actual, req->length);
+- req->context = NULL;
+-
+- if (req != dev->stat_req)
+- eth_req_free(ep, req);
+-}
+-
+-static int rndis_control_ack (struct net_device *net)
+-{
+- struct eth_dev *dev = netdev_priv(net);
+- int length;
+- struct usb_request *resp = dev->stat_req;
+-
+- /* in case RNDIS calls this after disconnect */
+- if (!dev->status) {
+- DEBUG (dev, "status ENODEV\n");
+- return -ENODEV;
+- }
+-
+- /* in case queue length > 1 */
+- if (resp->context) {
+- resp = eth_req_alloc (dev->status_ep, 8, GFP_ATOMIC);
+- if (!resp)
+- return -ENOMEM;
+- }
+-
+- /* Send RNDIS RESPONSE_AVAILABLE notification;
+- * USB_CDC_NOTIFY_RESPONSE_AVAILABLE should work too
+- */
+- resp->length = 8;
+- resp->complete = rndis_control_ack_complete;
+- resp->context = dev;
+-
+- *((__le32 *) resp->buf) = __constant_cpu_to_le32 (1);
+- *((__le32 *) resp->buf + 1) = __constant_cpu_to_le32 (0);
+-
+- length = usb_ep_queue (dev->status_ep, resp, GFP_ATOMIC);
+- if (length < 0) {
+- resp->status = 0;
+- rndis_control_ack_complete (dev->status_ep, resp);
+- }
+-
+- return 0;
+-}
+-
+-#else
+-
+-#define rndis_control_ack NULL
+-
+-#endif /* RNDIS */
+-
+-static void eth_start (struct eth_dev *dev, gfp_t gfp_flags)
+-{
+- DEBUG (dev, "%s\n", __func__);
+-
+- /* fill the rx queue */
+- rx_fill (dev, gfp_flags);
+-
+- /* and open the tx floodgates */
+- atomic_set (&dev->tx_qlen, 0);
+- netif_wake_queue (dev->net);
+- if (rndis_active(dev)) {
+- rndis_set_param_medium (dev->rndis_config,
+- NDIS_MEDIUM_802_3,
+- BITRATE(dev->gadget)/100);
+- (void) rndis_signal_connect (dev->rndis_config);
+- }
+-}
+-
+-static int eth_open (struct net_device *net)
+-{
+- struct eth_dev *dev = netdev_priv(net);
+-
+- DEBUG (dev, "%s\n", __func__);
+- if (netif_carrier_ok (dev->net))
+- eth_start (dev, GFP_KERNEL);
+- return 0;
++ return geth_bind_config(c, hostaddr);
+ }
+
+-static int eth_stop (struct net_device *net)
+-{
+- struct eth_dev *dev = netdev_priv(net);
+-
+- VDEBUG (dev, "%s\n", __func__);
+- netif_stop_queue (net);
+-
+- DEBUG (dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n",
+- dev->stats.rx_packets, dev->stats.tx_packets,
+- dev->stats.rx_errors, dev->stats.tx_errors
+- );
+-
+- /* ensure there are no more active requests */
+- if (dev->config) {
+- usb_ep_disable (dev->in_ep);
+- usb_ep_disable (dev->out_ep);
+- if (netif_carrier_ok (dev->net)) {
+- DEBUG (dev, "host still using in/out endpoints\n");
+- // FIXME idiom may leave toggle wrong here
+- usb_ep_enable (dev->in_ep, dev->in);
+- usb_ep_enable (dev->out_ep, dev->out);
+- }
+- if (dev->status_ep) {
+- usb_ep_disable (dev->status_ep);
+- usb_ep_enable (dev->status_ep, dev->status);
+- }
+- }
+-
+- if (rndis_active(dev)) {
+- rndis_set_param_medium(dev->rndis_config, NDIS_MEDIUM_802_3, 0);
+- (void) rndis_signal_disconnect (dev->rndis_config);
+- }
+-
+- return 0;
+-}
++static struct usb_configuration eth_config_driver = {
++ /* .label = f(hardware) */
++ .bind = eth_do_config,
++ .bConfigurationValue = 1,
++ /* .iConfiguration = DYNAMIC */
++ .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
++ .bMaxPower = 1, /* 2 mA, minimal */
++};
+
+ /*-------------------------------------------------------------------------*/
+
+-static struct usb_request *
+-eth_req_alloc (struct usb_ep *ep, unsigned size, gfp_t gfp_flags)
++static int __init eth_bind(struct usb_composite_dev *cdev)
+ {
+- struct usb_request *req;
+-
+- req = usb_ep_alloc_request (ep, gfp_flags);
+- if (!req)
+- return NULL;
+-
+- req->buf = kmalloc (size, gfp_flags);
+- if (!req->buf) {
+- usb_ep_free_request (ep, req);
+- req = NULL;
+- }
+- return req;
+-}
+-
+-static void
+-eth_req_free (struct usb_ep *ep, struct usb_request *req)
+-{
+- kfree (req->buf);
+- usb_ep_free_request (ep, req);
+-}
+-
+-
+-static void /* __init_or_exit */
+-eth_unbind (struct usb_gadget *gadget)
+-{
+- struct eth_dev *dev = get_gadget_data (gadget);
+-
+- DEBUG (dev, "unbind\n");
+- rndis_deregister (dev->rndis_config);
+- rndis_exit ();
+-
+- /* we've already been disconnected ... no i/o is active */
+- if (dev->req) {
+- eth_req_free (gadget->ep0, dev->req);
+- dev->req = NULL;
+- }
+- if (dev->stat_req) {
+- eth_req_free (dev->status_ep, dev->stat_req);
+- dev->stat_req = NULL;
+- }
+-
+- unregister_netdev (dev->net);
+- free_netdev(dev->net);
+-
+- /* assuming we used keventd, it must quiesce too */
+- flush_scheduled_work ();
+- set_gadget_data (gadget, NULL);
+-}
+-
+-static u8 __init nibble (unsigned char c)
+-{
+- if (likely (isdigit (c)))
+- return c - '0';
+- c = toupper (c);
+- if (likely (isxdigit (c)))
+- return 10 + c - 'A';
+- return 0;
+-}
++ int gcnum;
++ struct usb_gadget *gadget = cdev->gadget;
++ int status;
+
+-static int __init get_ether_addr(const char *str, u8 *dev_addr)
+-{
+- if (str) {
+- unsigned i;
++ /* set up network link layer */
++ status = gether_setup(cdev->gadget, hostaddr);
++ if (status < 0)
++ return status;
+
+- for (i = 0; i < 6; i++) {
+- unsigned char num;
++ /* set up main config label and device descriptor */
++ if (can_support_ecm(cdev->gadget)) {
++ /* ECM */
++ eth_config_driver.label = "CDC Ethernet (ECM)";
++ } else {
++ /* CDC Subset */
++ eth_config_driver.label = "CDC Subset/SAFE";
+
+- if((*str == '.') || (*str == ':'))
+- str++;
+- num = nibble(*str++) << 4;
+- num |= (nibble(*str++));
+- dev_addr [i] = num;
+- }
+- if (is_valid_ether_addr (dev_addr))
+- return 0;
++ device_desc.idVendor = cpu_to_le16(SIMPLE_VENDOR_NUM),
++ device_desc.idProduct = cpu_to_le16(SIMPLE_PRODUCT_NUM),
++ device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC;
+ }
+- random_ether_addr(dev_addr);
+- return 1;
+-}
+-
+-static int __init
+-eth_bind (struct usb_gadget *gadget)
+-{
+- struct eth_dev *dev;
+- struct net_device *net;
+- u8 cdc = 1, zlp = 1, rndis = 1;
+- struct usb_ep *in_ep, *out_ep, *status_ep = NULL;
+- int status = -ENOMEM;
+- int gcnum;
+-
+- /* these flags are only ever cleared; compiler take note */
+-#ifndef DEV_CONFIG_CDC
+- cdc = 0;
+-#endif
+-#ifndef CONFIG_USB_ETH_RNDIS
+- rndis = 0;
+-#endif
+
+- /* Because most host side USB stacks handle CDC Ethernet, that
+- * standard protocol is _strongly_ preferred for interop purposes.
+- * (By everyone except Microsoft.)
+- */
+- if (gadget_is_pxa (gadget)) {
+- /* pxa doesn't support altsettings */
+- cdc = 0;
+- } else if (gadget_is_musbhdrc(gadget)) {
+- /* reduce tx dma overhead by avoiding special cases */
+- zlp = 0;
+- } else if (gadget_is_sh(gadget)) {
+- /* sh doesn't support multiple interfaces or configs */
+- cdc = 0;
+- rndis = 0;
+- } else if (gadget_is_sa1100 (gadget)) {
+- /* hardware can't write zlps */
+- zlp = 0;
+- /* sa1100 CAN do CDC, without status endpoint ... we use
+- * non-CDC to be compatible with ARM Linux-2.4 "usb-eth".
+- */
+- cdc = 0;
++ if (has_rndis()) {
++ /* RNDIS plus ECM-or-Subset */
++ device_desc.idVendor = cpu_to_le16(RNDIS_VENDOR_NUM),
++ device_desc.idProduct = cpu_to_le16(RNDIS_PRODUCT_NUM),
++ device_desc.bNumConfigurations = 2;
+ }
+
+- gcnum = usb_gadget_controller_number (gadget);
++ gcnum = usb_gadget_controller_number(gadget);
+ if (gcnum >= 0)
+- device_desc.bcdDevice = cpu_to_le16 (0x0200 + gcnum);
++ device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
+ else {
+- /* can't assume CDC works. don't want to default to
+- * anything less functional on CDC-capable hardware,
+- * so we fail in this case.
++ /* We assume that can_support_ecm() tells the truth;
++ * but if the controller isn't recognized at all then
++ * that assumption is a bit more likely to be wrong.
+ */
+- dev_err (&gadget->dev,
+- "controller '%s' not recognized\n",
+- gadget->name);
+- return -ENODEV;
+- }
+- snprintf (manufacturer, sizeof manufacturer, "%s %s/%s",
+- init_utsname()->sysname, init_utsname()->release,
+- gadget->name);
+-
+- /* If there's an RNDIS configuration, that's what Windows wants to
+- * be using ... so use these product IDs here and in the "linux.inf"
+- * needed to install MSFT drivers. Current Linux kernels will use
+- * the second configuration if it's CDC Ethernet, and need some help
+- * to choose the right configuration otherwise.
+- */
+- if (rndis) {
+- device_desc.idVendor =
+- __constant_cpu_to_le16(RNDIS_VENDOR_NUM);
+- device_desc.idProduct =
+- __constant_cpu_to_le16(RNDIS_PRODUCT_NUM);
+- snprintf (product_desc, sizeof product_desc,
+- "RNDIS/%s", driver_desc);
+-
+- /* CDC subset ... recognized by Linux since 2.4.10, but Windows
+- * drivers aren't widely available. (That may be improved by
+- * supporting one submode of the "SAFE" variant of MDLM.)
+- */
+- } else if (!cdc) {
+- device_desc.idVendor =
+- __constant_cpu_to_le16(SIMPLE_VENDOR_NUM);
+- device_desc.idProduct =
+- __constant_cpu_to_le16(SIMPLE_PRODUCT_NUM);
+- }
+-
+- /* support optional vendor/distro customization */
+- if (idVendor) {
+- if (!idProduct) {
+- dev_err (&gadget->dev, "idVendor needs idProduct!\n");
+- return -ENODEV;
+- }
+- device_desc.idVendor = cpu_to_le16(idVendor);
+- device_desc.idProduct = cpu_to_le16(idProduct);
+- if (bcdDevice)
+- device_desc.bcdDevice = cpu_to_le16(bcdDevice);
+- }
+- if (iManufacturer)
+- strlcpy (manufacturer, iManufacturer, sizeof manufacturer);
+- if (iProduct)
+- strlcpy (product_desc, iProduct, sizeof product_desc);
+- if (iSerialNumber) {
+- device_desc.iSerialNumber = STRING_SERIALNUMBER,
+- strlcpy(serial_number, iSerialNumber, sizeof serial_number);
+- }
+-
+- /* all we really need is bulk IN/OUT */
+- usb_ep_autoconfig_reset (gadget);
+- in_ep = usb_ep_autoconfig (gadget, &fs_source_desc);
+- if (!in_ep) {
+-autoconf_fail:
+- dev_err (&gadget->dev,
+- "can't autoconfigure on %s\n",
+- gadget->name);
+- return -ENODEV;
+- }
+- in_ep->driver_data = in_ep; /* claim */
+-
+- out_ep = usb_ep_autoconfig (gadget, &fs_sink_desc);
+- if (!out_ep)
+- goto autoconf_fail;
+- out_ep->driver_data = out_ep; /* claim */
+-
+-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
+- /* CDC Ethernet control interface doesn't require a status endpoint.
+- * Since some hosts expect one, try to allocate one anyway.
+- */
+- if (cdc || rndis) {
+- status_ep = usb_ep_autoconfig (gadget, &fs_status_desc);
+- if (status_ep) {
+- status_ep->driver_data = status_ep; /* claim */
+- } else if (rndis) {
+- dev_err (&gadget->dev,
+- "can't run RNDIS on %s\n",
+- gadget->name);
+- return -ENODEV;
+-#ifdef DEV_CONFIG_CDC
+- /* pxa25x only does CDC subset; often used with RNDIS */
+- } else if (cdc) {
+- control_intf.bNumEndpoints = 0;
+- /* FIXME remove endpoint from descriptor list */
+-#endif
+- }
+- }
+-#endif
+-
+- /* one config: cdc, else minimal subset */
+- if (!cdc) {
+- eth_config.bNumInterfaces = 1;
+- eth_config.iConfiguration = STRING_SUBSET;
+-
+- /* use functions to set these up, in case we're built to work
+- * with multiple controllers and must override CDC Ethernet.
+- */
+- fs_subset_descriptors();
+- hs_subset_descriptors();
+- }
+-
+- device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
+- usb_gadget_set_selfpowered (gadget);
+-
+- /* For now RNDIS is always a second config */
+- if (rndis)
+- device_desc.bNumConfigurations = 2;
+-
+- if (gadget_is_dualspeed(gadget)) {
+- if (rndis)
+- dev_qualifier.bNumConfigurations = 2;
+- else if (!cdc)
+- dev_qualifier.bDeviceClass = USB_CLASS_VENDOR_SPEC;
+-
+- /* assumes ep0 uses the same value for both speeds ... */
+- dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
+-
+- /* and that all endpoints are dual-speed */
+- hs_source_desc.bEndpointAddress =
+- fs_source_desc.bEndpointAddress;
+- hs_sink_desc.bEndpointAddress =
+- fs_sink_desc.bEndpointAddress;
+-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
+- if (status_ep)
+- hs_status_desc.bEndpointAddress =
+- fs_status_desc.bEndpointAddress;
+-#endif
++ WARNING(cdev, "controller '%s' not recognized; trying %s\n",
++ gadget->name,
++ eth_config_driver.label);
++ device_desc.bcdDevice =
++ __constant_cpu_to_le16(0x0300 | 0x0099);
+ }
+
+- if (gadget_is_otg(gadget)) {
+- otg_descriptor.bmAttributes |= USB_OTG_HNP,
+- eth_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+- eth_config.bMaxPower = 4;
+-#ifdef CONFIG_USB_ETH_RNDIS
+- rndis_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+- rndis_config.bMaxPower = 4;
+-#endif
+- }
+-
+- net = alloc_etherdev (sizeof *dev);
+- if (!net)
+- return status;
+- dev = netdev_priv(net);
+- spin_lock_init (&dev->lock);
+- spin_lock_init (&dev->req_lock);
+- INIT_WORK (&dev->work, eth_work);
+- INIT_LIST_HEAD (&dev->tx_reqs);
+- INIT_LIST_HEAD (&dev->rx_reqs);
+-
+- /* network device setup */
+- dev->net = net;
+- strcpy (net->name, "usb%d");
+- dev->cdc = cdc;
+- dev->zlp = zlp;
+
+- dev->in_ep = in_ep;
+- dev->out_ep = out_ep;
+- dev->status_ep = status_ep;
+-
+- /* Module params for these addresses should come from ID proms.
+- * The host side address is used with CDC and RNDIS, and commonly
+- * ends up in a persistent config database. It's not clear if
+- * host side code for the SAFE thing cares -- its original BLAN
+- * thing didn't, Sharp never assigned those addresses on Zaurii.
++ /* Allocate string descriptor numbers ... note that string
++ * contents can be overridden by the composite_dev glue.
+ */
+- if (get_ether_addr(dev_addr, net->dev_addr))
+- dev_warn(&gadget->dev,
+- "using random %s ethernet address\n", "self");
+- if (get_ether_addr(host_addr, dev->host_mac))
+- dev_warn(&gadget->dev,
+- "using random %s ethernet address\n", "host");
+- snprintf (ethaddr, sizeof ethaddr, "%02X%02X%02X%02X%02X%02X",
+- dev->host_mac [0], dev->host_mac [1],
+- dev->host_mac [2], dev->host_mac [3],
+- dev->host_mac [4], dev->host_mac [5]);
+-
+- if (rndis) {
+- status = rndis_init();
+- if (status < 0) {
+- dev_err (&gadget->dev, "can't init RNDIS, %d\n",
+- status);
+- goto fail;
+- }
+- }
+
+- net->change_mtu = eth_change_mtu;
+- net->get_stats = eth_get_stats;
+- net->hard_start_xmit = eth_start_xmit;
+- net->open = eth_open;
+- net->stop = eth_stop;
+- // watchdog_timeo, tx_timeout ...
+- // set_multicast_list
+- SET_ETHTOOL_OPS(net, &ops);
++ /* device descriptor strings: manufacturer, product */
++ snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
++ init_utsname()->sysname, init_utsname()->release,
++ gadget->name);
++ status = usb_string_id(cdev);
++ if (status < 0)
++ goto fail;
++ strings_dev[STRING_MANUFACTURER_IDX].id = status;
++ device_desc.iManufacturer = status;
+
+- /* preallocate control message data and buffer */
+- dev->req = eth_req_alloc (gadget->ep0, USB_BUFSIZ, GFP_KERNEL);
+- if (!dev->req)
++ status = usb_string_id(cdev);
++ if (status < 0)
+ goto fail;
+- dev->req->complete = eth_setup_complete;
++ strings_dev[STRING_PRODUCT_IDX].id = status;
++ device_desc.iProduct = status;
+
+- /* ... and maybe likewise for status transfer */
+-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
+- if (dev->status_ep) {
+- dev->stat_req = eth_req_alloc (dev->status_ep,
+- STATUS_BYTECOUNT, GFP_KERNEL);
+- if (!dev->stat_req) {
+- eth_req_free (gadget->ep0, dev->req);
++ /* register our configuration(s); RNDIS first, if it's used */
++ if (has_rndis()) {
++ status = usb_add_config(cdev, &rndis_config_driver);
++ if (status < 0)
+ goto fail;
+- }
+- dev->stat_req->context = NULL;
+ }
+-#endif
+-
+- /* finish hookup to lower layer ... */
+- dev->gadget = gadget;
+- set_gadget_data (gadget, dev);
+- gadget->ep0->driver_data = dev;
+
+- /* two kinds of host-initiated state changes:
+- * - iff DATA transfer is active, carrier is "on"
+- * - tx queueing enabled if open *and* carrier is "on"
+- */
+- netif_stop_queue (dev->net);
+- netif_carrier_off (dev->net);
+-
+- SET_NETDEV_DEV (dev->net, &gadget->dev);
+- status = register_netdev (dev->net);
++ status = usb_add_config(cdev, ð_config_driver);
+ if (status < 0)
+- goto fail1;
+-
+- INFO (dev, "%s, version: " DRIVER_VERSION "\n", driver_desc);
+- INFO (dev, "using %s, OUT %s IN %s%s%s\n", gadget->name,
+- out_ep->name, in_ep->name,
+- status_ep ? " STATUS " : "",
+- status_ep ? status_ep->name : ""
+- );
+- INFO (dev, "MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+- net->dev_addr [0], net->dev_addr [1],
+- net->dev_addr [2], net->dev_addr [3],
+- net->dev_addr [4], net->dev_addr [5]);
+-
+- if (cdc || rndis)
+- INFO (dev, "HOST MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+- dev->host_mac [0], dev->host_mac [1],
+- dev->host_mac [2], dev->host_mac [3],
+- dev->host_mac [4], dev->host_mac [5]);
+-
+- if (rndis) {
+- u32 vendorID = 0;
+-
+- /* FIXME RNDIS vendor id == "vendor NIC code" == ? */
+-
+- dev->rndis_config = rndis_register (rndis_control_ack);
+- if (dev->rndis_config < 0) {
+-fail0:
+- unregister_netdev (dev->net);
+- status = -ENODEV;
+- goto fail;
+- }
++ goto fail;
+
+- /* these set up a lot of the OIDs that RNDIS needs */
+- rndis_set_host_mac (dev->rndis_config, dev->host_mac);
+- if (rndis_set_param_dev (dev->rndis_config, dev->net,
+- &dev->stats, &dev->cdc_filter))
+- goto fail0;
+- if (rndis_set_param_vendor(dev->rndis_config, vendorID,
+- manufacturer))
+- goto fail0;
+- if (rndis_set_param_medium(dev->rndis_config,
+- NDIS_MEDIUM_802_3, 0))
+- goto fail0;
+- INFO (dev, "RNDIS ready\n");
+- }
++ INFO(cdev, "%s, version: " DRIVER_VERSION "\n", DRIVER_DESC);
+
+- return status;
++ return 0;
+
+-fail1:
+- dev_dbg(&gadget->dev, "register_netdev failed, %d\n", status);
+ fail:
+- eth_unbind (gadget);
++ gether_cleanup();
+ return status;
+ }
+
+-/*-------------------------------------------------------------------------*/
+-
+-static void
+-eth_suspend (struct usb_gadget *gadget)
+-{
+- struct eth_dev *dev = get_gadget_data (gadget);
+-
+- DEBUG (dev, "suspend\n");
+- dev->suspended = 1;
+-}
+-
+-static void
+-eth_resume (struct usb_gadget *gadget)
++static int __exit eth_unbind(struct usb_composite_dev *cdev)
+ {
+- struct eth_dev *dev = get_gadget_data (gadget);
+-
+- DEBUG (dev, "resume\n");
+- dev->suspended = 0;
++ gether_cleanup();
++ return 0;
+ }
+
+-/*-------------------------------------------------------------------------*/
+-
+-static struct usb_gadget_driver eth_driver = {
+- .speed = DEVSPEED,
+-
+- .function = (char *) driver_desc,
++static struct usb_composite_driver eth_driver = {
++ .name = "g_ether",
++ .dev = &device_desc,
++ .strings = dev_strings,
+ .bind = eth_bind,
+- .unbind = eth_unbind,
+-
+- .setup = eth_setup,
+- .disconnect = eth_disconnect,
+-
+- .suspend = eth_suspend,
+- .resume = eth_resume,
+-
+- .driver = {
+- .name = (char *) shortname,
+- .owner = THIS_MODULE,
+- },
++ .unbind = __exit_p(eth_unbind),
+ };
+
+-MODULE_DESCRIPTION (DRIVER_DESC);
+-MODULE_AUTHOR ("David Brownell, Benedikt Spanger");
+-MODULE_LICENSE ("GPL");
++MODULE_DESCRIPTION(PREFIX DRIVER_DESC);
++MODULE_AUTHOR("David Brownell, Benedikt Spanger");
++MODULE_LICENSE("GPL");
+
+-
+-static int __init init (void)
++static int __init init(void)
+ {
+- return usb_gadget_register_driver (ð_driver);
++ return usb_composite_register(ð_driver);
+ }
+-module_init (init);
++module_init(init);
+
+-static void __exit cleanup (void)
++static void __exit cleanup(void)
+ {
+- usb_gadget_unregister_driver (ð_driver);
++ usb_composite_unregister(ð_driver);
+ }
+-module_exit (cleanup);
+-
++module_exit(cleanup);
+diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
+new file mode 100644
+index 0000000..5ee1590
+--- /dev/null
++++ b/drivers/usb/gadget/f_acm.c
+@@ -0,0 +1,759 @@
++/*
++ * f_acm.c -- USB CDC serial (ACM) function driver
++ *
++ * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
++ * Copyright (C) 2008 by David Brownell
++ * Copyright (C) 2008 by Nokia Corporation
++ *
++ * This software is distributed under the terms of the GNU General
++ * Public License ("GPL") as published by the Free Software Foundation,
++ * either version 2 of that License or (at your option) any later version.
++ */
++
++/* #define VERBOSE_DEBUG */
++
++#include <linux/kernel.h>
++#include <linux/device.h>
++
++#include "u_serial.h"
++#include "gadget_chips.h"
++
++
++/*
++ * This CDC ACM function support just wraps control functions and
++ * notifications around the generic serial-over-usb code.
++ *
++ * Because CDC ACM is standardized by the USB-IF, many host operating
++ * systems have drivers for it. Accordingly, ACM is the preferred
++ * interop solution for serial-port type connections. The control
++ * models are often not necessary, and in any case don't do much in
++ * this bare-bones implementation.
++ *
++ * Note that even MS-Windows has some support for ACM. However, that
++ * support is somewhat broken because when you use ACM in a composite
++ * device, having multiple interfaces confuses the poor OS. It doesn't
++ * seem to understand CDC Union descriptors. The new "association"
++ * descriptors (roughly equivalent to CDC Unions) may sometimes help.
++ */
++
++struct acm_ep_descs {
++ struct usb_endpoint_descriptor *in;
++ struct usb_endpoint_descriptor *out;
++ struct usb_endpoint_descriptor *notify;
++};
++
++struct f_acm {
++ struct gserial port;
++ u8 ctrl_id, data_id;
++ u8 port_num;
++
++ u8 pending;
++
++ /* lock is mostly for pending and notify_req ... they get accessed
++ * by callbacks both from tty (open/close/break) under its spinlock,
++ * and notify_req.complete() which can't use that lock.
++ */
++ spinlock_t lock;
++
++ struct acm_ep_descs fs;
++ struct acm_ep_descs hs;
++
++ struct usb_ep *notify;
++ struct usb_endpoint_descriptor *notify_desc;
++ struct usb_request *notify_req;
++
++ struct usb_cdc_line_coding port_line_coding; /* 8-N-1 etc */
++
++ /* SetControlLineState request -- CDC 1.1 section 6.2.14 (INPUT) */
++ u16 port_handshake_bits;
++#define ACM_CTRL_RTS (1 << 1) /* unused with full duplex */
++#define ACM_CTRL_DTR (1 << 0) /* host is ready for data r/w */
++
++ /* SerialState notification -- CDC 1.1 section 6.3.5 (OUTPUT) */
++ u16 serial_state;
++#define ACM_CTRL_OVERRUN (1 << 6)
++#define ACM_CTRL_PARITY (1 << 5)
++#define ACM_CTRL_FRAMING (1 << 4)
++#define ACM_CTRL_RI (1 << 3)
++#define ACM_CTRL_BRK (1 << 2)
++#define ACM_CTRL_DSR (1 << 1)
++#define ACM_CTRL_DCD (1 << 0)
++};
++
++static inline struct f_acm *func_to_acm(struct usb_function *f)
++{
++ return container_of(f, struct f_acm, port.func);
++}
++
++static inline struct f_acm *port_to_acm(struct gserial *p)
++{
++ return container_of(p, struct f_acm, port);
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* notification endpoint uses smallish and infrequent fixed-size messages */
++
++#define GS_LOG2_NOTIFY_INTERVAL 5 /* 1 << 5 == 32 msec */
++#define GS_NOTIFY_MAXPACKET 10 /* notification + 2 bytes */
++
++/* interface and class descriptors: */
++
++static struct usb_interface_descriptor acm_control_interface_desc __initdata = {
++ .bLength = USB_DT_INTERFACE_SIZE,
++ .bDescriptorType = USB_DT_INTERFACE,
++ /* .bInterfaceNumber = DYNAMIC */
++ .bNumEndpoints = 1,
++ .bInterfaceClass = USB_CLASS_COMM,
++ .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
++ .bInterfaceProtocol = USB_CDC_ACM_PROTO_AT_V25TER,
++ /* .iInterface = DYNAMIC */
++};
++
++static struct usb_interface_descriptor acm_data_interface_desc __initdata = {
++ .bLength = USB_DT_INTERFACE_SIZE,
++ .bDescriptorType = USB_DT_INTERFACE,
++ /* .bInterfaceNumber = DYNAMIC */
++ .bNumEndpoints = 2,
++ .bInterfaceClass = USB_CLASS_CDC_DATA,
++ .bInterfaceSubClass = 0,
++ .bInterfaceProtocol = 0,
++ /* .iInterface = DYNAMIC */
++};
++
++static struct usb_cdc_header_desc acm_header_desc __initdata = {
++ .bLength = sizeof(acm_header_desc),
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_HEADER_TYPE,
++ .bcdCDC = __constant_cpu_to_le16(0x0110),
++};
++
++static struct usb_cdc_call_mgmt_descriptor
++acm_call_mgmt_descriptor __initdata = {
++ .bLength = sizeof(acm_call_mgmt_descriptor),
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,
++ .bmCapabilities = 0,
++ /* .bDataInterface = DYNAMIC */
++};
++
++static struct usb_cdc_acm_descriptor acm_descriptor __initdata = {
++ .bLength = sizeof(acm_descriptor),
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_ACM_TYPE,
++ .bmCapabilities = USB_CDC_CAP_LINE,
++};
++
++static struct usb_cdc_union_desc acm_union_desc __initdata = {
++ .bLength = sizeof(acm_union_desc),
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_UNION_TYPE,
++ /* .bMasterInterface0 = DYNAMIC */
++ /* .bSlaveInterface0 = DYNAMIC */
++};
++
++/* full speed support: */
++
++static struct usb_endpoint_descriptor acm_fs_notify_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_INT,
++ .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
++ .bInterval = 1 << GS_LOG2_NOTIFY_INTERVAL,
++};
++
++static struct usb_endpoint_descriptor acm_fs_in_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_endpoint_descriptor acm_fs_out_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_OUT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_descriptor_header *acm_fs_function[] __initdata = {
++ (struct usb_descriptor_header *) &acm_control_interface_desc,
++ (struct usb_descriptor_header *) &acm_header_desc,
++ (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
++ (struct usb_descriptor_header *) &acm_descriptor,
++ (struct usb_descriptor_header *) &acm_union_desc,
++ (struct usb_descriptor_header *) &acm_fs_notify_desc,
++ (struct usb_descriptor_header *) &acm_data_interface_desc,
++ (struct usb_descriptor_header *) &acm_fs_in_desc,
++ (struct usb_descriptor_header *) &acm_fs_out_desc,
++ NULL,
++};
++
++/* high speed support: */
++
++static struct usb_endpoint_descriptor acm_hs_notify_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_INT,
++ .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
++ .bInterval = GS_LOG2_NOTIFY_INTERVAL+4,
++};
++
++static struct usb_endpoint_descriptor acm_hs_in_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_endpoint_descriptor acm_hs_out_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_descriptor_header *acm_hs_function[] __initdata = {
++ (struct usb_descriptor_header *) &acm_control_interface_desc,
++ (struct usb_descriptor_header *) &acm_header_desc,
++ (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
++ (struct usb_descriptor_header *) &acm_descriptor,
++ (struct usb_descriptor_header *) &acm_union_desc,
++ (struct usb_descriptor_header *) &acm_hs_notify_desc,
++ (struct usb_descriptor_header *) &acm_data_interface_desc,
++ (struct usb_descriptor_header *) &acm_hs_in_desc,
++ (struct usb_descriptor_header *) &acm_hs_out_desc,
++ NULL,
++};
++
++/* string descriptors: */
++
++#define ACM_CTRL_IDX 0
++#define ACM_DATA_IDX 1
++
++/* static strings, in UTF-8 */
++static struct usb_string acm_string_defs[] = {
++ [ACM_CTRL_IDX].s = "CDC Abstract Control Model (ACM)",
++ [ACM_DATA_IDX].s = "CDC ACM Data",
++ { /* ZEROES END LIST */ },
++};
++
++static struct usb_gadget_strings acm_string_table = {
++ .language = 0x0409, /* en-us */
++ .strings = acm_string_defs,
++};
++
++static struct usb_gadget_strings *acm_strings[] = {
++ &acm_string_table,
++ NULL,
++};
++
++/*-------------------------------------------------------------------------*/
++
++/* ACM control ... data handling is delegated to tty library code.
++ * The main task of this function is to activate and deactivate
++ * that code based on device state; track parameters like line
++ * speed, handshake state, and so on; and issue notifications.
++ */
++
++static void acm_complete_set_line_coding(struct usb_ep *ep,
++ struct usb_request *req)
++{
++ struct f_acm *acm = ep->driver_data;
++ struct usb_composite_dev *cdev = acm->port.func.config->cdev;
++
++ if (req->status != 0) {
++ DBG(cdev, "acm ttyGS%d completion, err %d\n",
++ acm->port_num, req->status);
++ return;
++ }
++
++ /* normal completion */
++ if (req->actual != sizeof(acm->port_line_coding)) {
++ DBG(cdev, "acm ttyGS%d short resp, len %d\n",
++ acm->port_num, req->actual);
++ usb_ep_set_halt(ep);
++ } else {
++ struct usb_cdc_line_coding *value = req->buf;
++
++ /* REVISIT: we currently just remember this data.
++ * If we change that, (a) validate it first, then
++ * (b) update whatever hardware needs updating,
++ * (c) worry about locking. This is information on
++ * the order of 9600-8-N-1 ... most of which means
++ * nothing unless we control a real RS232 line.
++ */
++ acm->port_line_coding = *value;
++ }
++}
++
++static int acm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
++{
++ struct f_acm *acm = func_to_acm(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++ struct usb_request *req = cdev->req;
++ int value = -EOPNOTSUPP;
++ u16 w_index = le16_to_cpu(ctrl->wIndex);
++ u16 w_value = le16_to_cpu(ctrl->wValue);
++ u16 w_length = le16_to_cpu(ctrl->wLength);
++
++ /* composite driver infrastructure handles everything except
++ * CDC class messages; interface activation uses set_alt().
++ *
++ * Note CDC spec table 4 lists the ACM request profile. It requires
++ * encapsulated command support ... we don't handle any, and respond
++ * to them by stalling. Options include get/set/clear comm features
++ * (not that useful) and SEND_BREAK.
++ */
++ switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
++
++ /* SET_LINE_CODING ... just read and save what the host sends */
++ case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
++ | USB_CDC_REQ_SET_LINE_CODING:
++ if (w_length != sizeof(struct usb_cdc_line_coding)
++ || w_index != acm->ctrl_id)
++ goto invalid;
++
++ value = w_length;
++ cdev->gadget->ep0->driver_data = acm;
++ req->complete = acm_complete_set_line_coding;
++ break;
++
++ /* GET_LINE_CODING ... return what host sent, or initial value */
++ case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
++ | USB_CDC_REQ_GET_LINE_CODING:
++ if (w_index != acm->ctrl_id)
++ goto invalid;
++
++ value = min_t(unsigned, w_length,
++ sizeof(struct usb_cdc_line_coding));
++ memcpy(req->buf, &acm->port_line_coding, value);
++ break;
++
++ /* SET_CONTROL_LINE_STATE ... save what the host sent */
++ case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
++ | USB_CDC_REQ_SET_CONTROL_LINE_STATE:
++ if (w_index != acm->ctrl_id)
++ goto invalid;
++
++ value = 0;
++
++ /* FIXME we should not allow data to flow until the
++ * host sets the ACM_CTRL_DTR bit; and when it clears
++ * that bit, we should return to that no-flow state.
++ */
++ acm->port_handshake_bits = w_value;
++ break;
++
++ default:
++invalid:
++ VDBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
++ ctrl->bRequestType, ctrl->bRequest,
++ w_value, w_index, w_length);
++ }
++
++ /* respond with data transfer or status phase? */
++ if (value >= 0) {
++ DBG(cdev, "acm ttyGS%d req%02x.%02x v%04x i%04x l%d\n",
++ acm->port_num, ctrl->bRequestType, ctrl->bRequest,
++ w_value, w_index, w_length);
++ req->zero = 0;
++ req->length = value;
++ value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
++ if (value < 0)
++ ERROR(cdev, "acm response on ttyGS%d, err %d\n",
++ acm->port_num, value);
++ }
++
++ /* device either stalls (value < 0) or reports success */
++ return value;
++}
++
++static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
++{
++ struct f_acm *acm = func_to_acm(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ /* we know alt == 0, so this is an activation or a reset */
++
++ if (intf == acm->ctrl_id) {
++ if (acm->notify->driver_data) {
++ VDBG(cdev, "reset acm control interface %d\n", intf);
++ usb_ep_disable(acm->notify);
++ } else {
++ VDBG(cdev, "init acm ctrl interface %d\n", intf);
++ acm->notify_desc = ep_choose(cdev->gadget,
++ acm->hs.notify,
++ acm->fs.notify);
++ }
++ usb_ep_enable(acm->notify, acm->notify_desc);
++ acm->notify->driver_data = acm;
++
++ } else if (intf == acm->data_id) {
++ if (acm->port.in->driver_data) {
++ DBG(cdev, "reset acm ttyGS%d\n", acm->port_num);
++ gserial_disconnect(&acm->port);
++ } else {
++ DBG(cdev, "activate acm ttyGS%d\n", acm->port_num);
++ acm->port.in_desc = ep_choose(cdev->gadget,
++ acm->hs.in, acm->fs.in);
++ acm->port.out_desc = ep_choose(cdev->gadget,
++ acm->hs.out, acm->fs.out);
++ }
++ gserial_connect(&acm->port, acm->port_num);
++
++ } else
++ return -EINVAL;
++
++ return 0;
++}
++
++static void acm_disable(struct usb_function *f)
++{
++ struct f_acm *acm = func_to_acm(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ DBG(cdev, "acm ttyGS%d deactivated\n", acm->port_num);
++ gserial_disconnect(&acm->port);
++ usb_ep_disable(acm->notify);
++ acm->notify->driver_data = NULL;
++}
++
++/*-------------------------------------------------------------------------*/
++
++/**
++ * acm_cdc_notify - issue CDC notification to host
++ * @acm: wraps host to be notified
++ * @type: notification type
++ * @value: Refer to cdc specs, wValue field.
++ * @data: data to be sent
++ * @length: size of data
++ * Context: irqs blocked, acm->lock held, acm_notify_req non-null
++ *
++ * Returns zero on sucess or a negative errno.
++ *
++ * See section 6.3.5 of the CDC 1.1 specification for information
++ * about the only notification we issue: SerialState change.
++ */
++static int acm_cdc_notify(struct f_acm *acm, u8 type, u16 value,
++ void *data, unsigned length)
++{
++ struct usb_ep *ep = acm->notify;
++ struct usb_request *req;
++ struct usb_cdc_notification *notify;
++ const unsigned len = sizeof(*notify) + length;
++ void *buf;
++ int status;
++
++ req = acm->notify_req;
++ acm->notify_req = NULL;
++ acm->pending = false;
++
++ req->length = len;
++ notify = req->buf;
++ buf = notify + 1;
++
++ notify->bmRequestType = USB_DIR_IN | USB_TYPE_CLASS
++ | USB_RECIP_INTERFACE;
++ notify->bNotificationType = type;
++ notify->wValue = cpu_to_le16(value);
++ notify->wIndex = cpu_to_le16(acm->ctrl_id);
++ notify->wLength = cpu_to_le16(length);
++ memcpy(buf, data, length);
++
++ status = usb_ep_queue(ep, req, GFP_ATOMIC);
++ if (status < 0) {
++ ERROR(acm->port.func.config->cdev,
++ "acm ttyGS%d can't notify serial state, %d\n",
++ acm->port_num, status);
++ acm->notify_req = req;
++ }
++
++ return status;
++}
++
++static int acm_notify_serial_state(struct f_acm *acm)
++{
++ struct usb_composite_dev *cdev = acm->port.func.config->cdev;
++ int status;
++
++ spin_lock(&acm->lock);
++ if (acm->notify_req) {
++ DBG(cdev, "acm ttyGS%d serial state %04x\n",
++ acm->port_num, acm->serial_state);
++ status = acm_cdc_notify(acm, USB_CDC_NOTIFY_SERIAL_STATE,
++ 0, &acm->serial_state, sizeof(acm->serial_state));
++ } else {
++ acm->pending = true;
++ status = 0;
++ }
++ spin_unlock(&acm->lock);
++ return status;
++}
++
++static void acm_cdc_notify_complete(struct usb_ep *ep, struct usb_request *req)
++{
++ struct f_acm *acm = req->context;
++ u8 doit = false;
++
++ /* on this call path we do NOT hold the port spinlock,
++ * which is why ACM needs its own spinlock
++ */
++ spin_lock(&acm->lock);
++ if (req->status != -ESHUTDOWN)
++ doit = acm->pending;
++ acm->notify_req = req;
++ spin_unlock(&acm->lock);
++
++ if (doit)
++ acm_notify_serial_state(acm);
++}
++
++/* connect == the TTY link is open */
++
++static void acm_connect(struct gserial *port)
++{
++ struct f_acm *acm = port_to_acm(port);
++
++ acm->serial_state |= ACM_CTRL_DSR | ACM_CTRL_DCD;
++ acm_notify_serial_state(acm);
++}
++
++static void acm_disconnect(struct gserial *port)
++{
++ struct f_acm *acm = port_to_acm(port);
++
++ acm->serial_state &= ~(ACM_CTRL_DSR | ACM_CTRL_DCD);
++ acm_notify_serial_state(acm);
++}
++
++static int acm_send_break(struct gserial *port, int duration)
++{
++ struct f_acm *acm = port_to_acm(port);
++ u16 state;
++
++ state = acm->serial_state;
++ state &= ~ACM_CTRL_BRK;
++ if (duration)
++ state |= ACM_CTRL_BRK;
++
++ acm->serial_state = state;
++ return acm_notify_serial_state(acm);
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* ACM function driver setup/binding */
++static int __init
++acm_bind(struct usb_configuration *c, struct usb_function *f)
++{
++ struct usb_composite_dev *cdev = c->cdev;
++ struct f_acm *acm = func_to_acm(f);
++ int status;
++ struct usb_ep *ep;
++
++ /* allocate instance-specific interface IDs, and patch descriptors */
++ status = usb_interface_id(c, f);
++ if (status < 0)
++ goto fail;
++ acm->ctrl_id = status;
++
++ acm_control_interface_desc.bInterfaceNumber = status;
++ acm_union_desc .bMasterInterface0 = status;
++
++ status = usb_interface_id(c, f);
++ if (status < 0)
++ goto fail;
++ acm->data_id = status;
++
++ acm_data_interface_desc.bInterfaceNumber = status;
++ acm_union_desc.bSlaveInterface0 = status;
++ acm_call_mgmt_descriptor.bDataInterface = status;
++
++ status = -ENODEV;
++
++ /* allocate instance-specific endpoints */
++ ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_in_desc);
++ if (!ep)
++ goto fail;
++ acm->port.in = ep;
++ ep->driver_data = cdev; /* claim */
++
++ ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_out_desc);
++ if (!ep)
++ goto fail;
++ acm->port.out = ep;
++ ep->driver_data = cdev; /* claim */
++
++ ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_notify_desc);
++ if (!ep)
++ goto fail;
++ acm->notify = ep;
++ ep->driver_data = cdev; /* claim */
++
++ /* allocate notification */
++ acm->notify_req = gs_alloc_req(ep,
++ sizeof(struct usb_cdc_notification) + 2,
++ GFP_KERNEL);
++ if (!acm->notify_req)
++ goto fail;
++
++ acm->notify_req->complete = acm_cdc_notify_complete;
++ acm->notify_req->context = acm;
++
++ /* copy descriptors, and track endpoint copies */
++ f->descriptors = usb_copy_descriptors(acm_fs_function);
++ if (!f->descriptors)
++ goto fail;
++
++ acm->fs.in = usb_find_endpoint(acm_fs_function,
++ f->descriptors, &acm_fs_in_desc);
++ acm->fs.out = usb_find_endpoint(acm_fs_function,
++ f->descriptors, &acm_fs_out_desc);
++ acm->fs.notify = usb_find_endpoint(acm_fs_function,
++ f->descriptors, &acm_fs_notify_desc);
++
++ /* support all relevant hardware speeds... we expect that when
++ * hardware is dual speed, all bulk-capable endpoints work at
++ * both speeds
++ */
++ if (gadget_is_dualspeed(c->cdev->gadget)) {
++ acm_hs_in_desc.bEndpointAddress =
++ acm_fs_in_desc.bEndpointAddress;
++ acm_hs_out_desc.bEndpointAddress =
++ acm_fs_out_desc.bEndpointAddress;
++ acm_hs_notify_desc.bEndpointAddress =
++ acm_fs_notify_desc.bEndpointAddress;
++
++ /* copy descriptors, and track endpoint copies */
++ f->hs_descriptors = usb_copy_descriptors(acm_hs_function);
++
++ acm->hs.in = usb_find_endpoint(acm_hs_function,
++ f->hs_descriptors, &acm_hs_in_desc);
++ acm->hs.out = usb_find_endpoint(acm_hs_function,
++ f->hs_descriptors, &acm_hs_out_desc);
++ acm->hs.notify = usb_find_endpoint(acm_hs_function,
++ f->hs_descriptors, &acm_hs_notify_desc);
++ }
++
++ DBG(cdev, "acm ttyGS%d: %s speed IN/%s OUT/%s NOTIFY/%s\n",
++ acm->port_num,
++ gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
++ acm->port.in->name, acm->port.out->name,
++ acm->notify->name);
++ return 0;
++
++fail:
++ if (acm->notify_req)
++ gs_free_req(acm->notify, acm->notify_req);
++
++ /* we might as well release our claims on endpoints */
++ if (acm->notify)
++ acm->notify->driver_data = NULL;
++ if (acm->port.out)
++ acm->port.out->driver_data = NULL;
++ if (acm->port.in)
++ acm->port.in->driver_data = NULL;
++
++ ERROR(cdev, "%s/%p: can't bind, err %d\n", f->name, f, status);
++
++ return status;
++}
++
++static void
++acm_unbind(struct usb_configuration *c, struct usb_function *f)
++{
++ struct f_acm *acm = func_to_acm(f);
++
++ if (gadget_is_dualspeed(c->cdev->gadget))
++ usb_free_descriptors(f->hs_descriptors);
++ usb_free_descriptors(f->descriptors);
++ gs_free_req(acm->notify, acm->notify_req);
++ kfree(acm);
++}
++
++/* Some controllers can't support CDC ACM ... */
++static inline bool can_support_cdc(struct usb_configuration *c)
++{
++ /* SH3 doesn't support multiple interfaces */
++ if (gadget_is_sh(c->cdev->gadget))
++ return false;
++
++ /* sa1100 doesn't have a third interrupt endpoint */
++ if (gadget_is_sa1100(c->cdev->gadget))
++ return false;
++
++ /* everything else is *probably* fine ... */
++ return true;
++}
++
++/**
++ * acm_bind_config - add a CDC ACM function to a configuration
++ * @c: the configuration to support the CDC ACM instance
++ * @port_num: /dev/ttyGS* port this interface will use
++ * Context: single threaded during gadget setup
++ *
++ * Returns zero on success, else negative errno.
++ *
++ * Caller must have called @gserial_setup() with enough ports to
++ * handle all the ones it binds. Caller is also responsible
++ * for calling @gserial_cleanup() before module unload.
++ */
++int __init acm_bind_config(struct usb_configuration *c, u8 port_num)
++{
++ struct f_acm *acm;
++ int status;
++
++ if (!can_support_cdc(c))
++ return -EINVAL;
++
++ /* REVISIT might want instance-specific strings to help
++ * distinguish instances ...
++ */
++
++ /* maybe allocate device-global string IDs, and patch descriptors */
++ if (acm_string_defs[ACM_CTRL_IDX].id == 0) {
++ status = usb_string_id(c->cdev);
++ if (status < 0)
++ return status;
++ acm_string_defs[ACM_CTRL_IDX].id = status;
++
++ acm_control_interface_desc.iInterface = status;
++
++ status = usb_string_id(c->cdev);
++ if (status < 0)
++ return status;
++ acm_string_defs[ACM_DATA_IDX].id = status;
++
++ acm_data_interface_desc.iInterface = status;
++ }
++
++ /* allocate and initialize one new instance */
++ acm = kzalloc(sizeof *acm, GFP_KERNEL);
++ if (!acm)
++ return -ENOMEM;
++
++ spin_lock_init(&acm->lock);
++
++ acm->port_num = port_num;
++
++ acm->port.connect = acm_connect;
++ acm->port.disconnect = acm_disconnect;
++ acm->port.send_break = acm_send_break;
++
++ acm->port.func.name = "acm";
++ acm->port.func.strings = acm_strings;
++ /* descriptors are per-instance copies */
++ acm->port.func.bind = acm_bind;
++ acm->port.func.unbind = acm_unbind;
++ acm->port.func.set_alt = acm_set_alt;
++ acm->port.func.setup = acm_setup;
++ acm->port.func.disable = acm_disable;
++
++ status = usb_add_function(c, &acm->port.func);
++ if (status)
++ kfree(acm);
++ return status;
++}
+diff --git a/drivers/usb/gadget/f_ecm.c b/drivers/usb/gadget/f_ecm.c
+new file mode 100644
+index 0000000..a2b5c09
+--- /dev/null
++++ b/drivers/usb/gadget/f_ecm.c
+@@ -0,0 +1,831 @@
++/*
++ * f_ecm.c -- USB CDC Ethernet (ECM) link function driver
++ *
++ * Copyright (C) 2003-2005,2008 David Brownell
++ * Copyright (C) 2008 Nokia Corporation
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++/* #define VERBOSE_DEBUG */
++
++#include <linux/kernel.h>
++#include <linux/device.h>
++#include <linux/etherdevice.h>
++
++#include "u_ether.h"
++
++
++/*
++ * This function is a "CDC Ethernet Networking Control Model" (CDC ECM)
++ * Ethernet link. The data transfer model is simple (packets sent and
++ * received over bulk endpoints using normal short packet termination),
++ * and the control model exposes various data and optional notifications.
++ *
++ * ECM is well standardized and (except for Microsoft) supported by most
++ * operating systems with USB host support. It's the preferred interop
++ * solution for Ethernet over USB, at least for firmware based solutions.
++ * (Hardware solutions tend to be more minimalist.) A newer and simpler
++ * "Ethernet Emulation Model" (CDC EEM) hasn't yet caught on.
++ *
++ * Note that ECM requires the use of "alternate settings" for its data
++ * interface. This means that the set_alt() method has real work to do,
++ * and also means that a get_alt() method is required.
++ */
++
++struct ecm_ep_descs {
++ struct usb_endpoint_descriptor *in;
++ struct usb_endpoint_descriptor *out;
++ struct usb_endpoint_descriptor *notify;
++};
++
++enum ecm_notify_state {
++ ECM_NOTIFY_NONE, /* don't notify */
++ ECM_NOTIFY_CONNECT, /* issue CONNECT next */
++ ECM_NOTIFY_SPEED, /* issue SPEED_CHANGE next */
++};
++
++struct f_ecm {
++ struct gether port;
++ u8 ctrl_id, data_id;
++
++ char ethaddr[14];
++
++ struct ecm_ep_descs fs;
++ struct ecm_ep_descs hs;
++
++ struct usb_ep *notify;
++ struct usb_endpoint_descriptor *notify_desc;
++ struct usb_request *notify_req;
++ u8 notify_state;
++ bool is_open;
++
++ /* FIXME is_open needs some irq-ish locking
++ * ... possibly the same as port.ioport
++ */
++};
++
++static inline struct f_ecm *func_to_ecm(struct usb_function *f)
++{
++ return container_of(f, struct f_ecm, port.func);
++}
++
++/* peak (theoretical) bulk transfer rate in bits-per-second */
++static inline unsigned bitrate(struct usb_gadget *g)
++{
++ if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
++ return 13 * 512 * 8 * 1000 * 8;
++ else
++ return 19 * 64 * 1 * 1000 * 8;
++}
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * Include the status endpoint if we can, even though it's optional.
++ *
++ * Use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
++ * packet, to simplify cancellation; and a big transfer interval, to
++ * waste less bandwidth.
++ *
++ * Some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even
++ * if they ignore the connect/disconnect notifications that real aether
++ * can provide. More advanced cdc configurations might want to support
++ * encapsulated commands (vendor-specific, using control-OUT).
++ */
++
++#define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */
++#define STATUS_BYTECOUNT 16 /* 8 byte header + data */
++
++
++/* interface descriptor: */
++
++static struct usb_interface_descriptor ecm_control_intf __initdata = {
++ .bLength = sizeof ecm_control_intf,
++ .bDescriptorType = USB_DT_INTERFACE,
++
++ /* .bInterfaceNumber = DYNAMIC */
++ /* status endpoint is optional; this could be patched later */
++ .bNumEndpoints = 1,
++ .bInterfaceClass = USB_CLASS_COMM,
++ .bInterfaceSubClass = USB_CDC_SUBCLASS_ETHERNET,
++ .bInterfaceProtocol = USB_CDC_PROTO_NONE,
++ /* .iInterface = DYNAMIC */
++};
++
++static struct usb_cdc_header_desc header_desc __initdata = {
++ .bLength = sizeof header_desc,
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_HEADER_TYPE,
++
++ .bcdCDC = __constant_cpu_to_le16(0x0110),
++};
++
++static struct usb_cdc_union_desc ecm_union_desc __initdata = {
++ .bLength = sizeof(ecm_union_desc),
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_UNION_TYPE,
++ /* .bMasterInterface0 = DYNAMIC */
++ /* .bSlaveInterface0 = DYNAMIC */
++};
++
++static struct usb_cdc_ether_desc ether_desc __initdata = {
++ .bLength = sizeof ether_desc,
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_ETHERNET_TYPE,
++
++ /* this descriptor actually adds value, surprise! */
++ /* .iMACAddress = DYNAMIC */
++ .bmEthernetStatistics = __constant_cpu_to_le32(0), /* no statistics */
++ .wMaxSegmentSize = __constant_cpu_to_le16(ETH_FRAME_LEN),
++ .wNumberMCFilters = __constant_cpu_to_le16(0),
++ .bNumberPowerFilters = 0,
++};
++
++/* the default data interface has no endpoints ... */
++
++static struct usb_interface_descriptor ecm_data_nop_intf __initdata = {
++ .bLength = sizeof ecm_data_nop_intf,
++ .bDescriptorType = USB_DT_INTERFACE,
++
++ .bInterfaceNumber = 1,
++ .bAlternateSetting = 0,
++ .bNumEndpoints = 0,
++ .bInterfaceClass = USB_CLASS_CDC_DATA,
++ .bInterfaceSubClass = 0,
++ .bInterfaceProtocol = 0,
++ /* .iInterface = DYNAMIC */
++};
++
++/* ... but the "real" data interface has two bulk endpoints */
++
++static struct usb_interface_descriptor ecm_data_intf __initdata = {
++ .bLength = sizeof ecm_data_intf,
++ .bDescriptorType = USB_DT_INTERFACE,
++
++ .bInterfaceNumber = 1,
++ .bAlternateSetting = 1,
++ .bNumEndpoints = 2,
++ .bInterfaceClass = USB_CLASS_CDC_DATA,
++ .bInterfaceSubClass = 0,
++ .bInterfaceProtocol = 0,
++ /* .iInterface = DYNAMIC */
++};
++
++/* full speed support: */
++
++static struct usb_endpoint_descriptor fs_notify_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_INT,
++ .wMaxPacketSize = __constant_cpu_to_le16(STATUS_BYTECOUNT),
++ .bInterval = 1 << LOG2_STATUS_INTERVAL_MSEC,
++};
++
++static struct usb_endpoint_descriptor fs_in_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_endpoint_descriptor fs_out_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_OUT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_descriptor_header *eth_fs_function[] __initdata = {
++ /* CDC ECM control descriptors */
++ (struct usb_descriptor_header *) &ecm_control_intf,
++ (struct usb_descriptor_header *) &header_desc,
++ (struct usb_descriptor_header *) &ecm_union_desc,
++ (struct usb_descriptor_header *) ðer_desc,
++ /* NOTE: status endpoint might need to be removed */
++ (struct usb_descriptor_header *) &fs_notify_desc,
++ /* data interface, altsettings 0 and 1 */
++ (struct usb_descriptor_header *) &ecm_data_nop_intf,
++ (struct usb_descriptor_header *) &ecm_data_intf,
++ (struct usb_descriptor_header *) &fs_in_desc,
++ (struct usb_descriptor_header *) &fs_out_desc,
++ NULL,
++};
++
++/* high speed support: */
++
++static struct usb_endpoint_descriptor hs_notify_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_INT,
++ .wMaxPacketSize = __constant_cpu_to_le16(STATUS_BYTECOUNT),
++ .bInterval = LOG2_STATUS_INTERVAL_MSEC + 4,
++};
++static struct usb_endpoint_descriptor hs_in_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_endpoint_descriptor hs_out_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_OUT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_descriptor_header *eth_hs_function[] __initdata = {
++ /* CDC ECM control descriptors */
++ (struct usb_descriptor_header *) &ecm_control_intf,
++ (struct usb_descriptor_header *) &header_desc,
++ (struct usb_descriptor_header *) &ecm_union_desc,
++ (struct usb_descriptor_header *) ðer_desc,
++ /* NOTE: status endpoint might need to be removed */
++ (struct usb_descriptor_header *) &hs_notify_desc,
++ /* data interface, altsettings 0 and 1 */
++ (struct usb_descriptor_header *) &ecm_data_nop_intf,
++ (struct usb_descriptor_header *) &ecm_data_intf,
++ (struct usb_descriptor_header *) &hs_in_desc,
++ (struct usb_descriptor_header *) &hs_out_desc,
++ NULL,
++};
++
++/* string descriptors: */
++
++static struct usb_string ecm_string_defs[] = {
++ [0].s = "CDC Ethernet Control Model (ECM)",
++ [1].s = NULL /* DYNAMIC */,
++ [2].s = "CDC Ethernet Data",
++ { } /* end of list */
++};
++
++static struct usb_gadget_strings ecm_string_table = {
++ .language = 0x0409, /* en-us */
++ .strings = ecm_string_defs,
++};
++
++static struct usb_gadget_strings *ecm_strings[] = {
++ &ecm_string_table,
++ NULL,
++};
++
++/*-------------------------------------------------------------------------*/
++
++static void ecm_do_notify(struct f_ecm *ecm)
++{
++ struct usb_request *req = ecm->notify_req;
++ struct usb_cdc_notification *event;
++ struct usb_composite_dev *cdev = ecm->port.func.config->cdev;
++ __le32 *data;
++ int status;
++
++ /* notification already in flight? */
++ if (!req)
++ return;
++
++ event = req->buf;
++ switch (ecm->notify_state) {
++ case ECM_NOTIFY_NONE:
++ return;
++
++ case ECM_NOTIFY_CONNECT:
++ event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
++ if (ecm->is_open)
++ event->wValue = cpu_to_le16(1);
++ else
++ event->wValue = cpu_to_le16(0);
++ event->wLength = 0;
++ req->length = sizeof *event;
++
++ DBG(cdev, "notify connect %s\n",
++ ecm->is_open ? "true" : "false");
++ ecm->notify_state = ECM_NOTIFY_SPEED;
++ break;
++
++ case ECM_NOTIFY_SPEED:
++ event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
++ event->wValue = cpu_to_le16(0);
++ event->wLength = cpu_to_le16(8);
++ req->length = STATUS_BYTECOUNT;
++
++ /* SPEED_CHANGE data is up/down speeds in bits/sec */
++ data = req->buf + sizeof *event;
++ data[0] = cpu_to_le32(bitrate(cdev->gadget));
++ data[1] = data[0];
++
++ DBG(cdev, "notify speed %d\n", bitrate(cdev->gadget));
++ ecm->notify_state = ECM_NOTIFY_NONE;
++ break;
++ }
++ event->bmRequestType = 0xA1;
++ event->wIndex = cpu_to_le16(ecm->ctrl_id);
++
++ ecm->notify_req = NULL;
++ status = usb_ep_queue(ecm->notify, req, GFP_ATOMIC);
++ if (status < 0) {
++ ecm->notify_req = req;
++ DBG(cdev, "notify --> %d\n", status);
++ }
++}
++
++static void ecm_notify(struct f_ecm *ecm)
++{
++ /* NOTE on most versions of Linux, host side cdc-ethernet
++ * won't listen for notifications until its netdevice opens.
++ * The first notification then sits in the FIFO for a long
++ * time, and the second one is queued.
++ */
++ ecm->notify_state = ECM_NOTIFY_CONNECT;
++ ecm_do_notify(ecm);
++}
++
++static void ecm_notify_complete(struct usb_ep *ep, struct usb_request *req)
++{
++ struct f_ecm *ecm = req->context;
++ struct usb_composite_dev *cdev = ecm->port.func.config->cdev;
++ struct usb_cdc_notification *event = req->buf;
++
++ switch (req->status) {
++ case 0:
++ /* no fault */
++ break;
++ case -ECONNRESET:
++ case -ESHUTDOWN:
++ ecm->notify_state = ECM_NOTIFY_NONE;
++ break;
++ default:
++ DBG(cdev, "event %02x --> %d\n",
++ event->bNotificationType, req->status);
++ break;
++ }
++ ecm->notify_req = req;
++ ecm_do_notify(ecm);
++}
++
++static int ecm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
++{
++ struct f_ecm *ecm = func_to_ecm(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++ struct usb_request *req = cdev->req;
++ int value = -EOPNOTSUPP;
++ u16 w_index = le16_to_cpu(ctrl->wIndex);
++ u16 w_value = le16_to_cpu(ctrl->wValue);
++ u16 w_length = le16_to_cpu(ctrl->wLength);
++
++ /* composite driver infrastructure handles everything except
++ * CDC class messages; interface activation uses set_alt().
++ */
++ switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
++ case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
++ | USB_CDC_SET_ETHERNET_PACKET_FILTER:
++ /* see 6.2.30: no data, wIndex = interface,
++ * wValue = packet filter bitmap
++ */
++ if (w_length != 0 || w_index != ecm->ctrl_id)
++ goto invalid;
++ DBG(cdev, "packet filter %02x\n", w_value);
++ /* REVISIT locking of cdc_filter. This assumes the UDC
++ * driver won't have a concurrent packet TX irq running on
++ * another CPU; or that if it does, this write is atomic...
++ */
++ ecm->port.cdc_filter = w_value;
++ value = 0;
++ break;
++
++ /* and optionally:
++ * case USB_CDC_SEND_ENCAPSULATED_COMMAND:
++ * case USB_CDC_GET_ENCAPSULATED_RESPONSE:
++ * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
++ * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
++ * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
++ * case USB_CDC_GET_ETHERNET_STATISTIC:
++ */
++
++ default:
++invalid:
++ DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
++ ctrl->bRequestType, ctrl->bRequest,
++ w_value, w_index, w_length);
++ }
++
++ /* respond with data transfer or status phase? */
++ if (value >= 0) {
++ DBG(cdev, "ecm req%02x.%02x v%04x i%04x l%d\n",
++ ctrl->bRequestType, ctrl->bRequest,
++ w_value, w_index, w_length);
++ req->zero = 0;
++ req->length = value;
++ value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
++ if (value < 0)
++ ERROR(cdev, "ecm req %02x.%02x response err %d\n",
++ ctrl->bRequestType, ctrl->bRequest,
++ value);
++ }
++
++ /* device either stalls (value < 0) or reports success */
++ return value;
++}
++
++
++static int ecm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
++{
++ struct f_ecm *ecm = func_to_ecm(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ /* Control interface has only altsetting 0 */
++ if (intf == ecm->ctrl_id) {
++ if (alt != 0)
++ goto fail;
++
++ if (ecm->notify->driver_data) {
++ VDBG(cdev, "reset ecm control %d\n", intf);
++ usb_ep_disable(ecm->notify);
++ } else {
++ VDBG(cdev, "init ecm ctrl %d\n", intf);
++ ecm->notify_desc = ep_choose(cdev->gadget,
++ ecm->hs.notify,
++ ecm->fs.notify);
++ }
++ usb_ep_enable(ecm->notify, ecm->notify_desc);
++ ecm->notify->driver_data = ecm;
++
++ /* Data interface has two altsettings, 0 and 1 */
++ } else if (intf == ecm->data_id) {
++ if (alt > 1)
++ goto fail;
++
++ if (ecm->port.in_ep->driver_data) {
++ DBG(cdev, "reset ecm\n");
++ gether_disconnect(&ecm->port);
++ }
++
++ if (!ecm->port.in) {
++ DBG(cdev, "init ecm\n");
++ ecm->port.in = ep_choose(cdev->gadget,
++ ecm->hs.in, ecm->fs.in);
++ ecm->port.out = ep_choose(cdev->gadget,
++ ecm->hs.out, ecm->fs.out);
++ }
++
++ /* CDC Ethernet only sends data in non-default altsettings.
++ * Changing altsettings resets filters, statistics, etc.
++ */
++ if (alt == 1) {
++ struct net_device *net;
++
++ /* Enable zlps by default for ECM conformance;
++ * override for musb_hdrc (avoids txdma ovhead)
++ * and sa1100 (can't).
++ */
++ ecm->port.is_zlp_ok = !(
++ gadget_is_sa1100(cdev->gadget)
++ || gadget_is_musbhdrc(cdev->gadget)
++ );
++ ecm->port.cdc_filter = DEFAULT_FILTER;
++ DBG(cdev, "activate ecm\n");
++ net = gether_connect(&ecm->port);
++ if (IS_ERR(net))
++ return PTR_ERR(net);
++ }
++
++ /* NOTE this can be a minor disagreement with the ECM spec,
++ * which says speed notifications will "always" follow
++ * connection notifications. But we allow one connect to
++ * follow another (if the first is in flight), and instead
++ * just guarantee that a speed notification is always sent.
++ */
++ ecm_notify(ecm);
++ } else
++ goto fail;
++
++ return 0;
++fail:
++ return -EINVAL;
++}
++
++/* Because the data interface supports multiple altsettings,
++ * this ECM function *MUST* implement a get_alt() method.
++ */
++static int ecm_get_alt(struct usb_function *f, unsigned intf)
++{
++ struct f_ecm *ecm = func_to_ecm(f);
++
++ if (intf == ecm->ctrl_id)
++ return 0;
++ return ecm->port.in_ep->driver_data ? 1 : 0;
++}
++
++static void ecm_disable(struct usb_function *f)
++{
++ struct f_ecm *ecm = func_to_ecm(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ DBG(cdev, "ecm deactivated\n");
++
++ if (ecm->port.in_ep->driver_data)
++ gether_disconnect(&ecm->port);
++
++ if (ecm->notify->driver_data) {
++ usb_ep_disable(ecm->notify);
++ ecm->notify->driver_data = NULL;
++ ecm->notify_desc = NULL;
++ }
++}
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * Callbacks let us notify the host about connect/disconnect when the
++ * net device is opened or closed.
++ *
++ * For testing, note that link states on this side include both opened
++ * and closed variants of:
++ *
++ * - disconnected/unconfigured
++ * - configured but inactive (data alt 0)
++ * - configured and active (data alt 1)
++ *
++ * Each needs to be tested with unplug, rmmod, SET_CONFIGURATION, and
++ * SET_INTERFACE (altsetting). Remember also that "configured" doesn't
++ * imply the host is actually polling the notification endpoint, and
++ * likewise that "active" doesn't imply it's actually using the data
++ * endpoints for traffic.
++ */
++
++static void ecm_open(struct gether *geth)
++{
++ struct f_ecm *ecm = func_to_ecm(&geth->func);
++
++ DBG(ecm->port.func.config->cdev, "%s\n", __func__);
++
++ ecm->is_open = true;
++ ecm_notify(ecm);
++}
++
++static void ecm_close(struct gether *geth)
++{
++ struct f_ecm *ecm = func_to_ecm(&geth->func);
++
++ DBG(ecm->port.func.config->cdev, "%s\n", __func__);
++
++ ecm->is_open = false;
++ ecm_notify(ecm);
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* ethernet function driver setup/binding */
++
++static int __init
++ecm_bind(struct usb_configuration *c, struct usb_function *f)
++{
++ struct usb_composite_dev *cdev = c->cdev;
++ struct f_ecm *ecm = func_to_ecm(f);
++ int status;
++ struct usb_ep *ep;
++
++ /* allocate instance-specific interface IDs */
++ status = usb_interface_id(c, f);
++ if (status < 0)
++ goto fail;
++ ecm->ctrl_id = status;
++
++ ecm_control_intf.bInterfaceNumber = status;
++ ecm_union_desc.bMasterInterface0 = status;
++
++ status = usb_interface_id(c, f);
++ if (status < 0)
++ goto fail;
++ ecm->data_id = status;
++
++ ecm_data_nop_intf.bInterfaceNumber = status;
++ ecm_data_intf.bInterfaceNumber = status;
++ ecm_union_desc.bSlaveInterface0 = status;
++
++ status = -ENODEV;
++
++ /* allocate instance-specific endpoints */
++ ep = usb_ep_autoconfig(cdev->gadget, &fs_in_desc);
++ if (!ep)
++ goto fail;
++ ecm->port.in_ep = ep;
++ ep->driver_data = cdev; /* claim */
++
++ ep = usb_ep_autoconfig(cdev->gadget, &fs_out_desc);
++ if (!ep)
++ goto fail;
++ ecm->port.out_ep = ep;
++ ep->driver_data = cdev; /* claim */
++
++ /* NOTE: a status/notification endpoint is *OPTIONAL* but we
++ * don't treat it that way. It's simpler, and some newer CDC
++ * profiles (wireless handsets) no longer treat it as optional.
++ */
++ ep = usb_ep_autoconfig(cdev->gadget, &fs_notify_desc);
++ if (!ep)
++ goto fail;
++ ecm->notify = ep;
++ ep->driver_data = cdev; /* claim */
++
++ status = -ENOMEM;
++
++ /* allocate notification request and buffer */
++ ecm->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
++ if (!ecm->notify_req)
++ goto fail;
++ ecm->notify_req->buf = kmalloc(STATUS_BYTECOUNT, GFP_KERNEL);
++ if (!ecm->notify_req->buf)
++ goto fail;
++ ecm->notify_req->context = ecm;
++ ecm->notify_req->complete = ecm_notify_complete;
++
++ /* copy descriptors, and track endpoint copies */
++ f->descriptors = usb_copy_descriptors(eth_fs_function);
++ if (!f->descriptors)
++ goto fail;
++
++ ecm->fs.in = usb_find_endpoint(eth_fs_function,
++ f->descriptors, &fs_in_desc);
++ ecm->fs.out = usb_find_endpoint(eth_fs_function,
++ f->descriptors, &fs_out_desc);
++ ecm->fs.notify = usb_find_endpoint(eth_fs_function,
++ f->descriptors, &fs_notify_desc);
++
++ /* support all relevant hardware speeds... we expect that when
++ * hardware is dual speed, all bulk-capable endpoints work at
++ * both speeds
++ */
++ if (gadget_is_dualspeed(c->cdev->gadget)) {
++ hs_in_desc.bEndpointAddress =
++ fs_in_desc.bEndpointAddress;
++ hs_out_desc.bEndpointAddress =
++ fs_out_desc.bEndpointAddress;
++ hs_notify_desc.bEndpointAddress =
++ fs_notify_desc.bEndpointAddress;
++
++ /* copy descriptors, and track endpoint copies */
++ f->hs_descriptors = usb_copy_descriptors(eth_hs_function);
++ if (!f->hs_descriptors)
++ goto fail;
++
++ ecm->hs.in = usb_find_endpoint(eth_hs_function,
++ f->hs_descriptors, &hs_in_desc);
++ ecm->hs.out = usb_find_endpoint(eth_hs_function,
++ f->hs_descriptors, &hs_out_desc);
++ ecm->hs.notify = usb_find_endpoint(eth_hs_function,
++ f->hs_descriptors, &hs_notify_desc);
++ }
++
++ /* NOTE: all that is done without knowing or caring about
++ * the network link ... which is unavailable to this code
++ * until we're activated via set_alt().
++ */
++
++ ecm->port.open = ecm_open;
++ ecm->port.close = ecm_close;
++
++ DBG(cdev, "CDC Ethernet: %s speed IN/%s OUT/%s NOTIFY/%s\n",
++ gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
++ ecm->port.in_ep->name, ecm->port.out_ep->name,
++ ecm->notify->name);
++ return 0;
++
++fail:
++ if (f->descriptors)
++ usb_free_descriptors(f->descriptors);
++
++ if (ecm->notify_req) {
++ kfree(ecm->notify_req->buf);
++ usb_ep_free_request(ecm->notify, ecm->notify_req);
++ }
++
++ /* we might as well release our claims on endpoints */
++ if (ecm->notify)
++ ecm->notify->driver_data = NULL;
++ if (ecm->port.out)
++ ecm->port.out_ep->driver_data = NULL;
++ if (ecm->port.in)
++ ecm->port.in_ep->driver_data = NULL;
++
++ ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
++
++ return status;
++}
++
++static void
++ecm_unbind(struct usb_configuration *c, struct usb_function *f)
++{
++ struct f_ecm *ecm = func_to_ecm(f);
++
++ DBG(c->cdev, "ecm unbind\n");
++
++ if (gadget_is_dualspeed(c->cdev->gadget))
++ usb_free_descriptors(f->hs_descriptors);
++ usb_free_descriptors(f->descriptors);
++
++ kfree(ecm->notify_req->buf);
++ usb_ep_free_request(ecm->notify, ecm->notify_req);
++
++ ecm_string_defs[1].s = NULL;
++ kfree(ecm);
++}
++
++/**
++ * ecm_bind_config - add CDC Ethernet network link to a configuration
++ * @c: the configuration to support the network link
++ * @ethaddr: a buffer in which the ethernet address of the host side
++ * side of the link was recorded
++ * Context: single threaded during gadget setup
++ *
++ * Returns zero on success, else negative errno.
++ *
++ * Caller must have called @gether_setup(). Caller is also responsible
++ * for calling @gether_cleanup() before module unload.
++ */
++int __init ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
++{
++ struct f_ecm *ecm;
++ int status;
++
++ if (!can_support_ecm(c->cdev->gadget) || !ethaddr)
++ return -EINVAL;
++
++ /* maybe allocate device-global string IDs */
++ if (ecm_string_defs[0].id == 0) {
++
++ /* control interface label */
++ status = usb_string_id(c->cdev);
++ if (status < 0)
++ return status;
++ ecm_string_defs[0].id = status;
++ ecm_control_intf.iInterface = status;
++
++ /* data interface label */
++ status = usb_string_id(c->cdev);
++ if (status < 0)
++ return status;
++ ecm_string_defs[2].id = status;
++ ecm_data_intf.iInterface = status;
++
++ /* MAC address */
++ status = usb_string_id(c->cdev);
++ if (status < 0)
++ return status;
++ ecm_string_defs[1].id = status;
++ ether_desc.iMACAddress = status;
++ }
++
++ /* allocate and initialize one new instance */
++ ecm = kzalloc(sizeof *ecm, GFP_KERNEL);
++ if (!ecm)
++ return -ENOMEM;
++
++ /* export host's Ethernet address in CDC format */
++ snprintf(ecm->ethaddr, sizeof ecm->ethaddr,
++ "%02X%02X%02X%02X%02X%02X",
++ ethaddr[0], ethaddr[1], ethaddr[2],
++ ethaddr[3], ethaddr[4], ethaddr[5]);
++ ecm_string_defs[1].s = ecm->ethaddr;
++
++ ecm->port.cdc_filter = DEFAULT_FILTER;
++
++ ecm->port.func.name = "cdc_ethernet";
++ ecm->port.func.strings = ecm_strings;
++ /* descriptors are per-instance copies */
++ ecm->port.func.bind = ecm_bind;
++ ecm->port.func.unbind = ecm_unbind;
++ ecm->port.func.set_alt = ecm_set_alt;
++ ecm->port.func.get_alt = ecm_get_alt;
++ ecm->port.func.setup = ecm_setup;
++ ecm->port.func.disable = ecm_disable;
++
++ status = usb_add_function(c, &ecm->port.func);
++ if (status) {
++ ecm_string_defs[1].s = NULL;
++ kfree(ecm);
++ }
++ return status;
++}
+diff --git a/drivers/usb/gadget/f_loopback.c b/drivers/usb/gadget/f_loopback.c
+new file mode 100644
+index 0000000..eda4cde
+--- /dev/null
++++ b/drivers/usb/gadget/f_loopback.c
+@@ -0,0 +1,381 @@
++/*
++ * f_loopback.c - USB peripheral loopback configuration driver
++ *
++ * Copyright (C) 2003-2008 David Brownell
++ * Copyright (C) 2008 by Nokia Corporation
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++/* #define VERBOSE_DEBUG */
++
++#include <linux/kernel.h>
++#include <linux/utsname.h>
++#include <linux/device.h>
++
++#include "g_zero.h"
++#include "gadget_chips.h"
++
++
++/*
++ * LOOPBACK FUNCTION ... a testing vehicle for USB peripherals,
++ *
++ * This takes messages of various sizes written OUT to a device, and loops
++ * them back so they can be read IN from it. It has been used by certain
++ * test applications. It supports limited testing of data queueing logic.
++ *
++ *
++ * This is currently packaged as a configuration driver, which can't be
++ * combined with other functions to make composite devices. However, it
++ * can be combined with other independent configurations.
++ */
++struct f_loopback {
++ struct usb_function function;
++
++ struct usb_ep *in_ep;
++ struct usb_ep *out_ep;
++};
++
++static inline struct f_loopback *func_to_loop(struct usb_function *f)
++{
++ return container_of(f, struct f_loopback, function);
++}
++
++static unsigned qlen = 32;
++module_param(qlen, uint, 0);
++MODULE_PARM_DESC(qlenn, "depth of loopback queue");
++
++/*-------------------------------------------------------------------------*/
++
++static struct usb_interface_descriptor loopback_intf = {
++ .bLength = sizeof loopback_intf,
++ .bDescriptorType = USB_DT_INTERFACE,
++
++ .bNumEndpoints = 2,
++ .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
++ /* .iInterface = DYNAMIC */
++};
++
++/* full speed support: */
++
++static struct usb_endpoint_descriptor fs_source_desc = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_endpoint_descriptor fs_sink_desc = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_OUT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_descriptor_header *fs_loopback_descs[] = {
++ (struct usb_descriptor_header *) &loopback_intf,
++ (struct usb_descriptor_header *) &fs_sink_desc,
++ (struct usb_descriptor_header *) &fs_source_desc,
++ NULL,
++};
++
++/* high speed support: */
++
++static struct usb_endpoint_descriptor hs_source_desc = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_endpoint_descriptor hs_sink_desc = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_descriptor_header *hs_loopback_descs[] = {
++ (struct usb_descriptor_header *) &loopback_intf,
++ (struct usb_descriptor_header *) &hs_source_desc,
++ (struct usb_descriptor_header *) &hs_sink_desc,
++ NULL,
++};
++
++/* function-specific strings: */
++
++static struct usb_string strings_loopback[] = {
++ [0].s = "loop input to output",
++ { } /* end of list */
++};
++
++static struct usb_gadget_strings stringtab_loop = {
++ .language = 0x0409, /* en-us */
++ .strings = strings_loopback,
++};
++
++static struct usb_gadget_strings *loopback_strings[] = {
++ &stringtab_loop,
++ NULL,
++};
++
++/*-------------------------------------------------------------------------*/
++
++static int __init
++loopback_bind(struct usb_configuration *c, struct usb_function *f)
++{
++ struct usb_composite_dev *cdev = c->cdev;
++ struct f_loopback *loop = func_to_loop(f);
++ int id;
++
++ /* allocate interface ID(s) */
++ id = usb_interface_id(c, f);
++ if (id < 0)
++ return id;
++ loopback_intf.bInterfaceNumber = id;
++
++ /* allocate endpoints */
++
++ loop->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc);
++ if (!loop->in_ep) {
++autoconf_fail:
++ ERROR(cdev, "%s: can't autoconfigure on %s\n",
++ f->name, cdev->gadget->name);
++ return -ENODEV;
++ }
++ loop->in_ep->driver_data = cdev; /* claim */
++
++ loop->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_sink_desc);
++ if (!loop->out_ep)
++ goto autoconf_fail;
++ loop->out_ep->driver_data = cdev; /* claim */
++
++ /* support high speed hardware */
++ if (gadget_is_dualspeed(c->cdev->gadget)) {
++ hs_source_desc.bEndpointAddress =
++ fs_source_desc.bEndpointAddress;
++ hs_sink_desc.bEndpointAddress =
++ fs_sink_desc.bEndpointAddress;
++ f->hs_descriptors = hs_loopback_descs;
++ }
++
++ DBG(cdev, "%s speed %s: IN/%s, OUT/%s\n",
++ gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
++ f->name, loop->in_ep->name, loop->out_ep->name);
++ return 0;
++}
++
++static void
++loopback_unbind(struct usb_configuration *c, struct usb_function *f)
++{
++ kfree(func_to_loop(f));
++}
++
++static void loopback_complete(struct usb_ep *ep, struct usb_request *req)
++{
++ struct f_loopback *loop = ep->driver_data;
++ struct usb_composite_dev *cdev = loop->function.config->cdev;
++ int status = req->status;
++
++ switch (status) {
++
++ case 0: /* normal completion? */
++ if (ep == loop->out_ep) {
++ /* loop this OUT packet back IN to the host */
++ req->zero = (req->actual < req->length);
++ req->length = req->actual;
++ status = usb_ep_queue(loop->in_ep, req, GFP_ATOMIC);
++ if (status == 0)
++ return;
++
++ /* "should never get here" */
++ ERROR(cdev, "can't loop %s to %s: %d\n",
++ ep->name, loop->in_ep->name,
++ status);
++ }
++
++ /* queue the buffer for some later OUT packet */
++ req->length = buflen;
++ status = usb_ep_queue(loop->out_ep, req, GFP_ATOMIC);
++ if (status == 0)
++ return;
++
++ /* "should never get here" */
++ /* FALLTHROUGH */
++
++ default:
++ ERROR(cdev, "%s loop complete --> %d, %d/%d\n", ep->name,
++ status, req->actual, req->length);
++ /* FALLTHROUGH */
++
++ /* NOTE: since this driver doesn't maintain an explicit record
++ * of requests it submitted (just maintains qlen count), we
++ * rely on the hardware driver to clean up on disconnect or
++ * endpoint disable.
++ */
++ case -ECONNABORTED: /* hardware forced ep reset */
++ case -ECONNRESET: /* request dequeued */
++ case -ESHUTDOWN: /* disconnect from host */
++ free_ep_req(ep, req);
++ return;
++ }
++}
++
++static void disable_loopback(struct f_loopback *loop)
++{
++ struct usb_composite_dev *cdev;
++
++ cdev = loop->function.config->cdev;
++ disable_endpoints(cdev, loop->in_ep, loop->out_ep);
++ VDBG(cdev, "%s disabled\n", loop->function.name);
++}
++
++static int
++enable_loopback(struct usb_composite_dev *cdev, struct f_loopback *loop)
++{
++ int result = 0;
++ const struct usb_endpoint_descriptor *src, *sink;
++ struct usb_ep *ep;
++ struct usb_request *req;
++ unsigned i;
++
++ src = ep_choose(cdev->gadget, &hs_source_desc, &fs_source_desc);
++ sink = ep_choose(cdev->gadget, &hs_sink_desc, &fs_sink_desc);
++
++ /* one endpoint writes data back IN to the host */
++ ep = loop->in_ep;
++ result = usb_ep_enable(ep, src);
++ if (result < 0)
++ return result;
++ ep->driver_data = loop;
++
++ /* one endpoint just reads OUT packets */
++ ep = loop->out_ep;
++ result = usb_ep_enable(ep, sink);
++ if (result < 0) {
++fail0:
++ ep = loop->in_ep;
++ usb_ep_disable(ep);
++ ep->driver_data = NULL;
++ return result;
++ }
++ ep->driver_data = loop;
++
++ /* allocate a bunch of read buffers and queue them all at once.
++ * we buffer at most 'qlen' transfers; fewer if any need more
++ * than 'buflen' bytes each.
++ */
++ for (i = 0; i < qlen && result == 0; i++) {
++ req = alloc_ep_req(ep);
++ if (req) {
++ req->complete = loopback_complete;
++ result = usb_ep_queue(ep, req, GFP_ATOMIC);
++ if (result)
++ ERROR(cdev, "%s queue req --> %d\n",
++ ep->name, result);
++ } else {
++ usb_ep_disable(ep);
++ ep->driver_data = NULL;
++ result = -ENOMEM;
++ goto fail0;
++ }
++ }
++
++ DBG(cdev, "%s enabled\n", loop->function.name);
++ return result;
++}
++
++static int loopback_set_alt(struct usb_function *f,
++ unsigned intf, unsigned alt)
++{
++ struct f_loopback *loop = func_to_loop(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ /* we know alt is zero */
++ if (loop->in_ep->driver_data)
++ disable_loopback(loop);
++ return enable_loopback(cdev, loop);
++}
++
++static void loopback_disable(struct usb_function *f)
++{
++ struct f_loopback *loop = func_to_loop(f);
++
++ disable_loopback(loop);
++}
++
++/*-------------------------------------------------------------------------*/
++
++static int __init loopback_bind_config(struct usb_configuration *c)
++{
++ struct f_loopback *loop;
++ int status;
++
++ loop = kzalloc(sizeof *loop, GFP_KERNEL);
++ if (!loop)
++ return -ENOMEM;
++
++ loop->function.name = "loopback";
++ loop->function.descriptors = fs_loopback_descs;
++ loop->function.bind = loopback_bind;
++ loop->function.unbind = loopback_unbind;
++ loop->function.set_alt = loopback_set_alt;
++ loop->function.disable = loopback_disable;
++
++ status = usb_add_function(c, &loop->function);
++ if (status)
++ kfree(loop);
++ return status;
++}
++
++static struct usb_configuration loopback_driver = {
++ .label = "loopback",
++ .strings = loopback_strings,
++ .bind = loopback_bind_config,
++ .bConfigurationValue = 2,
++ .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
++ .bMaxPower = 1, /* 2 mA, minimal */
++ /* .iConfiguration = DYNAMIC */
++};
++
++/**
++ * loopback_add - add a loopback testing configuration to a device
++ * @cdev: the device to support the loopback configuration
++ */
++int __init loopback_add(struct usb_composite_dev *cdev)
++{
++ int id;
++
++ /* allocate string ID(s) */
++ id = usb_string_id(cdev);
++ if (id < 0)
++ return id;
++ strings_loopback[0].id = id;
++
++ loopback_intf.iInterface = id;
++ loopback_driver.iConfiguration = id;
++
++ /* support OTG systems */
++ if (gadget_is_otg(cdev->gadget)) {
++ loopback_driver.descriptors = otg_desc;
++ loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
++ }
++
++ return usb_add_config(cdev, &loopback_driver);
++}
+diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
+new file mode 100644
+index 0000000..659b3d9
+--- /dev/null
++++ b/drivers/usb/gadget/f_rndis.c
+@@ -0,0 +1,825 @@
++/*
++ * f_rndis.c -- RNDIS link function driver
++ *
++ * Copyright (C) 2003-2005,2008 David Brownell
++ * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
++ * Copyright (C) 2008 Nokia Corporation
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++/* #define VERBOSE_DEBUG */
++
++#include <linux/kernel.h>
++#include <linux/device.h>
++#include <linux/etherdevice.h>
++
++#include <asm/atomic.h>
++
++#include "u_ether.h"
++#include "rndis.h"
++
++
++/*
++ * This function is an RNDIS Ethernet port -- a Microsoft protocol that's
++ * been promoted instead of the standard CDC Ethernet. The published RNDIS
++ * spec is ambiguous, incomplete, and needlessly complex. Variants such as
++ * ActiveSync have even worse status in terms of specification.
++ *
++ * In short: it's a protocol controlled by (and for) Microsoft, not for an
++ * Open ecosystem or markets. Linux supports it *only* because Microsoft
++ * doesn't support the CDC Ethernet standard.
++ *
++ * The RNDIS data transfer model is complex, with multiple Ethernet packets
++ * per USB message, and out of band data. The control model is built around
++ * what's essentially an "RNDIS RPC" protocol. It's all wrapped in a CDC ACM
++ * (modem, not Ethernet) veneer, with those ACM descriptors being entirely
++ * useless (they're ignored). RNDIS expects to be the only function in its
++ * configuration, so it's no real help if you need composite devices; and
++ * it expects to be the first configuration too.
++ *
++ * There is a single technical advantage of RNDIS over CDC Ethernet, if you
++ * discount the fluff that its RPC can be made to deliver: it doesn't need
++ * a NOP altsetting for the data interface. That lets it work on some of the
++ * "so smart it's stupid" hardware which takes over configuration changes
++ * from the software, and adds restrictions like "no altsettings".
++ *
++ * Unfortunately MSFT's RNDIS drivers are buggy. They hang or oops, and
++ * have all sorts of contrary-to-specification oddities that can prevent
++ * them from working sanely. Since bugfixes (or accurate specs, letting
++ * Linux work around those bugs) are unlikely to ever come from MSFT, you
++ * may want to avoid using RNDIS on purely operational grounds.
++ *
++ * Omissions from the RNDIS 1.0 specification include:
++ *
++ * - Power management ... references data that's scattered around lots
++ * of other documentation, which is incorrect/incomplete there too.
++ *
++ * - There are various undocumented protocol requirements, like the need
++ * to send garbage in some control-OUT messages.
++ *
++ * - MS-Windows drivers sometimes emit undocumented requests.
++ */
++
++struct rndis_ep_descs {
++ struct usb_endpoint_descriptor *in;
++ struct usb_endpoint_descriptor *out;
++ struct usb_endpoint_descriptor *notify;
++};
++
++struct f_rndis {
++ struct gether port;
++ u8 ctrl_id, data_id;
++ u8 ethaddr[ETH_ALEN];
++ int config;
++
++ struct rndis_ep_descs fs;
++ struct rndis_ep_descs hs;
++
++ struct usb_ep *notify;
++ struct usb_endpoint_descriptor *notify_desc;
++ struct usb_request *notify_req;
++ atomic_t notify_count;
++};
++
++static inline struct f_rndis *func_to_rndis(struct usb_function *f)
++{
++ return container_of(f, struct f_rndis, port.func);
++}
++
++/* peak (theoretical) bulk transfer rate in bits-per-second */
++static unsigned int bitrate(struct usb_gadget *g)
++{
++ if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
++ return 13 * 512 * 8 * 1000 * 8;
++ else
++ return 19 * 64 * 1 * 1000 * 8;
++}
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ */
++
++#define LOG2_STATUS_INTERVAL_MSEC 5 /* 1 << 5 == 32 msec */
++#define STATUS_BYTECOUNT 8 /* 8 bytes data */
++
++
++/* interface descriptor: */
++
++static struct usb_interface_descriptor rndis_control_intf __initdata = {
++ .bLength = sizeof rndis_control_intf,
++ .bDescriptorType = USB_DT_INTERFACE,
++
++ /* .bInterfaceNumber = DYNAMIC */
++ /* status endpoint is optional; this could be patched later */
++ .bNumEndpoints = 1,
++ .bInterfaceClass = USB_CLASS_COMM,
++ .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
++ .bInterfaceProtocol = USB_CDC_ACM_PROTO_VENDOR,
++ /* .iInterface = DYNAMIC */
++};
++
++static struct usb_cdc_header_desc header_desc __initdata = {
++ .bLength = sizeof header_desc,
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_HEADER_TYPE,
++
++ .bcdCDC = __constant_cpu_to_le16(0x0110),
++};
++
++static struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor __initdata = {
++ .bLength = sizeof call_mgmt_descriptor,
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,
++
++ .bmCapabilities = 0x00,
++ .bDataInterface = 0x01,
++};
++
++static struct usb_cdc_acm_descriptor acm_descriptor __initdata = {
++ .bLength = sizeof acm_descriptor,
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_ACM_TYPE,
++
++ .bmCapabilities = 0x00,
++};
++
++static struct usb_cdc_union_desc rndis_union_desc __initdata = {
++ .bLength = sizeof(rndis_union_desc),
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_UNION_TYPE,
++ /* .bMasterInterface0 = DYNAMIC */
++ /* .bSlaveInterface0 = DYNAMIC */
++};
++
++/* the data interface has two bulk endpoints */
++
++static struct usb_interface_descriptor rndis_data_intf __initdata = {
++ .bLength = sizeof rndis_data_intf,
++ .bDescriptorType = USB_DT_INTERFACE,
++
++ /* .bInterfaceNumber = DYNAMIC */
++ .bAlternateSetting = 1,
++ .bNumEndpoints = 2,
++ .bInterfaceClass = USB_CLASS_CDC_DATA,
++ .bInterfaceSubClass = 0,
++ .bInterfaceProtocol = 0,
++ /* .iInterface = DYNAMIC */
++};
++
++/* full speed support: */
++
++static struct usb_endpoint_descriptor fs_notify_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_INT,
++ .wMaxPacketSize = __constant_cpu_to_le16(STATUS_BYTECOUNT),
++ .bInterval = 1 << LOG2_STATUS_INTERVAL_MSEC,
++};
++
++static struct usb_endpoint_descriptor fs_in_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_endpoint_descriptor fs_out_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_OUT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_descriptor_header *eth_fs_function[] __initdata = {
++ /* control interface matches ACM, not Ethernet */
++ (struct usb_descriptor_header *) &rndis_control_intf,
++ (struct usb_descriptor_header *) &header_desc,
++ (struct usb_descriptor_header *) &call_mgmt_descriptor,
++ (struct usb_descriptor_header *) &acm_descriptor,
++ (struct usb_descriptor_header *) &rndis_union_desc,
++ (struct usb_descriptor_header *) &fs_notify_desc,
++ /* data interface has no altsetting */
++ (struct usb_descriptor_header *) &rndis_data_intf,
++ (struct usb_descriptor_header *) &fs_in_desc,
++ (struct usb_descriptor_header *) &fs_out_desc,
++ NULL,
++};
++
++/* high speed support: */
++
++static struct usb_endpoint_descriptor hs_notify_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_INT,
++ .wMaxPacketSize = __constant_cpu_to_le16(STATUS_BYTECOUNT),
++ .bInterval = LOG2_STATUS_INTERVAL_MSEC + 4,
++};
++static struct usb_endpoint_descriptor hs_in_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_endpoint_descriptor hs_out_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_OUT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_descriptor_header *eth_hs_function[] __initdata = {
++ /* control interface matches ACM, not Ethernet */
++ (struct usb_descriptor_header *) &rndis_control_intf,
++ (struct usb_descriptor_header *) &header_desc,
++ (struct usb_descriptor_header *) &call_mgmt_descriptor,
++ (struct usb_descriptor_header *) &acm_descriptor,
++ (struct usb_descriptor_header *) &rndis_union_desc,
++ (struct usb_descriptor_header *) &hs_notify_desc,
++ /* data interface has no altsetting */
++ (struct usb_descriptor_header *) &rndis_data_intf,
++ (struct usb_descriptor_header *) &hs_in_desc,
++ (struct usb_descriptor_header *) &hs_out_desc,
++ NULL,
++};
++
++/* string descriptors: */
++
++static struct usb_string rndis_string_defs[] = {
++ [0].s = "RNDIS Communications Control",
++ [1].s = "RNDIS Ethernet Data",
++ { } /* end of list */
++};
++
++static struct usb_gadget_strings rndis_string_table = {
++ .language = 0x0409, /* en-us */
++ .strings = rndis_string_defs,
++};
++
++static struct usb_gadget_strings *rndis_strings[] = {
++ &rndis_string_table,
++ NULL,
++};
++
++/*-------------------------------------------------------------------------*/
++
++static struct sk_buff *rndis_add_header(struct sk_buff *skb)
++{
++ skb = skb_realloc_headroom(skb, sizeof(struct rndis_packet_msg_type));
++ if (skb)
++ rndis_add_hdr(skb);
++ return skb;
++}
++
++static void rndis_response_available(void *_rndis)
++{
++ struct f_rndis *rndis = _rndis;
++ struct usb_request *req = rndis->notify_req;
++ struct usb_composite_dev *cdev = rndis->port.func.config->cdev;
++ __le32 *data = req->buf;
++ int status;
++
++ if (atomic_inc_return(&rndis->notify_count))
++ return;
++
++ /* Send RNDIS RESPONSE_AVAILABLE notification; a
++ * USB_CDC_NOTIFY_RESPONSE_AVAILABLE "should" work too
++ *
++ * This is the only notification defined by RNDIS.
++ */
++ data[0] = cpu_to_le32(1);
++ data[1] = cpu_to_le32(0);
++
++ status = usb_ep_queue(rndis->notify, req, GFP_ATOMIC);
++ if (status) {
++ atomic_dec(&rndis->notify_count);
++ DBG(cdev, "notify/0 --> %d\n", status);
++ }
++}
++
++static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)
++{
++ struct f_rndis *rndis = req->context;
++ struct usb_composite_dev *cdev = rndis->port.func.config->cdev;
++ int status = req->status;
++
++ /* after TX:
++ * - USB_CDC_GET_ENCAPSULATED_RESPONSE (ep0/control)
++ * - RNDIS_RESPONSE_AVAILABLE (status/irq)
++ */
++ switch (status) {
++ case -ECONNRESET:
++ case -ESHUTDOWN:
++ /* connection gone */
++ atomic_set(&rndis->notify_count, 0);
++ break;
++ default:
++ DBG(cdev, "RNDIS %s response error %d, %d/%d\n",
++ ep->name, status,
++ req->actual, req->length);
++ /* FALLTHROUGH */
++ case 0:
++ if (ep != rndis->notify)
++ break;
++
++ /* handle multiple pending RNDIS_RESPONSE_AVAILABLE
++ * notifications by resending until we're done
++ */
++ if (atomic_dec_and_test(&rndis->notify_count))
++ break;
++ status = usb_ep_queue(rndis->notify, req, GFP_ATOMIC);
++ if (status) {
++ atomic_dec(&rndis->notify_count);
++ DBG(cdev, "notify/1 --> %d\n", status);
++ }
++ break;
++ }
++}
++
++static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req)
++{
++ struct f_rndis *rndis = req->context;
++ struct usb_composite_dev *cdev = rndis->port.func.config->cdev;
++ int status;
++
++ /* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */
++// spin_lock(&dev->lock);
++ status = rndis_msg_parser(rndis->config, (u8 *) req->buf);
++ if (status < 0)
++ ERROR(cdev, "RNDIS command error %d, %d/%d\n",
++ status, req->actual, req->length);
++// spin_unlock(&dev->lock);
++}
++
++static int
++rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
++{
++ struct f_rndis *rndis = func_to_rndis(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++ struct usb_request *req = cdev->req;
++ int value = -EOPNOTSUPP;
++ u16 w_index = le16_to_cpu(ctrl->wIndex);
++ u16 w_value = le16_to_cpu(ctrl->wValue);
++ u16 w_length = le16_to_cpu(ctrl->wLength);
++
++ /* composite driver infrastructure handles everything except
++ * CDC class messages; interface activation uses set_alt().
++ */
++ switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
++
++ /* RNDIS uses the CDC command encapsulation mechanism to implement
++ * an RPC scheme, with much getting/setting of attributes by OID.
++ */
++ case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
++ | USB_CDC_SEND_ENCAPSULATED_COMMAND:
++ if (w_length > req->length || w_value
++ || w_index != rndis->ctrl_id)
++ goto invalid;
++ /* read the request; process it later */
++ value = w_length;
++ req->complete = rndis_command_complete;
++ req->context = rndis;
++ /* later, rndis_response_available() sends a notification */
++ break;
++
++ case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
++ | USB_CDC_GET_ENCAPSULATED_RESPONSE:
++ if (w_value || w_index != rndis->ctrl_id)
++ goto invalid;
++ else {
++ u8 *buf;
++ u32 n;
++
++ /* return the result */
++ buf = rndis_get_next_response(rndis->config, &n);
++ if (buf) {
++ memcpy(req->buf, buf, n);
++ req->complete = rndis_response_complete;
++ rndis_free_response(rndis->config, buf);
++ value = n;
++ }
++ /* else stalls ... spec says to avoid that */
++ }
++ break;
++
++ default:
++invalid:
++ VDBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
++ ctrl->bRequestType, ctrl->bRequest,
++ w_value, w_index, w_length);
++ }
++
++ /* respond with data transfer or status phase? */
++ if (value >= 0) {
++ DBG(cdev, "rndis req%02x.%02x v%04x i%04x l%d\n",
++ ctrl->bRequestType, ctrl->bRequest,
++ w_value, w_index, w_length);
++ req->zero = 0;
++ req->length = value;
++ value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
++ if (value < 0)
++ ERROR(cdev, "rndis response on err %d\n", value);
++ }
++
++ /* device either stalls (value < 0) or reports success */
++ return value;
++}
++
++
++static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
++{
++ struct f_rndis *rndis = func_to_rndis(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ /* we know alt == 0 */
++
++ if (intf == rndis->ctrl_id) {
++ if (rndis->notify->driver_data) {
++ VDBG(cdev, "reset rndis control %d\n", intf);
++ usb_ep_disable(rndis->notify);
++ } else {
++ VDBG(cdev, "init rndis ctrl %d\n", intf);
++ rndis->notify_desc = ep_choose(cdev->gadget,
++ rndis->hs.notify,
++ rndis->fs.notify);
++ }
++ usb_ep_enable(rndis->notify, rndis->notify_desc);
++ rndis->notify->driver_data = rndis;
++
++ } else if (intf == rndis->data_id) {
++ struct net_device *net;
++
++ if (rndis->port.in_ep->driver_data) {
++ DBG(cdev, "reset rndis\n");
++ gether_disconnect(&rndis->port);
++ } else {
++ DBG(cdev, "init rndis\n");
++ rndis->port.in = ep_choose(cdev->gadget,
++ rndis->hs.in, rndis->fs.in);
++ rndis->port.out = ep_choose(cdev->gadget,
++ rndis->hs.out, rndis->fs.out);
++ }
++
++ /* Avoid ZLPs; they can be troublesome. */
++ rndis->port.is_zlp_ok = false;
++
++ /* RNDIS should be in the "RNDIS uninitialized" state,
++ * either never activated or after rndis_uninit().
++ *
++ * We don't want data to flow here until a nonzero packet
++ * filter is set, at which point it enters "RNDIS data
++ * initialized" state ... but we do want the endpoints
++ * to be activated. It's a strange little state.
++ *
++ * REVISIT the RNDIS gadget code has done this wrong for a
++ * very long time. We need another call to the link layer
++ * code -- gether_updown(...bool) maybe -- to do it right.
++ */
++ rndis->port.cdc_filter = 0;
++
++ DBG(cdev, "RNDIS RX/TX early activation ... \n");
++ net = gether_connect(&rndis->port);
++ if (IS_ERR(net))
++ return PTR_ERR(net);
++
++ rndis_set_param_dev(rndis->config, net,
++ &rndis->port.cdc_filter);
++ } else
++ goto fail;
++
++ return 0;
++fail:
++ return -EINVAL;
++}
++
++static void rndis_disable(struct usb_function *f)
++{
++ struct f_rndis *rndis = func_to_rndis(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ if (!rndis->notify->driver_data)
++ return;
++
++ DBG(cdev, "rndis deactivated\n");
++
++ rndis_uninit(rndis->config);
++ gether_disconnect(&rndis->port);
++
++ usb_ep_disable(rndis->notify);
++ rndis->notify->driver_data = NULL;
++}
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * This isn't quite the same mechanism as CDC Ethernet, since the
++ * notification scheme passes less data, but the same set of link
++ * states must be tested. A key difference is that altsettings are
++ * not used to tell whether the link should send packets or not.
++ */
++
++static void rndis_open(struct gether *geth)
++{
++ struct f_rndis *rndis = func_to_rndis(&geth->func);
++ struct usb_composite_dev *cdev = geth->func.config->cdev;
++
++ DBG(cdev, "%s\n", __func__);
++
++ rndis_set_param_medium(rndis->config, NDIS_MEDIUM_802_3,
++ bitrate(cdev->gadget) / 100);
++ rndis_signal_connect(rndis->config);
++}
++
++static void rndis_close(struct gether *geth)
++{
++ struct f_rndis *rndis = func_to_rndis(&geth->func);
++
++ DBG(geth->func.config->cdev, "%s\n", __func__);
++
++ rndis_set_param_medium(rndis->config, NDIS_MEDIUM_802_3, 0);
++ rndis_signal_disconnect(rndis->config);
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* ethernet function driver setup/binding */
++
++static int __init
++rndis_bind(struct usb_configuration *c, struct usb_function *f)
++{
++ struct usb_composite_dev *cdev = c->cdev;
++ struct f_rndis *rndis = func_to_rndis(f);
++ int status;
++ struct usb_ep *ep;
++
++ /* allocate instance-specific interface IDs */
++ status = usb_interface_id(c, f);
++ if (status < 0)
++ goto fail;
++ rndis->ctrl_id = status;
++
++ rndis_control_intf.bInterfaceNumber = status;
++ rndis_union_desc.bMasterInterface0 = status;
++
++ status = usb_interface_id(c, f);
++ if (status < 0)
++ goto fail;
++ rndis->data_id = status;
++
++ rndis_data_intf.bInterfaceNumber = status;
++ rndis_union_desc.bSlaveInterface0 = status;
++
++ status = -ENODEV;
++
++ /* allocate instance-specific endpoints */
++ ep = usb_ep_autoconfig(cdev->gadget, &fs_in_desc);
++ if (!ep)
++ goto fail;
++ rndis->port.in_ep = ep;
++ ep->driver_data = cdev; /* claim */
++
++ ep = usb_ep_autoconfig(cdev->gadget, &fs_out_desc);
++ if (!ep)
++ goto fail;
++ rndis->port.out_ep = ep;
++ ep->driver_data = cdev; /* claim */
++
++ /* NOTE: a status/notification endpoint is, strictly speaking,
++ * optional. We don't treat it that way though! It's simpler,
++ * and some newer profiles don't treat it as optional.
++ */
++ ep = usb_ep_autoconfig(cdev->gadget, &fs_notify_desc);
++ if (!ep)
++ goto fail;
++ rndis->notify = ep;
++ ep->driver_data = cdev; /* claim */
++
++ status = -ENOMEM;
++
++ /* allocate notification request and buffer */
++ rndis->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
++ if (!rndis->notify_req)
++ goto fail;
++ rndis->notify_req->buf = kmalloc(STATUS_BYTECOUNT, GFP_KERNEL);
++ if (!rndis->notify_req->buf)
++ goto fail;
++ rndis->notify_req->length = STATUS_BYTECOUNT;
++ rndis->notify_req->context = rndis;
++ rndis->notify_req->complete = rndis_response_complete;
++
++ /* copy descriptors, and track endpoint copies */
++ f->descriptors = usb_copy_descriptors(eth_fs_function);
++ if (!f->descriptors)
++ goto fail;
++
++ rndis->fs.in = usb_find_endpoint(eth_fs_function,
++ f->descriptors, &fs_in_desc);
++ rndis->fs.out = usb_find_endpoint(eth_fs_function,
++ f->descriptors, &fs_out_desc);
++ rndis->fs.notify = usb_find_endpoint(eth_fs_function,
++ f->descriptors, &fs_notify_desc);
++
++ /* support all relevant hardware speeds... we expect that when
++ * hardware is dual speed, all bulk-capable endpoints work at
++ * both speeds
++ */
++ if (gadget_is_dualspeed(c->cdev->gadget)) {
++ hs_in_desc.bEndpointAddress =
++ fs_in_desc.bEndpointAddress;
++ hs_out_desc.bEndpointAddress =
++ fs_out_desc.bEndpointAddress;
++
++ /* copy descriptors, and track endpoint copies */
++ f->hs_descriptors = usb_copy_descriptors(eth_hs_function);
++
++ if (!f->hs_descriptors)
++ goto fail;
++
++ rndis->hs.in = usb_find_endpoint(eth_hs_function,
++ f->hs_descriptors, &hs_in_desc);
++ rndis->hs.out = usb_find_endpoint(eth_hs_function,
++ f->hs_descriptors, &hs_out_desc);
++ }
++
++ rndis->port.open = rndis_open;
++ rndis->port.close = rndis_close;
++
++ status = rndis_register(rndis_response_available, rndis);
++ if (status < 0)
++ goto fail;
++ rndis->config = status;
++
++ rndis_set_param_medium(rndis->config, NDIS_MEDIUM_802_3, 0);
++ rndis_set_host_mac(rndis->config, rndis->ethaddr);
++
++#if 0
++// FIXME
++ if (rndis_set_param_vendor(rndis->config, vendorID,
++ manufacturer))
++ goto fail0;
++#endif
++
++ /* NOTE: all that is done without knowing or caring about
++ * the network link ... which is unavailable to this code
++ * until we're activated via set_alt().
++ */
++
++ DBG(cdev, "RNDIS: %s speed IN/%s OUT/%s NOTIFY/%s\n",
++ gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
++ rndis->port.in_ep->name, rndis->port.out_ep->name,
++ rndis->notify->name);
++ return 0;
++
++fail:
++ if (gadget_is_dualspeed(c->cdev->gadget) && f->hs_descriptors)
++ usb_free_descriptors(f->hs_descriptors);
++ if (f->descriptors)
++ usb_free_descriptors(f->descriptors);
++
++ if (rndis->notify_req) {
++ kfree(rndis->notify_req->buf);
++ usb_ep_free_request(rndis->notify, rndis->notify_req);
++ }
++
++ /* we might as well release our claims on endpoints */
++ if (rndis->notify)
++ rndis->notify->driver_data = NULL;
++ if (rndis->port.out)
++ rndis->port.out_ep->driver_data = NULL;
++ if (rndis->port.in)
++ rndis->port.in_ep->driver_data = NULL;
++
++ ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
++
++ return status;
++}
++
++static void
++rndis_unbind(struct usb_configuration *c, struct usb_function *f)
++{
++ struct f_rndis *rndis = func_to_rndis(f);
++
++ rndis_deregister(rndis->config);
++ rndis_exit();
++
++ if (gadget_is_dualspeed(c->cdev->gadget))
++ usb_free_descriptors(f->hs_descriptors);
++ usb_free_descriptors(f->descriptors);
++
++ kfree(rndis->notify_req->buf);
++ usb_ep_free_request(rndis->notify, rndis->notify_req);
++
++ kfree(rndis);
++}
++
++/* Some controllers can't support RNDIS ... */
++static inline bool can_support_rndis(struct usb_configuration *c)
++{
++ /* only two endpoints on sa1100 */
++ if (gadget_is_sa1100(c->cdev->gadget))
++ return false;
++
++ /* everything else is *presumably* fine */
++ return true;
++}
++
++/**
++ * rndis_bind_config - add RNDIS network link to a configuration
++ * @c: the configuration to support the network link
++ * @ethaddr: a buffer in which the ethernet address of the host side
++ * side of the link was recorded
++ * Context: single threaded during gadget setup
++ *
++ * Returns zero on success, else negative errno.
++ *
++ * Caller must have called @gether_setup(). Caller is also responsible
++ * for calling @gether_cleanup() before module unload.
++ */
++int __init rndis_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
++{
++ struct f_rndis *rndis;
++ int status;
++
++ if (!can_support_rndis(c) || !ethaddr)
++ return -EINVAL;
++
++ /* maybe allocate device-global string IDs */
++ if (rndis_string_defs[0].id == 0) {
++
++ /* ... and setup RNDIS itself */
++ status = rndis_init();
++ if (status < 0)
++ return status;
++
++ /* control interface label */
++ status = usb_string_id(c->cdev);
++ if (status < 0)
++ return status;
++ rndis_string_defs[0].id = status;
++ rndis_control_intf.iInterface = status;
++
++ /* data interface label */
++ status = usb_string_id(c->cdev);
++ if (status < 0)
++ return status;
++ rndis_string_defs[1].id = status;
++ rndis_data_intf.iInterface = status;
++ }
++
++ /* allocate and initialize one new instance */
++ status = -ENOMEM;
++ rndis = kzalloc(sizeof *rndis, GFP_KERNEL);
++ if (!rndis)
++ goto fail;
++
++ memcpy(rndis->ethaddr, ethaddr, ETH_ALEN);
++
++ /* RNDIS activates when the host changes this filter */
++ rndis->port.cdc_filter = 0;
++
++ /* RNDIS has special (and complex) framing */
++ rndis->port.header_len = sizeof(struct rndis_packet_msg_type);
++ rndis->port.wrap = rndis_add_header;
++ rndis->port.unwrap = rndis_rm_hdr;
++
++ rndis->port.func.name = "rndis";
++ rndis->port.func.strings = rndis_strings;
++ /* descriptors are per-instance copies */
++ rndis->port.func.bind = rndis_bind;
++ rndis->port.func.unbind = rndis_unbind;
++ rndis->port.func.set_alt = rndis_set_alt;
++ rndis->port.func.setup = rndis_setup;
++ rndis->port.func.disable = rndis_disable;
++
++ status = usb_add_function(c, &rndis->port.func);
++ if (status) {
++ kfree(rndis);
++fail:
++ rndis_exit();
++ }
++ return status;
++}
+diff --git a/drivers/usb/gadget/f_serial.c b/drivers/usb/gadget/f_serial.c
+new file mode 100644
+index 0000000..fe5674d
+--- /dev/null
++++ b/drivers/usb/gadget/f_serial.c
+@@ -0,0 +1,294 @@
++/*
++ * f_serial.c - generic USB serial function driver
++ *
++ * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
++ * Copyright (C) 2008 by David Brownell
++ * Copyright (C) 2008 by Nokia Corporation
++ *
++ * This software is distributed under the terms of the GNU General
++ * Public License ("GPL") as published by the Free Software Foundation,
++ * either version 2 of that License or (at your option) any later version.
++ */
++
++#include <linux/kernel.h>
++#include <linux/device.h>
++
++#include "u_serial.h"
++#include "gadget_chips.h"
++
++
++/*
++ * This function packages a simple "generic serial" port with no real
++ * control mechanisms, just raw data transfer over two bulk endpoints.
++ *
++ * Because it's not standardized, this isn't as interoperable as the
++ * CDC ACM driver. However, for many purposes it's just as functional
++ * if you can arrange appropriate host side drivers.
++ */
++
++struct gser_descs {
++ struct usb_endpoint_descriptor *in;
++ struct usb_endpoint_descriptor *out;
++};
++
++struct f_gser {
++ struct gserial port;
++ u8 data_id;
++ u8 port_num;
++
++ struct gser_descs fs;
++ struct gser_descs hs;
++};
++
++static inline struct f_gser *func_to_gser(struct usb_function *f)
++{
++ return container_of(f, struct f_gser, port.func);
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* interface descriptor: */
++
++static struct usb_interface_descriptor gser_interface_desc __initdata = {
++ .bLength = USB_DT_INTERFACE_SIZE,
++ .bDescriptorType = USB_DT_INTERFACE,
++ /* .bInterfaceNumber = DYNAMIC */
++ .bNumEndpoints = 2,
++ .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
++ .bInterfaceSubClass = 0,
++ .bInterfaceProtocol = 0,
++ /* .iInterface = DYNAMIC */
++};
++
++/* full speed support: */
++
++static struct usb_endpoint_descriptor gser_fs_in_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_endpoint_descriptor gser_fs_out_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_OUT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_descriptor_header *gser_fs_function[] __initdata = {
++ (struct usb_descriptor_header *) &gser_interface_desc,
++ (struct usb_descriptor_header *) &gser_fs_in_desc,
++ (struct usb_descriptor_header *) &gser_fs_out_desc,
++ NULL,
++};
++
++/* high speed support: */
++
++static struct usb_endpoint_descriptor gser_hs_in_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_endpoint_descriptor gser_hs_out_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_descriptor_header *gser_hs_function[] __initdata = {
++ (struct usb_descriptor_header *) &gser_interface_desc,
++ (struct usb_descriptor_header *) &gser_hs_in_desc,
++ (struct usb_descriptor_header *) &gser_hs_out_desc,
++ NULL,
++};
++
++/* string descriptors: */
++
++static struct usb_string gser_string_defs[] = {
++ [0].s = "Generic Serial",
++ { } /* end of list */
++};
++
++static struct usb_gadget_strings gser_string_table = {
++ .language = 0x0409, /* en-us */
++ .strings = gser_string_defs,
++};
++
++static struct usb_gadget_strings *gser_strings[] = {
++ &gser_string_table,
++ NULL,
++};
++
++/*-------------------------------------------------------------------------*/
++
++static int gser_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
++{
++ struct f_gser *gser = func_to_gser(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ /* we know alt == 0, so this is an activation or a reset */
++
++ if (gser->port.in->driver_data) {
++ DBG(cdev, "reset generic ttyGS%d\n", gser->port_num);
++ gserial_disconnect(&gser->port);
++ } else {
++ DBG(cdev, "activate generic ttyGS%d\n", gser->port_num);
++ gser->port.in_desc = ep_choose(cdev->gadget,
++ gser->hs.in, gser->fs.in);
++ gser->port.out_desc = ep_choose(cdev->gadget,
++ gser->hs.out, gser->fs.out);
++ }
++ gserial_connect(&gser->port, gser->port_num);
++ return 0;
++}
++
++static void gser_disable(struct usb_function *f)
++{
++ struct f_gser *gser = func_to_gser(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ DBG(cdev, "generic ttyGS%d deactivated\n", gser->port_num);
++ gserial_disconnect(&gser->port);
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* serial function driver setup/binding */
++
++static int __init
++gser_bind(struct usb_configuration *c, struct usb_function *f)
++{
++ struct usb_composite_dev *cdev = c->cdev;
++ struct f_gser *gser = func_to_gser(f);
++ int status;
++ struct usb_ep *ep;
++
++ /* allocate instance-specific interface IDs */
++ status = usb_interface_id(c, f);
++ if (status < 0)
++ goto fail;
++ gser->data_id = status;
++ gser_interface_desc.bInterfaceNumber = status;
++
++ status = -ENODEV;
++
++ /* allocate instance-specific endpoints */
++ ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_in_desc);
++ if (!ep)
++ goto fail;
++ gser->port.in = ep;
++ ep->driver_data = cdev; /* claim */
++
++ ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_out_desc);
++ if (!ep)
++ goto fail;
++ gser->port.out = ep;
++ ep->driver_data = cdev; /* claim */
++
++ /* copy descriptors, and track endpoint copies */
++ f->descriptors = usb_copy_descriptors(gser_fs_function);
++
++ gser->fs.in = usb_find_endpoint(gser_fs_function,
++ f->descriptors, &gser_fs_in_desc);
++ gser->fs.out = usb_find_endpoint(gser_fs_function,
++ f->descriptors, &gser_fs_out_desc);
++
++
++ /* support all relevant hardware speeds... we expect that when
++ * hardware is dual speed, all bulk-capable endpoints work at
++ * both speeds
++ */
++ if (gadget_is_dualspeed(c->cdev->gadget)) {
++ gser_hs_in_desc.bEndpointAddress =
++ gser_fs_in_desc.bEndpointAddress;
++ gser_hs_out_desc.bEndpointAddress =
++ gser_fs_out_desc.bEndpointAddress;
++
++ /* copy descriptors, and track endpoint copies */
++ f->hs_descriptors = usb_copy_descriptors(gser_hs_function);
++
++ gser->hs.in = usb_find_endpoint(gser_hs_function,
++ f->hs_descriptors, &gser_hs_in_desc);
++ gser->hs.out = usb_find_endpoint(gser_hs_function,
++ f->hs_descriptors, &gser_hs_out_desc);
++ }
++
++ DBG(cdev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",
++ gser->port_num,
++ gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
++ gser->port.in->name, gser->port.out->name);
++ return 0;
++
++fail:
++ /* we might as well release our claims on endpoints */
++ if (gser->port.out)
++ gser->port.out->driver_data = NULL;
++ if (gser->port.in)
++ gser->port.in->driver_data = NULL;
++
++ ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
++
++ return status;
++}
++
++static void
++gser_unbind(struct usb_configuration *c, struct usb_function *f)
++{
++ if (gadget_is_dualspeed(c->cdev->gadget))
++ usb_free_descriptors(f->hs_descriptors);
++ usb_free_descriptors(f->descriptors);
++ kfree(func_to_gser(f));
++}
++
++/**
++ * gser_bind_config - add a generic serial function to a configuration
++ * @c: the configuration to support the serial instance
++ * @port_num: /dev/ttyGS* port this interface will use
++ * Context: single threaded during gadget setup
++ *
++ * Returns zero on success, else negative errno.
++ *
++ * Caller must have called @gserial_setup() with enough ports to
++ * handle all the ones it binds. Caller is also responsible
++ * for calling @gserial_cleanup() before module unload.
++ */
++int __init gser_bind_config(struct usb_configuration *c, u8 port_num)
++{
++ struct f_gser *gser;
++ int status;
++
++ /* REVISIT might want instance-specific strings to help
++ * distinguish instances ...
++ */
++
++ /* maybe allocate device-global string ID */
++ if (gser_string_defs[0].id == 0) {
++ status = usb_string_id(c->cdev);
++ if (status < 0)
++ return status;
++ gser_string_defs[0].id = status;
++ }
++
++ /* allocate and initialize one new instance */
++ gser = kzalloc(sizeof *gser, GFP_KERNEL);
++ if (!gser)
++ return -ENOMEM;
++
++ gser->port_num = port_num;
++
++ gser->port.func.name = "gser";
++ gser->port.func.strings = gser_strings;
++ gser->port.func.bind = gser_bind;
++ gser->port.func.unbind = gser_unbind;
++ gser->port.func.set_alt = gser_set_alt;
++ gser->port.func.disable = gser_disable;
++
++ status = usb_add_function(c, &gser->port.func);
++ if (status)
++ kfree(gser);
++ return status;
++}
+diff --git a/drivers/usb/gadget/f_sourcesink.c b/drivers/usb/gadget/f_sourcesink.c
+new file mode 100644
+index 0000000..f18c3a1
+--- /dev/null
++++ b/drivers/usb/gadget/f_sourcesink.c
+@@ -0,0 +1,587 @@
++/*
++ * f_sourcesink.c - USB peripheral source/sink configuration driver
++ *
++ * Copyright (C) 2003-2008 David Brownell
++ * Copyright (C) 2008 by Nokia Corporation
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++/* #define VERBOSE_DEBUG */
++
++#include <linux/kernel.h>
++#include <linux/utsname.h>
++#include <linux/device.h>
++
++#include "g_zero.h"
++#include "gadget_chips.h"
++
++
++/*
++ * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripheral
++ * controller drivers.
++ *
++ * This just sinks bulk packets OUT to the peripheral and sources them IN
++ * to the host, optionally with specific data patterns for integrity tests.
++ * As such it supports basic functionality and load tests.
++ *
++ * In terms of control messaging, this supports all the standard requests
++ * plus two that support control-OUT tests. If the optional "autoresume"
++ * mode is enabled, it provides good functional coverage for the "USBCV"
++ * test harness from USB-IF.
++ *
++ * Note that because this doesn't queue more than one request at a time,
++ * some other function must be used to test queueing logic. The network
++ * link (g_ether) is the best overall option for that, since its TX and RX
++ * queues are relatively independent, will receive a range of packet sizes,
++ * and can often be made to run out completely. Those issues are important
++ * when stress testing peripheral controller drivers.
++ *
++ *
++ * This is currently packaged as a configuration driver, which can't be
++ * combined with other functions to make composite devices. However, it
++ * can be combined with other independent configurations.
++ */
++struct f_sourcesink {
++ struct usb_function function;
++
++ struct usb_ep *in_ep;
++ struct usb_ep *out_ep;
++ struct timer_list resume;
++};
++
++static inline struct f_sourcesink *func_to_ss(struct usb_function *f)
++{
++ return container_of(f, struct f_sourcesink, function);
++}
++
++static unsigned autoresume;
++module_param(autoresume, uint, 0);
++MODULE_PARM_DESC(autoresume, "zero, or seconds before remote wakeup");
++
++static unsigned pattern;
++module_param(pattern, uint, 0);
++MODULE_PARM_DESC(pattern, "0 = all zeroes, 1 = mod63 ");
++
++/*-------------------------------------------------------------------------*/
++
++static struct usb_interface_descriptor source_sink_intf = {
++ .bLength = sizeof source_sink_intf,
++ .bDescriptorType = USB_DT_INTERFACE,
++
++ .bNumEndpoints = 2,
++ .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
++ /* .iInterface = DYNAMIC */
++};
++
++/* full speed support: */
++
++static struct usb_endpoint_descriptor fs_source_desc = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_endpoint_descriptor fs_sink_desc = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_OUT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_descriptor_header *fs_source_sink_descs[] = {
++ (struct usb_descriptor_header *) &source_sink_intf,
++ (struct usb_descriptor_header *) &fs_sink_desc,
++ (struct usb_descriptor_header *) &fs_source_desc,
++ NULL,
++};
++
++/* high speed support: */
++
++static struct usb_endpoint_descriptor hs_source_desc = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_endpoint_descriptor hs_sink_desc = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_descriptor_header *hs_source_sink_descs[] = {
++ (struct usb_descriptor_header *) &source_sink_intf,
++ (struct usb_descriptor_header *) &hs_source_desc,
++ (struct usb_descriptor_header *) &hs_sink_desc,
++ NULL,
++};
++
++/* function-specific strings: */
++
++static struct usb_string strings_sourcesink[] = {
++ [0].s = "source and sink data",
++ { } /* end of list */
++};
++
++static struct usb_gadget_strings stringtab_sourcesink = {
++ .language = 0x0409, /* en-us */
++ .strings = strings_sourcesink,
++};
++
++static struct usb_gadget_strings *sourcesink_strings[] = {
++ &stringtab_sourcesink,
++ NULL,
++};
++
++/*-------------------------------------------------------------------------*/
++
++static void sourcesink_autoresume(unsigned long _c)
++{
++ struct usb_composite_dev *cdev = (void *)_c;
++ struct usb_gadget *g = cdev->gadget;
++
++ /* Normally the host would be woken up for something
++ * more significant than just a timer firing; likely
++ * because of some direct user request.
++ */
++ if (g->speed != USB_SPEED_UNKNOWN) {
++ int status = usb_gadget_wakeup(g);
++ DBG(cdev, "%s --> %d\n", __func__, status);
++ }
++}
++
++static int __init
++sourcesink_bind(struct usb_configuration *c, struct usb_function *f)
++{
++ struct usb_composite_dev *cdev = c->cdev;
++ struct f_sourcesink *ss = func_to_ss(f);
++ int id;
++
++ /* allocate interface ID(s) */
++ id = usb_interface_id(c, f);
++ if (id < 0)
++ return id;
++ source_sink_intf.bInterfaceNumber = id;
++
++ /* allocate endpoints */
++ ss->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc);
++ if (!ss->in_ep) {
++autoconf_fail:
++ ERROR(cdev, "%s: can't autoconfigure on %s\n",
++ f->name, cdev->gadget->name);
++ return -ENODEV;
++ }
++ ss->in_ep->driver_data = cdev; /* claim */
++
++ ss->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_sink_desc);
++ if (!ss->out_ep)
++ goto autoconf_fail;
++ ss->out_ep->driver_data = cdev; /* claim */
++
++ setup_timer(&ss->resume, sourcesink_autoresume,
++ (unsigned long) c->cdev);
++
++ /* support high speed hardware */
++ if (gadget_is_dualspeed(c->cdev->gadget)) {
++ hs_source_desc.bEndpointAddress =
++ fs_source_desc.bEndpointAddress;
++ hs_sink_desc.bEndpointAddress =
++ fs_sink_desc.bEndpointAddress;
++ f->hs_descriptors = hs_source_sink_descs;
++ }
++
++ DBG(cdev, "%s speed %s: IN/%s, OUT/%s\n",
++ gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
++ f->name, ss->in_ep->name, ss->out_ep->name);
++ return 0;
++}
++
++static void
++sourcesink_unbind(struct usb_configuration *c, struct usb_function *f)
++{
++ kfree(func_to_ss(f));
++}
++
++/* optionally require specific source/sink data patterns */
++static int check_read_data(struct f_sourcesink *ss, struct usb_request *req)
++{
++ unsigned i;
++ u8 *buf = req->buf;
++ struct usb_composite_dev *cdev = ss->function.config->cdev;
++
++ for (i = 0; i < req->actual; i++, buf++) {
++ switch (pattern) {
++
++ /* all-zeroes has no synchronization issues */
++ case 0:
++ if (*buf == 0)
++ continue;
++ break;
++
++ /* "mod63" stays in sync with short-terminated transfers,
++ * OR otherwise when host and gadget agree on how large
++ * each usb transfer request should be. Resync is done
++ * with set_interface or set_config. (We *WANT* it to
++ * get quickly out of sync if controllers or their drivers
++ * stutter for any reason, including buffer duplcation...)
++ */
++ case 1:
++ if (*buf == (u8)(i % 63))
++ continue;
++ break;
++ }
++ ERROR(cdev, "bad OUT byte, buf[%d] = %d\n", i, *buf);
++ usb_ep_set_halt(ss->out_ep);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++static void reinit_write_data(struct usb_ep *ep, struct usb_request *req)
++{
++ unsigned i;
++ u8 *buf = req->buf;
++
++ switch (pattern) {
++ case 0:
++ memset(req->buf, 0, req->length);
++ break;
++ case 1:
++ for (i = 0; i < req->length; i++)
++ *buf++ = (u8) (i % 63);
++ break;
++ }
++}
++
++static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)
++{
++ struct f_sourcesink *ss = ep->driver_data;
++ struct usb_composite_dev *cdev = ss->function.config->cdev;
++ int status = req->status;
++
++ switch (status) {
++
++ case 0: /* normal completion? */
++ if (ep == ss->out_ep) {
++ check_read_data(ss, req);
++ memset(req->buf, 0x55, req->length);
++ } else
++ reinit_write_data(ep, req);
++ break;
++
++ /* this endpoint is normally active while we're configured */
++ case -ECONNABORTED: /* hardware forced ep reset */
++ case -ECONNRESET: /* request dequeued */
++ case -ESHUTDOWN: /* disconnect from host */
++ VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status,
++ req->actual, req->length);
++ if (ep == ss->out_ep)
++ check_read_data(ss, req);
++ free_ep_req(ep, req);
++ return;
++
++ case -EOVERFLOW: /* buffer overrun on read means that
++ * we didn't provide a big enough
++ * buffer.
++ */
++ default:
++#if 1
++ DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name,
++ status, req->actual, req->length);
++#endif
++ case -EREMOTEIO: /* short read */
++ break;
++ }
++
++ status = usb_ep_queue(ep, req, GFP_ATOMIC);
++ if (status) {
++ ERROR(cdev, "kill %s: resubmit %d bytes --> %d\n",
++ ep->name, req->length, status);
++ usb_ep_set_halt(ep);
++ /* FIXME recover later ... somehow */
++ }
++}
++
++static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in)
++{
++ struct usb_ep *ep;
++ struct usb_request *req;
++ int status;
++
++ ep = is_in ? ss->in_ep : ss->out_ep;
++ req = alloc_ep_req(ep);
++ if (!req)
++ return -ENOMEM;
++
++ req->complete = source_sink_complete;
++ if (is_in)
++ reinit_write_data(ep, req);
++ else
++ memset(req->buf, 0x55, req->length);
++
++ status = usb_ep_queue(ep, req, GFP_ATOMIC);
++ if (status) {
++ struct usb_composite_dev *cdev;
++
++ cdev = ss->function.config->cdev;
++ ERROR(cdev, "start %s %s --> %d\n",
++ is_in ? "IN" : "OUT",
++ ep->name, status);
++ free_ep_req(ep, req);
++ }
++
++ return status;
++}
++
++static void disable_source_sink(struct f_sourcesink *ss)
++{
++ struct usb_composite_dev *cdev;
++
++ cdev = ss->function.config->cdev;
++ disable_endpoints(cdev, ss->in_ep, ss->out_ep);
++ del_timer(&ss->resume);
++ VDBG(cdev, "%s disabled\n", ss->function.name);
++}
++
++static int
++enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss)
++{
++ int result = 0;
++ const struct usb_endpoint_descriptor *src, *sink;
++ struct usb_ep *ep;
++
++ src = ep_choose(cdev->gadget, &hs_source_desc, &fs_source_desc);
++ sink = ep_choose(cdev->gadget, &hs_sink_desc, &fs_sink_desc);
++
++ /* one endpoint writes (sources) zeroes IN (to the host) */
++ ep = ss->in_ep;
++ result = usb_ep_enable(ep, src);
++ if (result < 0)
++ return result;
++ ep->driver_data = ss;
++
++ result = source_sink_start_ep(ss, true);
++ if (result < 0) {
++fail:
++ ep = ss->in_ep;
++ usb_ep_disable(ep);
++ ep->driver_data = NULL;
++ return result;
++ }
++
++ /* one endpoint reads (sinks) anything OUT (from the host) */
++ ep = ss->out_ep;
++ result = usb_ep_enable(ep, sink);
++ if (result < 0)
++ goto fail;
++ ep->driver_data = ss;
++
++ result = source_sink_start_ep(ss, false);
++ if (result < 0) {
++ usb_ep_disable(ep);
++ ep->driver_data = NULL;
++ goto fail;
++ }
++
++ DBG(cdev, "%s enabled\n", ss->function.name);
++ return result;
++}
++
++static int sourcesink_set_alt(struct usb_function *f,
++ unsigned intf, unsigned alt)
++{
++ struct f_sourcesink *ss = func_to_ss(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ /* we know alt is zero */
++ if (ss->in_ep->driver_data)
++ disable_source_sink(ss);
++ return enable_source_sink(cdev, ss);
++}
++
++static void sourcesink_disable(struct usb_function *f)
++{
++ struct f_sourcesink *ss = func_to_ss(f);
++
++ disable_source_sink(ss);
++}
++
++static void sourcesink_suspend(struct usb_function *f)
++{
++ struct f_sourcesink *ss = func_to_ss(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ if (cdev->gadget->speed == USB_SPEED_UNKNOWN)
++ return;
++
++ if (autoresume) {
++ mod_timer(&ss->resume, jiffies + (HZ * autoresume));
++ DBG(cdev, "suspend, wakeup in %d seconds\n", autoresume);
++ } else
++ DBG(cdev, "%s\n", __func__);
++}
++
++static void sourcesink_resume(struct usb_function *f)
++{
++ struct f_sourcesink *ss = func_to_ss(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ DBG(cdev, "%s\n", __func__);
++ del_timer(&ss->resume);
++}
++
++/*-------------------------------------------------------------------------*/
++
++static int __init sourcesink_bind_config(struct usb_configuration *c)
++{
++ struct f_sourcesink *ss;
++ int status;
++
++ ss = kzalloc(sizeof *ss, GFP_KERNEL);
++ if (!ss)
++ return -ENOMEM;
++
++ ss->function.name = "source/sink";
++ ss->function.descriptors = fs_source_sink_descs;
++ ss->function.bind = sourcesink_bind;
++ ss->function.unbind = sourcesink_unbind;
++ ss->function.set_alt = sourcesink_set_alt;
++ ss->function.disable = sourcesink_disable;
++ ss->function.suspend = sourcesink_suspend;
++ ss->function.resume = sourcesink_resume;
++
++ status = usb_add_function(c, &ss->function);
++ if (status)
++ kfree(ss);
++ return status;
++}
++
++static int sourcesink_setup(struct usb_configuration *c,
++ const struct usb_ctrlrequest *ctrl)
++{
++ struct usb_request *req = c->cdev->req;
++ int value = -EOPNOTSUPP;
++ u16 w_index = le16_to_cpu(ctrl->wIndex);
++ u16 w_value = le16_to_cpu(ctrl->wValue);
++ u16 w_length = le16_to_cpu(ctrl->wLength);
++
++ /* composite driver infrastructure handles everything except
++ * the two control test requests.
++ */
++ switch (ctrl->bRequest) {
++
++ /*
++ * These are the same vendor-specific requests supported by
++ * Intel's USB 2.0 compliance test devices. We exceed that
++ * device spec by allowing multiple-packet requests.
++ *
++ * NOTE: the Control-OUT data stays in req->buf ... better
++ * would be copying it into a scratch buffer, so that other
++ * requests may safely intervene.
++ */
++ case 0x5b: /* control WRITE test -- fill the buffer */
++ if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
++ goto unknown;
++ if (w_value || w_index)
++ break;
++ /* just read that many bytes into the buffer */
++ if (w_length > req->length)
++ break;
++ value = w_length;
++ break;
++ case 0x5c: /* control READ test -- return the buffer */
++ if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
++ goto unknown;
++ if (w_value || w_index)
++ break;
++ /* expect those bytes are still in the buffer; send back */
++ if (w_length > req->length)
++ break;
++ value = w_length;
++ break;
++
++ default:
++unknown:
++ VDBG(c->cdev,
++ "unknown control req%02x.%02x v%04x i%04x l%d\n",
++ ctrl->bRequestType, ctrl->bRequest,
++ w_value, w_index, w_length);
++ }
++
++ /* respond with data transfer or status phase? */
++ if (value >= 0) {
++ VDBG(c->cdev, "source/sink req%02x.%02x v%04x i%04x l%d\n",
++ ctrl->bRequestType, ctrl->bRequest,
++ w_value, w_index, w_length);
++ req->zero = 0;
++ req->length = value;
++ value = usb_ep_queue(c->cdev->gadget->ep0, req, GFP_ATOMIC);
++ if (value < 0)
++ ERROR(c->cdev, "source/sinkc response, err %d\n",
++ value);
++ }
++
++ /* device either stalls (value < 0) or reports success */
++ return value;
++}
++
++static struct usb_configuration sourcesink_driver = {
++ .label = "source/sink",
++ .strings = sourcesink_strings,
++ .bind = sourcesink_bind_config,
++ .setup = sourcesink_setup,
++ .bConfigurationValue = 3,
++ .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
++ .bMaxPower = 1, /* 2 mA, minimal */
++ /* .iConfiguration = DYNAMIC */
++};
++
++/**
++ * sourcesink_add - add a source/sink testing configuration to a device
++ * @cdev: the device to support the configuration
++ */
++int __init sourcesink_add(struct usb_composite_dev *cdev)
++{
++ int id;
++
++ /* allocate string ID(s) */
++ id = usb_string_id(cdev);
++ if (id < 0)
++ return id;
++ strings_sourcesink[0].id = id;
++
++ source_sink_intf.iInterface = id;
++ sourcesink_driver.iConfiguration = id;
++
++ /* support autoresume for remote wakeup testing */
++ if (autoresume)
++ sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
++
++ /* support OTG systems */
++ if (gadget_is_otg(cdev->gadget)) {
++ sourcesink_driver.descriptors = otg_desc;
++ sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
++ }
++
++ return usb_add_config(cdev, &sourcesink_driver);
++}
+diff --git a/drivers/usb/gadget/f_subset.c b/drivers/usb/gadget/f_subset.c
+new file mode 100644
+index 0000000..acb8d23
+--- /dev/null
++++ b/drivers/usb/gadget/f_subset.c
+@@ -0,0 +1,421 @@
++/*
++ * f_subset.c -- "CDC Subset" Ethernet link function driver
++ *
++ * Copyright (C) 2003-2005,2008 David Brownell
++ * Copyright (C) 2008 Nokia Corporation
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++#include <linux/kernel.h>
++#include <linux/device.h>
++#include <linux/etherdevice.h>
++
++#include "u_ether.h"
++
++
++/*
++ * This function packages a simple "CDC Subset" Ethernet port with no real
++ * control mechanisms; just raw data transfer over two bulk endpoints.
++ * The data transfer model is exactly that of CDC Ethernet, which is
++ * why we call it the "CDC Subset".
++ *
++ * Because it's not standardized, this has some interoperability issues.
++ * They mostly relate to driver binding, since the data transfer model is
++ * so simple (CDC Ethernet). The original versions of this protocol used
++ * specific product/vendor IDs: byteswapped IDs for Digital Equipment's
++ * SA-1100 "Itsy" board, which could run Linux 2.4 kernels and supported
++ * daughtercards with USB peripheral connectors. (It was used more often
++ * with other boards, using the Itsy identifiers.) Linux hosts recognized
++ * this with CONFIG_USB_ARMLINUX; these devices have only one configuration
++ * and one interface.
++ *
++ * At some point, MCCI defined a (nonconformant) CDC MDLM variant called
++ * "SAFE", which happens to have a mode which is identical to the "CDC
++ * Subset" in terms of data transfer and lack of control model. This was
++ * adopted by later Sharp Zaurus models, and by some other software which
++ * Linux hosts recognize with CONFIG_USB_NET_ZAURUS.
++ *
++ * Because Microsoft's RNDIS drivers are far from robust, we added a few
++ * descriptors to the CDC Subset code, making this code look like a SAFE
++ * implementation. This lets you use MCCI's host side MS-Windows drivers
++ * if you get fed up with RNDIS. It also makes it easier for composite
++ * drivers to work, since they can use class based binding instead of
++ * caring about specific product and vendor IDs.
++ */
++
++struct geth_descs {
++ struct usb_endpoint_descriptor *in;
++ struct usb_endpoint_descriptor *out;
++};
++
++struct f_gether {
++ struct gether port;
++
++ char ethaddr[14];
++
++ struct geth_descs fs;
++ struct geth_descs hs;
++};
++
++static inline struct f_gether *func_to_geth(struct usb_function *f)
++{
++ return container_of(f, struct f_gether, port.func);
++}
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * "Simple" CDC-subset option is a simple vendor-neutral model that most
++ * full speed controllers can handle: one interface, two bulk endpoints.
++ * To assist host side drivers, we fancy it up a bit, and add descriptors so
++ * some host side drivers will understand it as a "SAFE" variant.
++ *
++ * "SAFE" loosely follows CDC WMC MDLM, violating the spec in various ways.
++ * Data endpoints live in the control interface, there's no data interface.
++ * And it's not used to talk to a cell phone radio.
++ */
++
++/* interface descriptor: */
++
++static struct usb_interface_descriptor subset_data_intf __initdata = {
++ .bLength = sizeof subset_data_intf,
++ .bDescriptorType = USB_DT_INTERFACE,
++
++ /* .bInterfaceNumber = DYNAMIC */
++ .bAlternateSetting = 0,
++ .bNumEndpoints = 2,
++ .bInterfaceClass = USB_CLASS_COMM,
++ .bInterfaceSubClass = USB_CDC_SUBCLASS_MDLM,
++ .bInterfaceProtocol = 0,
++ /* .iInterface = DYNAMIC */
++};
++
++static struct usb_cdc_header_desc header_desc __initdata = {
++ .bLength = sizeof header_desc,
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_HEADER_TYPE,
++
++ .bcdCDC = __constant_cpu_to_le16(0x0110),
++};
++
++static struct usb_cdc_mdlm_desc mdlm_desc __initdata = {
++ .bLength = sizeof mdlm_desc,
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_MDLM_TYPE,
++
++ .bcdVersion = __constant_cpu_to_le16(0x0100),
++ .bGUID = {
++ 0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,
++ 0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,
++ },
++};
++
++/* since "usb_cdc_mdlm_detail_desc" is a variable length structure, we
++ * can't really use its struct. All we do here is say that we're using
++ * the submode of "SAFE" which directly matches the CDC Subset.
++ */
++static u8 mdlm_detail_desc[] __initdata = {
++ 6,
++ USB_DT_CS_INTERFACE,
++ USB_CDC_MDLM_DETAIL_TYPE,
++
++ 0, /* "SAFE" */
++ 0, /* network control capabilities (none) */
++ 0, /* network data capabilities ("raw" encapsulation) */
++};
++
++static struct usb_cdc_ether_desc ether_desc __initdata = {
++ .bLength = sizeof ether_desc,
++ .bDescriptorType = USB_DT_CS_INTERFACE,
++ .bDescriptorSubType = USB_CDC_ETHERNET_TYPE,
++
++ /* this descriptor actually adds value, surprise! */
++ /* .iMACAddress = DYNAMIC */
++ .bmEthernetStatistics = __constant_cpu_to_le32(0), /* no statistics */
++ .wMaxSegmentSize = __constant_cpu_to_le16(ETH_FRAME_LEN),
++ .wNumberMCFilters = __constant_cpu_to_le16(0),
++ .bNumberPowerFilters = 0,
++};
++
++/* full speed support: */
++
++static struct usb_endpoint_descriptor fs_in_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_endpoint_descriptor fs_out_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bEndpointAddress = USB_DIR_OUT,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++};
++
++static struct usb_descriptor_header *fs_eth_function[] __initdata = {
++ (struct usb_descriptor_header *) &subset_data_intf,
++ (struct usb_descriptor_header *) &header_desc,
++ (struct usb_descriptor_header *) &mdlm_desc,
++ (struct usb_descriptor_header *) &mdlm_detail_desc,
++ (struct usb_descriptor_header *) ðer_desc,
++ (struct usb_descriptor_header *) &fs_in_desc,
++ (struct usb_descriptor_header *) &fs_out_desc,
++ NULL,
++};
++
++/* high speed support: */
++
++static struct usb_endpoint_descriptor hs_in_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_endpoint_descriptor hs_out_desc __initdata = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .wMaxPacketSize = __constant_cpu_to_le16(512),
++};
++
++static struct usb_descriptor_header *hs_eth_function[] __initdata = {
++ (struct usb_descriptor_header *) &subset_data_intf,
++ (struct usb_descriptor_header *) &header_desc,
++ (struct usb_descriptor_header *) &mdlm_desc,
++ (struct usb_descriptor_header *) &mdlm_detail_desc,
++ (struct usb_descriptor_header *) ðer_desc,
++ (struct usb_descriptor_header *) &hs_in_desc,
++ (struct usb_descriptor_header *) &hs_out_desc,
++ NULL,
++};
++
++/* string descriptors: */
++
++static struct usb_string geth_string_defs[] = {
++ [0].s = "CDC Ethernet Subset/SAFE",
++ [1].s = NULL /* DYNAMIC */,
++ { } /* end of list */
++};
++
++static struct usb_gadget_strings geth_string_table = {
++ .language = 0x0409, /* en-us */
++ .strings = geth_string_defs,
++};
++
++static struct usb_gadget_strings *geth_strings[] = {
++ &geth_string_table,
++ NULL,
++};
++
++/*-------------------------------------------------------------------------*/
++
++static int geth_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
++{
++ struct f_gether *geth = func_to_geth(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++ struct net_device *net;
++
++ /* we know alt == 0, so this is an activation or a reset */
++
++ if (geth->port.in_ep->driver_data) {
++ DBG(cdev, "reset cdc subset\n");
++ gether_disconnect(&geth->port);
++ }
++
++ DBG(cdev, "init + activate cdc subset\n");
++ geth->port.in = ep_choose(cdev->gadget,
++ geth->hs.in, geth->fs.in);
++ geth->port.out = ep_choose(cdev->gadget,
++ geth->hs.out, geth->fs.out);
++
++ net = gether_connect(&geth->port);
++ return IS_ERR(net) ? PTR_ERR(net) : 0;
++}
++
++static void geth_disable(struct usb_function *f)
++{
++ struct f_gether *geth = func_to_geth(f);
++ struct usb_composite_dev *cdev = f->config->cdev;
++
++ DBG(cdev, "net deactivated\n");
++ gether_disconnect(&geth->port);
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* serial function driver setup/binding */
++
++static int __init
++geth_bind(struct usb_configuration *c, struct usb_function *f)
++{
++ struct usb_composite_dev *cdev = c->cdev;
++ struct f_gether *geth = func_to_geth(f);
++ int status;
++ struct usb_ep *ep;
++
++ /* allocate instance-specific interface IDs */
++ status = usb_interface_id(c, f);
++ if (status < 0)
++ goto fail;
++ subset_data_intf.bInterfaceNumber = status;
++
++ status = -ENODEV;
++
++ /* allocate instance-specific endpoints */
++ ep = usb_ep_autoconfig(cdev->gadget, &fs_in_desc);
++ if (!ep)
++ goto fail;
++ geth->port.in_ep = ep;
++ ep->driver_data = cdev; /* claim */
++
++ ep = usb_ep_autoconfig(cdev->gadget, &fs_out_desc);
++ if (!ep)
++ goto fail;
++ geth->port.out_ep = ep;
++ ep->driver_data = cdev; /* claim */
++
++ /* copy descriptors, and track endpoint copies */
++ f->descriptors = usb_copy_descriptors(fs_eth_function);
++
++ geth->fs.in = usb_find_endpoint(fs_eth_function,
++ f->descriptors, &fs_in_desc);
++ geth->fs.out = usb_find_endpoint(fs_eth_function,
++ f->descriptors, &fs_out_desc);
++
++
++ /* support all relevant hardware speeds... we expect that when
++ * hardware is dual speed, all bulk-capable endpoints work at
++ * both speeds
++ */
++ if (gadget_is_dualspeed(c->cdev->gadget)) {
++ hs_in_desc.bEndpointAddress =
++ fs_in_desc.bEndpointAddress;
++ hs_out_desc.bEndpointAddress =
++ fs_out_desc.bEndpointAddress;
++
++ /* copy descriptors, and track endpoint copies */
++ f->hs_descriptors = usb_copy_descriptors(hs_eth_function);
++
++ geth->hs.in = usb_find_endpoint(hs_eth_function,
++ f->hs_descriptors, &hs_in_desc);
++ geth->hs.out = usb_find_endpoint(hs_eth_function,
++ f->hs_descriptors, &hs_out_desc);
++ }
++
++ /* NOTE: all that is done without knowing or caring about
++ * the network link ... which is unavailable to this code
++ * until we're activated via set_alt().
++ */
++
++ DBG(cdev, "CDC Subset: %s speed IN/%s OUT/%s\n",
++ gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
++ geth->port.in_ep->name, geth->port.out_ep->name);
++ return 0;
++
++fail:
++ /* we might as well release our claims on endpoints */
++ if (geth->port.out)
++ geth->port.out_ep->driver_data = NULL;
++ if (geth->port.in)
++ geth->port.in_ep->driver_data = NULL;
++
++ ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
++
++ return status;
++}
++
++static void
++geth_unbind(struct usb_configuration *c, struct usb_function *f)
++{
++ if (gadget_is_dualspeed(c->cdev->gadget))
++ usb_free_descriptors(f->hs_descriptors);
++ usb_free_descriptors(f->descriptors);
++ geth_string_defs[1].s = NULL;
++ kfree(func_to_geth(f));
++}
++
++/**
++ * geth_bind_config - add CDC Subset network link to a configuration
++ * @c: the configuration to support the network link
++ * @ethaddr: a buffer in which the ethernet address of the host side
++ * side of the link was recorded
++ * Context: single threaded during gadget setup
++ *
++ * Returns zero on success, else negative errno.
++ *
++ * Caller must have called @gether_setup(). Caller is also responsible
++ * for calling @gether_cleanup() before module unload.
++ */
++int __init geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
++{
++ struct f_gether *geth;
++ int status;
++
++ if (!ethaddr)
++ return -EINVAL;
++
++ /* maybe allocate device-global string IDs */
++ if (geth_string_defs[0].id == 0) {
++
++ /* interface label */
++ status = usb_string_id(c->cdev);
++ if (status < 0)
++ return status;
++ geth_string_defs[0].id = status;
++ subset_data_intf.iInterface = status;
++
++ /* MAC address */
++ status = usb_string_id(c->cdev);
++ if (status < 0)
++ return status;
++ geth_string_defs[1].id = status;
++ ether_desc.iMACAddress = status;
++ }
++
++ /* allocate and initialize one new instance */
++ geth = kzalloc(sizeof *geth, GFP_KERNEL);
++ if (!geth)
++ return -ENOMEM;
++
++ /* export host's Ethernet address in CDC format */
++ snprintf(geth->ethaddr, sizeof geth->ethaddr,
++ "%02X%02X%02X%02X%02X%02X",
++ ethaddr[0], ethaddr[1], ethaddr[2],
++ ethaddr[3], ethaddr[4], ethaddr[5]);
++ geth_string_defs[1].s = geth->ethaddr;
++
++ geth->port.cdc_filter = DEFAULT_FILTER;
++
++ geth->port.func.name = "cdc_subset";
++ geth->port.func.strings = geth_strings;
++ geth->port.func.bind = geth_bind;
++ geth->port.func.unbind = geth_unbind;
++ geth->port.func.set_alt = geth_set_alt;
++ geth->port.func.disable = geth_disable;
++
++ status = usb_add_function(c, &geth->port.func);
++ if (status) {
++ geth_string_defs[1].s = NULL;
++ kfree(geth);
++ }
++ return status;
++}
+diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
+index 47bb9f0..ea2c31d 100644
+--- a/drivers/usb/gadget/file_storage.c
++++ b/drivers/usb/gadget/file_storage.c
+@@ -308,7 +308,7 @@ MODULE_LICENSE("Dual BSD/GPL");
+ dev_vdbg(&(d)->gadget->dev , fmt , ## args)
+ #define ERROR(d, fmt, args...) \
+ dev_err(&(d)->gadget->dev , fmt , ## args)
+-#define WARN(d, fmt, args...) \
++#define WARNING(d, fmt, args...) \
+ dev_warn(&(d)->gadget->dev , fmt , ## args)
+ #define INFO(d, fmt, args...) \
+ dev_info(&(d)->gadget->dev , fmt , ## args)
+@@ -1091,7 +1091,7 @@ static int ep0_queue(struct fsg_dev *fsg)
+ if (rc != 0 && rc != -ESHUTDOWN) {
+
+ /* We can't do much more than wait for a reset */
+- WARN(fsg, "error in submission: %s --> %d\n",
++ WARNING(fsg, "error in submission: %s --> %d\n",
+ fsg->ep0->name, rc);
+ }
+ return rc;
+@@ -1227,7 +1227,7 @@ static void received_cbi_adsc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
+
+ /* Save the command for later */
+ if (fsg->cbbuf_cmnd_size)
+- WARN(fsg, "CB[I] overwriting previous command\n");
++ WARNING(fsg, "CB[I] overwriting previous command\n");
+ fsg->cbbuf_cmnd_size = req->actual;
+ memcpy(fsg->cbbuf_cmnd, req->buf, fsg->cbbuf_cmnd_size);
+
+@@ -1506,7 +1506,7 @@ static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
+ * submissions if DMA is enabled. */
+ if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP &&
+ req->length == 0))
+- WARN(fsg, "error in submission: %s --> %d\n",
++ WARNING(fsg, "error in submission: %s --> %d\n",
+ ep->name, rc);
+ }
+ }
+@@ -2294,7 +2294,7 @@ static int halt_bulk_in_endpoint(struct fsg_dev *fsg)
+ VDBG(fsg, "delayed bulk-in endpoint halt\n");
+ while (rc != 0) {
+ if (rc != -EAGAIN) {
+- WARN(fsg, "usb_ep_set_halt -> %d\n", rc);
++ WARNING(fsg, "usb_ep_set_halt -> %d\n", rc);
+ rc = 0;
+ break;
+ }
+@@ -2317,7 +2317,7 @@ static int wedge_bulk_in_endpoint(struct fsg_dev *fsg)
+ VDBG(fsg, "delayed bulk-in endpoint wedge\n");
+ while (rc != 0) {
+ if (rc != -EAGAIN) {
+- WARN(fsg, "usb_ep_set_wedge -> %d\n", rc);
++ WARNING(fsg, "usb_ep_set_wedge -> %d\n", rc);
+ rc = 0;
+ break;
+ }
+@@ -3755,7 +3755,7 @@ static int __init check_parameters(struct fsg_dev *fsg)
+ if (gcnum >= 0)
+ mod_data.release = 0x0300 + gcnum;
+ else {
+- WARN(fsg, "controller '%s' not recognized\n",
++ WARNING(fsg, "controller '%s' not recognized\n",
+ fsg->gadget->name);
+ mod_data.release = 0x0399;
+ }
+@@ -3867,8 +3867,8 @@ static int __init fsg_bind(struct usb_gadget *gadget)
+ curlun->dev.parent = &gadget->dev;
+ curlun->dev.driver = &fsg_driver.driver;
+ dev_set_drvdata(&curlun->dev, fsg);
+- snprintf(curlun->dev.bus_id, BUS_ID_SIZE,
+- "%s-lun%d", gadget->dev.bus_id, i);
++ dev_set_name(&curlun->dev,"%s-lun%d",
++ dev_name(&gadget->dev), i);
+
+ if ((rc = device_register(&curlun->dev)) != 0) {
+ INFO(fsg, "failed to register LUN%d: %d\n", i, rc);
+diff --git a/drivers/usb/gadget/fsl_usb2_udc.c b/drivers/usb/gadget/fsl_usb2_udc.c
+index 1868754..45ad556 100644
+--- a/drivers/usb/gadget/fsl_usb2_udc.c
++++ b/drivers/usb/gadget/fsl_usb2_udc.c
+@@ -223,7 +223,7 @@ static int dr_controller_setup(struct fsl_udc *udc)
+ fsl_writel(tmp, &dr_regs->endpointlistaddr);
+
+ VDBG("vir[qh_base] is %p phy[qh_base] is 0x%8x reg is 0x%8x",
+- (int)udc->ep_qh, (int)tmp,
++ udc->ep_qh, (int)tmp,
+ fsl_readl(&dr_regs->endpointlistaddr));
+
+ /* Config PHY interface */
+@@ -1538,7 +1538,7 @@ static void dtd_complete_irq(struct fsl_udc *udc)
+
+ /* If the ep is configured */
+ if (curr_ep->name == NULL) {
+- WARN("Invalid EP?");
++ WARNING("Invalid EP?");
+ continue;
+ }
+
+@@ -2331,7 +2331,7 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
+ udc_controller->gadget.name = driver_name;
+
+ /* Setup gadget.dev and register with kernel */
+- strcpy(udc_controller->gadget.dev.bus_id, "gadget");
++ dev_set_name(&udc_controller->gadget.dev, "gadget");
+ udc_controller->gadget.dev.release = fsl_udc_release;
+ udc_controller->gadget.dev.parent = &pdev->dev;
+ ret = device_register(&udc_controller->gadget.dev);
+diff --git a/drivers/usb/gadget/fsl_usb2_udc.h b/drivers/usb/gadget/fsl_usb2_udc.h
+index 98b1483..6131752 100644
+--- a/drivers/usb/gadget/fsl_usb2_udc.h
++++ b/drivers/usb/gadget/fsl_usb2_udc.h
+@@ -552,7 +552,7 @@ static void dump_msg(const char *label, const u8 * buf, unsigned int length)
+ #endif
+
+ #define ERR(stuff...) pr_err("udc: " stuff)
+-#define WARN(stuff...) pr_warning("udc: " stuff)
++#define WARNING(stuff...) pr_warning("udc: " stuff)
+ #define INFO(stuff...) pr_info("udc: " stuff)
+
+ /*-------------------------------------------------------------------------*/
+diff --git a/drivers/usb/gadget/g_zero.h b/drivers/usb/gadget/g_zero.h
+new file mode 100644
+index 0000000..dd2f16a
+--- /dev/null
++++ b/drivers/usb/gadget/g_zero.h
+@@ -0,0 +1,25 @@
++/*
++ * This header declares the utility functions used by "Gadget Zero", plus
++ * interfaces to its two single-configuration function drivers.
++ */
++
++#ifndef __G_ZERO_H
++#define __G_ZERO_H
++
++#include <linux/usb/composite.h>
++
++/* global state */
++extern unsigned buflen;
++extern const struct usb_descriptor_header *otg_desc[];
++
++/* common utilities */
++struct usb_request *alloc_ep_req(struct usb_ep *ep);
++void free_ep_req(struct usb_ep *ep, struct usb_request *req);
++void disable_endpoints(struct usb_composite_dev *cdev,
++ struct usb_ep *in, struct usb_ep *out);
++
++/* configuration-specific linkup */
++int sourcesink_add(struct usb_composite_dev *cdev);
++int loopback_add(struct usb_composite_dev *cdev);
++
++#endif /* __G_ZERO_H */
+diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
+index f7f159c..17d9905 100644
+--- a/drivers/usb/gadget/gadget_chips.h
++++ b/drivers/usb/gadget/gadget_chips.h
+@@ -11,6 +11,10 @@
+ * Some are available on 2.4 kernels; several are available, but not
+ * yet pushed in the 2.6 mainline tree.
+ */
++
++#ifndef __GADGET_CHIPS_H
++#define __GADGET_CHIPS_H
++
+ #ifdef CONFIG_USB_GADGET_NET2280
+ #define gadget_is_net2280(g) !strcmp("net2280", (g)->name)
+ #else
+@@ -29,8 +33,8 @@
+ #define gadget_is_dummy(g) 0
+ #endif
+
+-#ifdef CONFIG_USB_GADGET_PXA2XX
+-#define gadget_is_pxa(g) !strcmp("pxa2xx_udc", (g)->name)
++#ifdef CONFIG_USB_GADGET_PXA25X
++#define gadget_is_pxa(g) !strcmp("pxa25x_udc", (g)->name)
+ #else
+ #define gadget_is_pxa(g) 0
+ #endif
+@@ -214,3 +218,28 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
+ return 0x21;
+ return -ENOENT;
+ }
++
++
++/**
++ * gadget_supports_altsettings - return true if altsettings work
++ * @gadget: the gadget in question
++ */
++static inline bool gadget_supports_altsettings(struct usb_gadget *gadget)
++{
++ /* PXA 21x/25x/26x has no altsettings at all */
++ if (gadget_is_pxa(gadget))
++ return false;
++
++ /* PXA 27x and 3xx have *broken* altsetting support */
++ if (gadget_is_pxa27x(gadget))
++ return false;
++
++ /* SH3 hardware just doesn't do altsettings */
++ if (gadget_is_sh(gadget))
++ return false;
++
++ /* Everything else is *presumably* fine ... */
++ return true;
++}
++
++#endif /* __GADGET_CHIPS_H */
+diff --git a/drivers/usb/gadget/gmidi.c b/drivers/usb/gadget/gmidi.c
+index 7f4d482..ea8651e 100644
+--- a/drivers/usb/gadget/gmidi.c
++++ b/drivers/usb/gadget/gmidi.c
+@@ -138,8 +138,6 @@ static void gmidi_transmit(struct gmidi_device* dev, struct usb_request* req);
+ dev_vdbg(&(d)->gadget->dev , fmt , ## args)
+ #define ERROR(d, fmt, args...) \
+ dev_err(&(d)->gadget->dev , fmt , ## args)
+-#define WARN(d, fmt, args...) \
+- dev_warn(&(d)->gadget->dev , fmt , ## args)
+ #define INFO(d, fmt, args...) \
+ dev_info(&(d)->gadget->dev , fmt , ## args)
+
+diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
+index be6613a..60aa048 100644
+--- a/drivers/usb/gadget/goku_udc.c
++++ b/drivers/usb/gadget/goku_udc.c
+@@ -1768,7 +1768,7 @@ static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+ * usb_gadget_driver_{register,unregister}() must change.
+ */
+ if (the_controller) {
+- WARN(dev, "ignoring %s\n", pci_name(pdev));
++ WARNING(dev, "ignoring %s\n", pci_name(pdev));
+ return -EBUSY;
+ }
+ if (!pdev->irq) {
+@@ -1790,7 +1790,7 @@ static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+ dev->gadget.ops = &goku_ops;
+
+ /* the "gadget" abstracts/virtualizes the controller */
+- strcpy(dev->gadget.dev.bus_id, "gadget");
++ dev_set_name(&dev->gadget.dev, "gadget");
+ dev->gadget.dev.parent = &pdev->dev;
+ dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
+ dev->gadget.dev.release = gadget_release;
+diff --git a/drivers/usb/gadget/goku_udc.h b/drivers/usb/gadget/goku_udc.h
+index bc4eb1e..566cb23 100644
+--- a/drivers/usb/gadget/goku_udc.h
++++ b/drivers/usb/gadget/goku_udc.h
+@@ -285,7 +285,7 @@ struct goku_udc {
+
+ #define ERROR(dev,fmt,args...) \
+ xprintk(dev , KERN_ERR , fmt , ## args)
+-#define WARN(dev,fmt,args...) \
++#define WARNING(dev,fmt,args...) \
+ xprintk(dev , KERN_WARNING , fmt , ## args)
+ #define INFO(dev,fmt,args...) \
+ xprintk(dev , KERN_INFO , fmt , ## args)
+diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
+index 69b0a27..f4585d3 100644
+--- a/drivers/usb/gadget/inode.c
++++ b/drivers/usb/gadget/inode.c
+@@ -32,6 +32,7 @@
+ #include <asm/uaccess.h>
+ #include <linux/slab.h>
+ #include <linux/poll.h>
++#include <linux/smp_lock.h>
+
+ #include <linux/device.h>
+ #include <linux/moduleparam.h>
+@@ -261,8 +262,6 @@ static const char *CHIP;
+
+ #define ERROR(dev,fmt,args...) \
+ xprintk(dev , KERN_ERR , fmt , ## args)
+-#define WARN(dev,fmt,args...) \
+- xprintk(dev , KERN_WARNING , fmt , ## args)
+ #define INFO(dev,fmt,args...) \
+ xprintk(dev , KERN_INFO , fmt , ## args)
+
+@@ -483,8 +482,7 @@ ep_release (struct inode *inode, struct file *fd)
+ return 0;
+ }
+
+-static int ep_ioctl (struct inode *inode, struct file *fd,
+- unsigned code, unsigned long value)
++static long ep_ioctl(struct file *fd, unsigned code, unsigned long value)
+ {
+ struct ep_data *data = fd->private_data;
+ int status;
+@@ -740,7 +738,7 @@ static const struct file_operations ep_io_operations = {
+
+ .read = ep_read,
+ .write = ep_write,
+- .ioctl = ep_ioctl,
++ .unlocked_ioctl = ep_ioctl,
+ .release = ep_release,
+
+ .aio_read = ep_aio_read,
+@@ -1294,15 +1292,18 @@ out:
+ return mask;
+ }
+
+-static int dev_ioctl (struct inode *inode, struct file *fd,
+- unsigned code, unsigned long value)
++static long dev_ioctl (struct file *fd, unsigned code, unsigned long value)
+ {
+ struct dev_data *dev = fd->private_data;
+ struct usb_gadget *gadget = dev->gadget;
++ long ret = -ENOTTY;
+
+- if (gadget->ops->ioctl)
+- return gadget->ops->ioctl (gadget, code, value);
+- return -ENOTTY;
++ if (gadget->ops->ioctl) {
++ lock_kernel();
++ ret = gadget->ops->ioctl (gadget, code, value);
++ unlock_kernel();
++ }
++ return ret;
+ }
+
+ /* used after device configuration */
+@@ -1314,7 +1315,7 @@ static const struct file_operations ep0_io_operations = {
+ .write = ep0_write,
+ .fasync = ep0_fasync,
+ .poll = ep0_poll,
+- .ioctl = dev_ioctl,
++ .unlocked_ioctl = dev_ioctl,
+ .release = dev_release,
+ };
+
+@@ -1501,7 +1502,7 @@ gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
+ }
+ break;
+
+-#ifndef CONFIG_USB_GADGET_PXA2XX
++#ifndef CONFIG_USB_GADGET_PXA25X
+ /* PXA automagically handles this request too */
+ case USB_REQ_GET_CONFIGURATION:
+ if (ctrl->bRequestType != 0x80)
+@@ -1964,7 +1965,7 @@ static const struct file_operations dev_init_operations = {
+ .open = dev_open,
+ .write = dev_config,
+ .fasync = ep0_fasync,
+- .ioctl = dev_ioctl,
++ .unlocked_ioctl = dev_ioctl,
+ .release = dev_release,
+ };
+
+diff --git a/drivers/usb/gadget/lh7a40x_udc.c b/drivers/usb/gadget/lh7a40x_udc.c
+index 825abd2..c6e7df0 100644
+--- a/drivers/usb/gadget/lh7a40x_udc.c
++++ b/drivers/usb/gadget/lh7a40x_udc.c
+@@ -1970,7 +1970,7 @@ static const struct usb_gadget_ops lh7a40x_udc_ops = {
+
+ static void nop_release(struct device *dev)
+ {
+- DEBUG("%s %s\n", __func__, dev->bus_id);
++ DEBUG("%s %s\n", __func__, dev_name(dev));
+ }
+
+ static struct lh7a40x_udc memory = {
+diff --git a/drivers/usb/gadget/lh7a40x_udc.h b/drivers/usb/gadget/lh7a40x_udc.h
+index 1ecfd63..ca86120 100644
+--- a/drivers/usb/gadget/lh7a40x_udc.h
++++ b/drivers/usb/gadget/lh7a40x_udc.h
+@@ -47,7 +47,7 @@
+ #include <asm/irq.h>
+ #include <asm/system.h>
+ #include <asm/unaligned.h>
+-#include <asm/hardware.h>
++#include <mach/hardware.h>
+
+ #include <linux/usb/ch9.h>
+ #include <linux/usb/gadget.h>
+diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
+index ee6b35f..77b44fb 100644
+--- a/drivers/usb/gadget/m66592-udc.c
++++ b/drivers/usb/gadget/m66592-udc.c
+@@ -1593,7 +1593,7 @@ static int __init m66592_probe(struct platform_device *pdev)
+
+ m66592->gadget.ops = &m66592_gadget_ops;
+ device_initialize(&m66592->gadget.dev);
+- strcpy(m66592->gadget.dev.bus_id, "gadget");
++ dev_set_name(&m66592->gadget.dev, "gadget");
+ m66592->gadget.is_dualspeed = 1;
+ m66592->gadget.dev.parent = &pdev->dev;
+ m66592->gadget.dev.dma_mask = pdev->dev.dma_mask;
+diff --git a/drivers/usb/gadget/ndis.h b/drivers/usb/gadget/ndis.h
+index 09e3ee4..df886ce 100644
+--- a/drivers/usb/gadget/ndis.h
++++ b/drivers/usb/gadget/ndis.h
+@@ -1,11 +1,11 @@
+ /*
+- * ndis.h
+- *
++ * ndis.h
++ *
+ * ntddndis.h modified by Benedikt Spranger <b.spranger@pengutronix.de>
+- *
+- * Thanks to the cygwin development team,
++ *
++ * Thanks to the cygwin development team,
+ * espacially to Casper S. Hornstrup <chorns@users.sourceforge.net>
+- *
++ *
+ * THIS SOFTWARE IS NOT COPYRIGHTED
+ *
+ * This source code is offered for use in the public domain. You may
+diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
+index e018623..5cfb5eb 100644
+--- a/drivers/usb/gadget/net2280.c
++++ b/drivers/usb/gadget/net2280.c
+@@ -1007,7 +1007,7 @@ static void scan_dma_completions (struct net2280_ep *ep)
+ * 0122, and 0124; not all cases trigger the warning.
+ */
+ if ((tmp & (1 << NAK_OUT_PACKETS)) == 0) {
+- WARN (ep->dev, "%s lost packet sync!\n",
++ WARNING (ep->dev, "%s lost packet sync!\n",
+ ep->ep.name);
+ req->req.status = -EOVERFLOW;
+ } else if ((tmp = readl (&ep->regs->ep_avail)) != 0) {
+@@ -2768,7 +2768,7 @@ static int net2280_probe (struct pci_dev *pdev, const struct pci_device_id *id)
+ dev->gadget.is_dualspeed = 1;
+
+ /* the "gadget" abstracts/virtualizes the controller */
+- strcpy (dev->gadget.dev.bus_id, "gadget");
++ dev_set_name(&dev->gadget.dev, "gadget");
+ dev->gadget.dev.parent = &pdev->dev;
+ dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
+ dev->gadget.dev.release = gadget_release;
+diff --git a/drivers/usb/gadget/net2280.h b/drivers/usb/gadget/net2280.h
+index 1f2af39..81a71db 100644
+--- a/drivers/usb/gadget/net2280.h
++++ b/drivers/usb/gadget/net2280.h
+@@ -272,7 +272,7 @@ static inline void net2280_led_shutdown (struct net2280 *dev)
+
+ #define ERROR(dev,fmt,args...) \
+ xprintk(dev , KERN_ERR , fmt , ## args)
+-#define WARN(dev,fmt,args...) \
++#define WARNING(dev,fmt,args...) \
+ xprintk(dev , KERN_WARNING , fmt , ## args)
+ #define INFO(dev,fmt,args...) \
+ xprintk(dev , KERN_INFO , fmt , ## args)
+diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
+index 881d74c..bb54cca 100644
+--- a/drivers/usb/gadget/omap_udc.c
++++ b/drivers/usb/gadget/omap_udc.c
+@@ -52,8 +52,9 @@
+ #include <asm/unaligned.h>
+ #include <asm/mach-types.h>
+
+-#include <asm/arch/dma.h>
+-#include <asm/arch/usb.h>
++#include <mach/dma.h>
++#include <mach/usb.h>
++#include <mach/control.h>
+
+ #include "omap_udc.h"
+
+@@ -135,13 +136,17 @@ static void use_ep(struct omap_ep *ep, u16 select)
+
+ if (ep->bEndpointAddress & USB_DIR_IN)
+ num |= UDC_EP_DIR;
+- UDC_EP_NUM_REG = num | select;
++ omap_writew(num | select, UDC_EP_NUM);
+ /* when select, MUST deselect later !! */
+ }
+
+ static inline void deselect_ep(void)
+ {
+- UDC_EP_NUM_REG &= ~UDC_EP_SEL;
++ u16 w;
++
++ w = omap_readw(UDC_EP_NUM);
++ w &= ~UDC_EP_SEL;
++ omap_writew(w, UDC_EP_NUM);
+ /* 6 wait states before TX will happen */
+ }
+
+@@ -216,7 +221,7 @@ static int omap_ep_enable(struct usb_ep *_ep,
+ ep->has_dma = 0;
+ ep->lch = -1;
+ use_ep(ep, UDC_EP_SEL);
+- UDC_CTRL_REG = udc->clr_halt;
++ omap_writew(udc->clr_halt, UDC_CTRL);
+ ep->ackwait = 0;
+ deselect_ep();
+
+@@ -232,7 +237,7 @@ static int omap_ep_enable(struct usb_ep *_ep,
+ if (desc->bmAttributes != USB_ENDPOINT_XFER_ISOC
+ && !ep->has_dma
+ && !(ep->bEndpointAddress & USB_DIR_IN)) {
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+ ep->ackwait = 1 + ep->double_buf;
+ }
+
+@@ -259,7 +264,7 @@ static int omap_ep_disable(struct usb_ep *_ep)
+ nuke (ep, -ESHUTDOWN);
+ ep->ep.maxpacket = ep->maxpacket;
+ ep->has_dma = 0;
+- UDC_CTRL_REG = UDC_SET_HALT;
++ omap_writew(UDC_SET_HALT, UDC_CTRL);
+ list_del_init(&ep->iso);
+ del_timer(&ep->timer);
+
+@@ -360,13 +365,13 @@ write_packet(u8 *buf, struct omap_req *req, unsigned max)
+ if (likely((((int)buf) & 1) == 0)) {
+ wp = (u16 *)buf;
+ while (max >= 2) {
+- UDC_DATA_REG = *wp++;
++ omap_writew(*wp++, UDC_DATA);
+ max -= 2;
+ }
+ buf = (u8 *)wp;
+ }
+ while (max--)
+- *(volatile u8 *)&UDC_DATA_REG = *buf++;
++ omap_writeb(*buf++, UDC_DATA);
+ return len;
+ }
+
+@@ -385,13 +390,13 @@ static int write_fifo(struct omap_ep *ep, struct omap_req *req)
+ prefetch(buf);
+
+ /* PIO-IN isn't double buffered except for iso */
+- ep_stat = UDC_STAT_FLG_REG;
++ ep_stat = omap_readw(UDC_STAT_FLG);
+ if (ep_stat & UDC_FIFO_UNWRITABLE)
+ return 0;
+
+ count = ep->ep.maxpacket;
+ count = write_packet(buf, req, count);
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+ ep->ackwait = 1;
+
+ /* last packet is often short (sometimes a zlp) */
+@@ -425,13 +430,13 @@ read_packet(u8 *buf, struct omap_req *req, unsigned avail)
+ if (likely((((int)buf) & 1) == 0)) {
+ wp = (u16 *)buf;
+ while (avail >= 2) {
+- *wp++ = UDC_DATA_REG;
++ *wp++ = omap_readw(UDC_DATA);
+ avail -= 2;
+ }
+ buf = (u8 *)wp;
+ }
+ while (avail--)
+- *buf++ = *(volatile u8 *)&UDC_DATA_REG;
++ *buf++ = omap_readb(UDC_DATA);
+ return len;
+ }
+
+@@ -446,7 +451,7 @@ static int read_fifo(struct omap_ep *ep, struct omap_req *req)
+ prefetchw(buf);
+
+ for (;;) {
+- u16 ep_stat = UDC_STAT_FLG_REG;
++ u16 ep_stat = omap_readw(UDC_STAT_FLG);
+
+ is_last = 0;
+ if (ep_stat & FIFO_EMPTY) {
+@@ -460,7 +465,7 @@ static int read_fifo(struct omap_ep *ep, struct omap_req *req)
+ if (ep_stat & UDC_FIFO_FULL)
+ avail = ep->ep.maxpacket;
+ else {
+- avail = UDC_RXFSTAT_REG;
++ avail = omap_readw(UDC_RXFSTAT);
+ ep->fnf = ep->double_buf;
+ }
+ count = read_packet(buf, req, avail);
+@@ -473,7 +478,7 @@ static int read_fifo(struct omap_ep *ep, struct omap_req *req)
+ req->req.status = -EOVERFLOW;
+ avail -= count;
+ while (avail--)
+- (void) *(volatile u8 *)&UDC_DATA_REG;
++ omap_readw(UDC_DATA);
+ }
+ } else if (req->req.length == req->req.actual)
+ is_last = 1;
+@@ -491,32 +496,6 @@ static int read_fifo(struct omap_ep *ep, struct omap_req *req)
+
+ /*-------------------------------------------------------------------------*/
+
+-static inline dma_addr_t dma_csac(unsigned lch)
+-{
+- dma_addr_t csac;
+-
+- /* omap 3.2/3.3 erratum: sometimes 0 is returned if CSAC/CDAC is
+- * read before the DMA controller finished disabling the channel.
+- */
+- csac = OMAP_DMA_CSAC_REG(lch);
+- if (csac == 0)
+- csac = OMAP_DMA_CSAC_REG(lch);
+- return csac;
+-}
+-
+-static inline dma_addr_t dma_cdac(unsigned lch)
+-{
+- dma_addr_t cdac;
+-
+- /* omap 3.2/3.3 erratum: sometimes 0 is returned if CSAC/CDAC is
+- * read before the DMA controller finished disabling the channel.
+- */
+- cdac = OMAP_DMA_CDAC_REG(lch);
+- if (cdac == 0)
+- cdac = OMAP_DMA_CDAC_REG(lch);
+- return cdac;
+-}
+-
+ static u16 dma_src_len(struct omap_ep *ep, dma_addr_t start)
+ {
+ dma_addr_t end;
+@@ -527,7 +506,7 @@ static u16 dma_src_len(struct omap_ep *ep, dma_addr_t start)
+ if (cpu_is_omap15xx())
+ return 0;
+
+- end = dma_csac(ep->lch);
++ end = omap_get_dma_src_pos(ep->lch);
+ if (end == ep->dma_counter)
+ return 0;
+
+@@ -537,15 +516,11 @@ static u16 dma_src_len(struct omap_ep *ep, dma_addr_t start)
+ return end - start;
+ }
+
+-#define DMA_DEST_LAST(x) (cpu_is_omap15xx() \
+- ? OMAP_DMA_CSAC_REG(x) /* really: CPC */ \
+- : dma_cdac(x))
+-
+ static u16 dma_dest_len(struct omap_ep *ep, dma_addr_t start)
+ {
+ dma_addr_t end;
+
+- end = DMA_DEST_LAST(ep->lch);
++ end = omap_get_dma_dst_pos(ep->lch);
+ if (end == ep->dma_counter)
+ return 0;
+
+@@ -565,7 +540,7 @@ static u16 dma_dest_len(struct omap_ep *ep, dma_addr_t start)
+
+ static void next_in_dma(struct omap_ep *ep, struct omap_req *req)
+ {
+- u16 txdma_ctrl;
++ u16 txdma_ctrl, w;
+ unsigned length = req->req.length - req->req.actual;
+ const int sync_mode = cpu_is_omap15xx()
+ ? OMAP_DMA_SYNC_FRAME
+@@ -596,14 +571,18 @@ static void next_in_dma(struct omap_ep *ep, struct omap_req *req)
+ 0, 0);
+
+ omap_start_dma(ep->lch);
+- ep->dma_counter = dma_csac(ep->lch);
+- UDC_DMA_IRQ_EN_REG |= UDC_TX_DONE_IE(ep->dma_channel);
+- UDC_TXDMA_REG(ep->dma_channel) = UDC_TXN_START | txdma_ctrl;
++ ep->dma_counter = omap_get_dma_src_pos(ep->lch);
++ w = omap_readw(UDC_DMA_IRQ_EN);
++ w |= UDC_TX_DONE_IE(ep->dma_channel);
++ omap_writew(w, UDC_DMA_IRQ_EN);
++ omap_writew(UDC_TXN_START | txdma_ctrl, UDC_TXDMA(ep->dma_channel));
+ req->dma_bytes = length;
+ }
+
+ static void finish_in_dma(struct omap_ep *ep, struct omap_req *req, int status)
+ {
++ u16 w;
++
+ if (status == 0) {
+ req->req.actual += req->dma_bytes;
+
+@@ -620,7 +599,9 @@ static void finish_in_dma(struct omap_ep *ep, struct omap_req *req, int status)
+
+ /* tx completion */
+ omap_stop_dma(ep->lch);
+- UDC_DMA_IRQ_EN_REG &= ~UDC_TX_DONE_IE(ep->dma_channel);
++ w = omap_readw(UDC_DMA_IRQ_EN);
++ w &= ~UDC_TX_DONE_IE(ep->dma_channel);
++ omap_writew(w, UDC_DMA_IRQ_EN);
+ done(ep, req, status);
+ }
+
+@@ -628,6 +609,7 @@ static void next_out_dma(struct omap_ep *ep, struct omap_req *req)
+ {
+ unsigned packets = req->req.length - req->req.actual;
+ int dma_trigger = 0;
++ u16 w;
+
+ if (cpu_is_omap24xx())
+ dma_trigger = OMAP24XX_DMA(USB_W2FC_RX0, ep->dma_channel);
+@@ -654,12 +636,14 @@ static void next_out_dma(struct omap_ep *ep, struct omap_req *req)
+ omap_set_dma_dest_params(ep->lch, OMAP_DMA_PORT_EMIFF,
+ OMAP_DMA_AMODE_POST_INC, req->req.dma + req->req.actual,
+ 0, 0);
+- ep->dma_counter = DMA_DEST_LAST(ep->lch);
++ ep->dma_counter = omap_get_dma_dst_pos(ep->lch);
+
+- UDC_RXDMA_REG(ep->dma_channel) = UDC_RXN_STOP | (packets - 1);
+- UDC_DMA_IRQ_EN_REG |= UDC_RX_EOT_IE(ep->dma_channel);
+- UDC_EP_NUM_REG = (ep->bEndpointAddress & 0xf);
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
++ omap_writew(UDC_RXN_STOP | (packets - 1), UDC_RXDMA(ep->dma_channel));
++ w = omap_readw(UDC_DMA_IRQ_EN);
++ w |= UDC_RX_EOT_IE(ep->dma_channel);
++ omap_writew(w, UDC_DMA_IRQ_EN);
++ omap_writew(ep->bEndpointAddress & 0xf, UDC_EP_NUM);
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+
+ omap_start_dma(ep->lch);
+ }
+@@ -667,7 +651,7 @@ static void next_out_dma(struct omap_ep *ep, struct omap_req *req)
+ static void
+ finish_out_dma(struct omap_ep *ep, struct omap_req *req, int status, int one)
+ {
+- u16 count;
++ u16 count, w;
+
+ if (status == 0)
+ ep->dma_counter = (u16) (req->req.dma + req->req.actual);
+@@ -686,13 +670,15 @@ finish_out_dma(struct omap_ep *ep, struct omap_req *req, int status, int one)
+ return;
+
+ /* rx completion */
+- UDC_DMA_IRQ_EN_REG &= ~UDC_RX_EOT_IE(ep->dma_channel);
++ w = omap_readw(UDC_DMA_IRQ_EN);
++ w &= ~UDC_RX_EOT_IE(ep->dma_channel);
++ omap_writew(w, UDC_DMA_IRQ_EN);
+ done(ep, req, status);
+ }
+
+ static void dma_irq(struct omap_udc *udc, u16 irq_src)
+ {
+- u16 dman_stat = UDC_DMAN_STAT_REG;
++ u16 dman_stat = omap_readw(UDC_DMAN_STAT);
+ struct omap_ep *ep;
+ struct omap_req *req;
+
+@@ -706,7 +692,7 @@ static void dma_irq(struct omap_udc *udc, u16 irq_src)
+ struct omap_req, queue);
+ finish_in_dma(ep, req, 0);
+ }
+- UDC_IRQ_SRC_REG = UDC_TXN_DONE;
++ omap_writew(UDC_TXN_DONE, UDC_IRQ_SRC);
+
+ if (!list_empty (&ep->queue)) {
+ req = container_of(ep->queue.next,
+@@ -725,7 +711,7 @@ static void dma_irq(struct omap_udc *udc, u16 irq_src)
+ struct omap_req, queue);
+ finish_out_dma(ep, req, 0, dman_stat & UDC_DMA_RX_SB);
+ }
+- UDC_IRQ_SRC_REG = UDC_RXN_EOT;
++ omap_writew(UDC_RXN_EOT, UDC_IRQ_SRC);
+
+ if (!list_empty (&ep->queue)) {
+ req = container_of(ep->queue.next,
+@@ -739,7 +725,7 @@ static void dma_irq(struct omap_udc *udc, u16 irq_src)
+ ep->irqs++;
+ /* omap15xx does this unasked... */
+ VDBG("%s, RX_CNT irq?\n", ep->ep.name);
+- UDC_IRQ_SRC_REG = UDC_RXN_CNT;
++ omap_writew(UDC_RXN_CNT, UDC_IRQ_SRC);
+ }
+ }
+
+@@ -762,9 +748,9 @@ static void dma_channel_claim(struct omap_ep *ep, unsigned channel)
+
+ is_in = ep->bEndpointAddress & USB_DIR_IN;
+ if (is_in)
+- reg = UDC_TXDMA_CFG_REG;
++ reg = omap_readw(UDC_TXDMA_CFG);
+ else
+- reg = UDC_RXDMA_CFG_REG;
++ reg = omap_readw(UDC_RXDMA_CFG);
+ reg |= UDC_DMA_REQ; /* "pulse" activated */
+
+ ep->dma_channel = 0;
+@@ -792,7 +778,7 @@ static void dma_channel_claim(struct omap_ep *ep, unsigned channel)
+ status = omap_request_dma(dma_channel,
+ ep->ep.name, dma_error, ep, &ep->lch);
+ if (status == 0) {
+- UDC_TXDMA_CFG_REG = reg;
++ omap_writew(reg, UDC_TXDMA_CFG);
+ /* EMIFF or SDRC */
+ omap_set_dma_src_burst_mode(ep->lch,
+ OMAP_DMA_DATA_BURST_4);
+@@ -801,7 +787,7 @@ static void dma_channel_claim(struct omap_ep *ep, unsigned channel)
+ omap_set_dma_dest_params(ep->lch,
+ OMAP_DMA_PORT_TIPB,
+ OMAP_DMA_AMODE_CONSTANT,
+- (unsigned long) io_v2p((u32)&UDC_DATA_DMA_REG),
++ UDC_DATA_DMA,
+ 0, 0);
+ }
+ } else {
+@@ -813,12 +799,12 @@ static void dma_channel_claim(struct omap_ep *ep, unsigned channel)
+ status = omap_request_dma(dma_channel,
+ ep->ep.name, dma_error, ep, &ep->lch);
+ if (status == 0) {
+- UDC_RXDMA_CFG_REG = reg;
++ omap_writew(reg, UDC_RXDMA_CFG);
+ /* TIPB */
+ omap_set_dma_src_params(ep->lch,
+ OMAP_DMA_PORT_TIPB,
+ OMAP_DMA_AMODE_CONSTANT,
+- (unsigned long) io_v2p((u32)&UDC_DATA_DMA_REG),
++ UDC_DATA_DMA,
+ 0, 0);
+ /* EMIFF or SDRC */
+ omap_set_dma_dest_burst_mode(ep->lch,
+@@ -834,7 +820,7 @@ static void dma_channel_claim(struct omap_ep *ep, unsigned channel)
+
+ /* channel type P: hw synch (fifo) */
+ if (cpu_class_is_omap1() && !cpu_is_omap15xx())
+- OMAP1_DMA_LCH_CTRL_REG(ep->lch) = 2;
++ omap_set_dma_channel_mode(ep->lch, OMAP_DMA_LCH_P);
+ }
+
+ just_restart:
+@@ -860,7 +846,7 @@ just_restart:
+ (is_in ? write_fifo : read_fifo)(ep, req);
+ deselect_ep();
+ if (!is_in) {
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+ ep->ackwait = 1 + ep->double_buf;
+ }
+ /* IN: 6 wait states before it'll tx */
+@@ -881,7 +867,7 @@ static void dma_channel_release(struct omap_ep *ep)
+ else
+ req = NULL;
+
+- active = ((1 << 7) & OMAP_DMA_CCR_REG(ep->lch)) != 0;
++ active = omap_get_dma_active_status(ep->lch);
+
+ DBG("%s release %s %cxdma%d %p\n", ep->ep.name,
+ active ? "active" : "idle",
+@@ -894,23 +880,25 @@ static void dma_channel_release(struct omap_ep *ep)
+
+ /* wait till current packet DMA finishes, and fifo empties */
+ if (ep->bEndpointAddress & USB_DIR_IN) {
+- UDC_TXDMA_CFG_REG = (UDC_TXDMA_CFG_REG & ~mask) | UDC_DMA_REQ;
++ omap_writew((omap_readw(UDC_TXDMA_CFG) & ~mask) | UDC_DMA_REQ,
++ UDC_TXDMA_CFG);
+
+ if (req) {
+ finish_in_dma(ep, req, -ECONNRESET);
+
+ /* clear FIFO; hosts probably won't empty it */
+ use_ep(ep, UDC_EP_SEL);
+- UDC_CTRL_REG = UDC_CLR_EP;
++ omap_writew(UDC_CLR_EP, UDC_CTRL);
+ deselect_ep();
+ }
+- while (UDC_TXDMA_CFG_REG & mask)
++ while (omap_readw(UDC_TXDMA_CFG) & mask)
+ udelay(10);
+ } else {
+- UDC_RXDMA_CFG_REG = (UDC_RXDMA_CFG_REG & ~mask) | UDC_DMA_REQ;
++ omap_writew((omap_readw(UDC_RXDMA_CFG) & ~mask) | UDC_DMA_REQ,
++ UDC_RXDMA_CFG);
+
+ /* dma empties the fifo */
+- while (UDC_RXDMA_CFG_REG & mask)
++ while (omap_readw(UDC_RXDMA_CFG) & mask)
+ udelay(10);
+ if (req)
+ finish_out_dma(ep, req, -ECONNRESET, 0);
+@@ -997,9 +985,13 @@ omap_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
+ req->req.actual = 0;
+
+ /* maybe kickstart non-iso i/o queues */
+- if (is_iso)
+- UDC_IRQ_EN_REG |= UDC_SOF_IE;
+- else if (list_empty(&ep->queue) && !ep->stopped && !ep->ackwait) {
++ if (is_iso) {
++ u16 w;
++
++ w = omap_readw(UDC_IRQ_EN);
++ w |= UDC_SOF_IE;
++ omap_writew(w, UDC_IRQ_EN);
++ } else if (list_empty(&ep->queue) && !ep->stopped && !ep->ackwait) {
+ int is_in;
+
+ if (ep->bEndpointAddress == 0) {
+@@ -1017,23 +1009,23 @@ omap_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
+ * requests to non-control endpoints
+ */
+ if (udc->ep0_set_config) {
+- u16 irq_en = UDC_IRQ_EN_REG;
++ u16 irq_en = omap_readw(UDC_IRQ_EN);
+
+ irq_en |= UDC_DS_CHG_IE | UDC_EP0_IE;
+ if (!udc->ep0_reset_config)
+ irq_en |= UDC_EPN_RX_IE
+ | UDC_EPN_TX_IE;
+- UDC_IRQ_EN_REG = irq_en;
++ omap_writew(irq_en, UDC_IRQ_EN);
+ }
+
+ /* STATUS for zero length DATA stages is
+ * always an IN ... even for IN transfers,
+ * a weird case which seem to stall OMAP.
+ */
+- UDC_EP_NUM_REG = (UDC_EP_SEL|UDC_EP_DIR);
+- UDC_CTRL_REG = UDC_CLR_EP;
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
+- UDC_EP_NUM_REG = UDC_EP_DIR;
++ omap_writew(UDC_EP_SEL | UDC_EP_DIR, UDC_EP_NUM);
++ omap_writew(UDC_CLR_EP, UDC_CTRL);
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
++ omap_writew(UDC_EP_DIR, UDC_EP_NUM);
+
+ /* cleanup */
+ udc->ep0_pending = 0;
+@@ -1042,11 +1034,11 @@ omap_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
+
+ /* non-empty DATA stage */
+ } else if (is_in) {
+- UDC_EP_NUM_REG = UDC_EP_SEL|UDC_EP_DIR;
++ omap_writew(UDC_EP_SEL | UDC_EP_DIR, UDC_EP_NUM);
+ } else {
+ if (udc->ep0_setup)
+ goto irq_wait;
+- UDC_EP_NUM_REG = UDC_EP_SEL;
++ omap_writew(UDC_EP_SEL, UDC_EP_NUM);
+ }
+ } else {
+ is_in = ep->bEndpointAddress & USB_DIR_IN;
+@@ -1062,7 +1054,7 @@ omap_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
+ req = NULL;
+ deselect_ep();
+ if (!is_in) {
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+ ep->ackwait = 1 + ep->double_buf;
+ }
+ /* IN: 6 wait states before it'll tx */
+@@ -1129,10 +1121,10 @@ static int omap_ep_set_halt(struct usb_ep *_ep, int value)
+ status = -EINVAL;
+ else if (value) {
+ if (ep->udc->ep0_set_config) {
+- WARN("error changing config?\n");
+- UDC_SYSCON2_REG = UDC_CLR_CFG;
++ WARNING("error changing config?\n");
++ omap_writew(UDC_CLR_CFG, UDC_SYSCON2);
+ }
+- UDC_SYSCON2_REG = UDC_STALL_CMD;
++ omap_writew(UDC_STALL_CMD, UDC_SYSCON2);
+ ep->udc->ep0_pending = 0;
+ status = 0;
+ } else /* NOP */
+@@ -1159,8 +1151,8 @@ static int omap_ep_set_halt(struct usb_ep *_ep, int value)
+ channel = 0;
+
+ use_ep(ep, UDC_EP_SEL);
+- if (UDC_STAT_FLG_REG & UDC_NON_ISO_FIFO_EMPTY) {
+- UDC_CTRL_REG = UDC_SET_HALT;
++ if (omap_readw(UDC_STAT_FLG) & UDC_NON_ISO_FIFO_EMPTY) {
++ omap_writew(UDC_SET_HALT, UDC_CTRL);
+ status = 0;
+ } else
+ status = -EAGAIN;
+@@ -1170,10 +1162,10 @@ static int omap_ep_set_halt(struct usb_ep *_ep, int value)
+ dma_channel_claim(ep, channel);
+ } else {
+ use_ep(ep, 0);
+- UDC_CTRL_REG = ep->udc->clr_halt;
++ omap_writew(ep->udc->clr_halt, UDC_CTRL);
+ ep->ackwait = 0;
+ if (!(ep->bEndpointAddress & USB_DIR_IN)) {
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+ ep->ackwait = 1 + ep->double_buf;
+ }
+ }
+@@ -1205,7 +1197,7 @@ static struct usb_ep_ops omap_ep_ops = {
+
+ static int omap_get_frame(struct usb_gadget *gadget)
+ {
+- u16 sof = UDC_SOF_REG;
++ u16 sof = omap_readw(UDC_SOF);
+ return (sof & UDC_TS_OK) ? (sof & UDC_TS) : -EL2NSYNC;
+ }
+
+@@ -1224,7 +1216,7 @@ static int omap_wakeup(struct usb_gadget *gadget)
+ */
+ if (udc->devstat & (UDC_B_HNP_ENABLE|UDC_R_WK_OK)) {
+ DBG("remote wakeup...\n");
+- UDC_SYSCON2_REG = UDC_RMT_WKP;
++ omap_writew(UDC_RMT_WKP, UDC_SYSCON2);
+ retval = 0;
+ }
+
+@@ -1247,12 +1239,12 @@ omap_set_selfpowered(struct usb_gadget *gadget, int is_selfpowered)
+
+ udc = container_of(gadget, struct omap_udc, gadget);
+ spin_lock_irqsave(&udc->lock, flags);
+- syscon1 = UDC_SYSCON1_REG;
++ syscon1 = omap_readw(UDC_SYSCON1);
+ if (is_selfpowered)
+ syscon1 |= UDC_SELF_PWR;
+ else
+ syscon1 &= ~UDC_SELF_PWR;
+- UDC_SYSCON1_REG = syscon1;
++ omap_writew(syscon1, UDC_SYSCON1);
+ spin_unlock_irqrestore(&udc->lock, flags);
+
+ return 0;
+@@ -1265,18 +1257,36 @@ static int can_pullup(struct omap_udc *udc)
+
+ static void pullup_enable(struct omap_udc *udc)
+ {
+- UDC_SYSCON1_REG |= UDC_PULLUP_EN;
+- if (!gadget_is_otg(&udc->gadget) && !cpu_is_omap15xx())
+- OTG_CTRL_REG |= OTG_BSESSVLD;
+- UDC_IRQ_EN_REG = UDC_DS_CHG_IE;
++ u16 w;
++
++ w = omap_readw(UDC_SYSCON1);
++ w |= UDC_PULLUP_EN;
++ omap_writew(w, UDC_SYSCON1);
++ if (!gadget_is_otg(&udc->gadget) && !cpu_is_omap15xx()) {
++ u32 l;
++
++ l = omap_readl(OTG_CTRL);
++ l |= OTG_BSESSVLD;
++ omap_writel(l, OTG_CTRL);
++ }
++ omap_writew(UDC_DS_CHG_IE, UDC_IRQ_EN);
+ }
+
+ static void pullup_disable(struct omap_udc *udc)
+ {
+- if (!gadget_is_otg(&udc->gadget) && !cpu_is_omap15xx())
+- OTG_CTRL_REG &= ~OTG_BSESSVLD;
+- UDC_IRQ_EN_REG = UDC_DS_CHG_IE;
+- UDC_SYSCON1_REG &= ~UDC_PULLUP_EN;
++ u16 w;
++
++ if (!gadget_is_otg(&udc->gadget) && !cpu_is_omap15xx()) {
++ u32 l;
++
++ l = omap_readl(OTG_CTRL);
++ l &= ~OTG_BSESSVLD;
++ omap_writel(l, OTG_CTRL);
++ }
++ omap_writew(UDC_DS_CHG_IE, UDC_IRQ_EN);
++ w = omap_readw(UDC_SYSCON1);
++ w &= ~UDC_PULLUP_EN;
++ omap_writew(w, UDC_SYSCON1);
+ }
+
+ static struct omap_udc *udc;
+@@ -1304,6 +1314,7 @@ static int omap_vbus_session(struct usb_gadget *gadget, int is_active)
+ {
+ struct omap_udc *udc;
+ unsigned long flags;
++ u32 l;
+
+ udc = container_of(gadget, struct omap_udc, gadget);
+ spin_lock_irqsave(&udc->lock, flags);
+@@ -1311,10 +1322,12 @@ static int omap_vbus_session(struct usb_gadget *gadget, int is_active)
+ udc->vbus_active = (is_active != 0);
+ if (cpu_is_omap15xx()) {
+ /* "software" detect, ignored if !VBUS_MODE_1510 */
++ l = omap_readl(FUNC_MUX_CTRL_0);
+ if (is_active)
+- FUNC_MUX_CTRL_0_REG |= VBUS_CTRL_1510;
++ l |= VBUS_CTRL_1510;
+ else
+- FUNC_MUX_CTRL_0_REG &= ~VBUS_CTRL_1510;
++ l &= ~VBUS_CTRL_1510;
++ omap_writel(l, FUNC_MUX_CTRL_0);
+ }
+ if (udc->dc_clk != NULL && is_active) {
+ if (!udc->clk_requested) {
+@@ -1384,9 +1397,9 @@ static void nuke(struct omap_ep *ep, int status)
+ dma_channel_release(ep);
+
+ use_ep(ep, 0);
+- UDC_CTRL_REG = UDC_CLR_EP;
++ omap_writew(UDC_CLR_EP, UDC_CTRL);
+ if (ep->bEndpointAddress && ep->bmAttributes != USB_ENDPOINT_XFER_ISOC)
+- UDC_CTRL_REG = UDC_SET_HALT;
++ omap_writew(UDC_SET_HALT, UDC_CTRL);
+
+ while (!list_empty(&ep->queue)) {
+ req = list_entry(ep->queue.next, struct omap_req, queue);
+@@ -1414,8 +1427,8 @@ static void update_otg(struct omap_udc *udc)
+ if (!gadget_is_otg(&udc->gadget))
+ return;
+
+- if (OTG_CTRL_REG & OTG_ID)
+- devstat = UDC_DEVSTAT_REG;
++ if (omap_readl(OTG_CTRL) & OTG_ID)
++ devstat = omap_readw(UDC_DEVSTAT);
+ else
+ devstat = 0;
+
+@@ -1426,9 +1439,14 @@ static void update_otg(struct omap_udc *udc)
+ /* Enable HNP early, avoiding races on suspend irq path.
+ * ASSUMES OTG state machine B_BUS_REQ input is true.
+ */
+- if (udc->gadget.b_hnp_enable)
+- OTG_CTRL_REG = (OTG_CTRL_REG | OTG_B_HNPEN | OTG_B_BUSREQ)
+- & ~OTG_PULLUP;
++ if (udc->gadget.b_hnp_enable) {
++ u32 l;
++
++ l = omap_readl(OTG_CTRL);
++ l |= OTG_B_HNPEN | OTG_B_BUSREQ;
++ l &= ~OTG_PULLUP;
++ omap_writel(l, OTG_CTRL);
++ }
+ }
+
+ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
+@@ -1446,7 +1464,7 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
+
+ nuke(ep0, 0);
+ if (ack) {
+- UDC_IRQ_SRC_REG = ack;
++ omap_writew(ack, UDC_IRQ_SRC);
+ irq_src = UDC_SETUP;
+ }
+ }
+@@ -1466,9 +1484,9 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
+ if (irq_src & UDC_EP0_TX) {
+ int stat;
+
+- UDC_IRQ_SRC_REG = UDC_EP0_TX;
+- UDC_EP_NUM_REG = UDC_EP_SEL|UDC_EP_DIR;
+- stat = UDC_STAT_FLG_REG;
++ omap_writew(UDC_EP0_TX, UDC_IRQ_SRC);
++ omap_writew(UDC_EP_SEL|UDC_EP_DIR, UDC_EP_NUM);
++ stat = omap_readw(UDC_STAT_FLG);
+ if (stat & UDC_ACK) {
+ if (udc->ep0_in) {
+ /* write next IN packet from response,
+@@ -1476,26 +1494,26 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
+ */
+ if (req)
+ stat = write_fifo(ep0, req);
+- UDC_EP_NUM_REG = UDC_EP_DIR;
++ omap_writew(UDC_EP_DIR, UDC_EP_NUM);
+ if (!req && udc->ep0_pending) {
+- UDC_EP_NUM_REG = UDC_EP_SEL;
+- UDC_CTRL_REG = UDC_CLR_EP;
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
+- UDC_EP_NUM_REG = 0;
++ omap_writew(UDC_EP_SEL, UDC_EP_NUM);
++ omap_writew(UDC_CLR_EP, UDC_CTRL);
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
++ omap_writew(0, UDC_EP_NUM);
+ udc->ep0_pending = 0;
+ } /* else: 6 wait states before it'll tx */
+ } else {
+ /* ack status stage of OUT transfer */
+- UDC_EP_NUM_REG = UDC_EP_DIR;
++ omap_writew(UDC_EP_DIR, UDC_EP_NUM);
+ if (req)
+ done(ep0, req, 0);
+ }
+ req = NULL;
+ } else if (stat & UDC_STALL) {
+- UDC_CTRL_REG = UDC_CLR_HALT;
+- UDC_EP_NUM_REG = UDC_EP_DIR;
++ omap_writew(UDC_CLR_HALT, UDC_CTRL);
++ omap_writew(UDC_EP_DIR, UDC_EP_NUM);
+ } else {
+- UDC_EP_NUM_REG = UDC_EP_DIR;
++ omap_writew(UDC_EP_DIR, UDC_EP_NUM);
+ }
+ }
+
+@@ -1503,9 +1521,9 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
+ if (irq_src & UDC_EP0_RX) {
+ int stat;
+
+- UDC_IRQ_SRC_REG = UDC_EP0_RX;
+- UDC_EP_NUM_REG = UDC_EP_SEL;
+- stat = UDC_STAT_FLG_REG;
++ omap_writew(UDC_EP0_RX, UDC_IRQ_SRC);
++ omap_writew(UDC_EP_SEL, UDC_EP_NUM);
++ stat = omap_readw(UDC_STAT_FLG);
+ if (stat & UDC_ACK) {
+ if (!udc->ep0_in) {
+ stat = 0;
+@@ -1513,34 +1531,35 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
+ * reactiviting the fifo; stall on errors.
+ */
+ if (!req || (stat = read_fifo(ep0, req)) < 0) {
+- UDC_SYSCON2_REG = UDC_STALL_CMD;
++ omap_writew(UDC_STALL_CMD, UDC_SYSCON2);
+ udc->ep0_pending = 0;
+ stat = 0;
+ } else if (stat == 0)
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
+- UDC_EP_NUM_REG = 0;
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
++ omap_writew(0, UDC_EP_NUM);
+
+ /* activate status stage */
+ if (stat == 1) {
+ done(ep0, req, 0);
+ /* that may have STALLed ep0... */
+- UDC_EP_NUM_REG = UDC_EP_SEL|UDC_EP_DIR;
+- UDC_CTRL_REG = UDC_CLR_EP;
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
+- UDC_EP_NUM_REG = UDC_EP_DIR;
++ omap_writew(UDC_EP_SEL | UDC_EP_DIR,
++ UDC_EP_NUM);
++ omap_writew(UDC_CLR_EP, UDC_CTRL);
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
++ omap_writew(UDC_EP_DIR, UDC_EP_NUM);
+ udc->ep0_pending = 0;
+ }
+ } else {
+ /* ack status stage of IN transfer */
+- UDC_EP_NUM_REG = 0;
++ omap_writew(0, UDC_EP_NUM);
+ if (req)
+ done(ep0, req, 0);
+ }
+ } else if (stat & UDC_STALL) {
+- UDC_CTRL_REG = UDC_CLR_HALT;
+- UDC_EP_NUM_REG = 0;
++ omap_writew(UDC_CLR_HALT, UDC_CTRL);
++ omap_writew(0, UDC_EP_NUM);
+ } else {
+- UDC_EP_NUM_REG = 0;
++ omap_writew(0, UDC_EP_NUM);
+ }
+ }
+
+@@ -1555,14 +1574,14 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
+
+ /* read the (latest) SETUP message */
+ do {
+- UDC_EP_NUM_REG = UDC_SETUP_SEL;
++ omap_writew(UDC_SETUP_SEL, UDC_EP_NUM);
+ /* two bytes at a time */
+- u.word[0] = UDC_DATA_REG;
+- u.word[1] = UDC_DATA_REG;
+- u.word[2] = UDC_DATA_REG;
+- u.word[3] = UDC_DATA_REG;
+- UDC_EP_NUM_REG = 0;
+- } while (UDC_IRQ_SRC_REG & UDC_SETUP);
++ u.word[0] = omap_readw(UDC_DATA);
++ u.word[1] = omap_readw(UDC_DATA);
++ u.word[2] = omap_readw(UDC_DATA);
++ u.word[3] = omap_readw(UDC_DATA);
++ omap_writew(0, UDC_EP_NUM);
++ } while (omap_readw(UDC_IRQ_SRC) & UDC_SETUP);
+
+ #define w_value le16_to_cpu(u.r.wValue)
+ #define w_index le16_to_cpu(u.r.wIndex)
+@@ -1593,9 +1612,9 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
+ * later if it fails the request.
+ */
+ if (udc->ep0_reset_config)
+- UDC_SYSCON2_REG = UDC_CLR_CFG;
++ omap_writew(UDC_CLR_CFG, UDC_SYSCON2);
+ else
+- UDC_SYSCON2_REG = UDC_DEV_CFG;
++ omap_writew(UDC_DEV_CFG, UDC_SYSCON2);
+ update_otg(udc);
+ goto delegate;
+ case USB_REQ_CLEAR_FEATURE:
+@@ -1613,10 +1632,10 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
+ || !ep->desc)
+ goto do_stall;
+ use_ep(ep, 0);
+- UDC_CTRL_REG = udc->clr_halt;
++ omap_writew(udc->clr_halt, UDC_CTRL);
+ ep->ackwait = 0;
+ if (!(ep->bEndpointAddress & USB_DIR_IN)) {
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+ ep->ackwait = 1 + ep->double_buf;
+ }
+ /* NOTE: assumes the host behaves sanely,
+@@ -1649,15 +1668,15 @@ static void ep0_irq(struct omap_udc *udc, u16 irq_src)
+ }
+ use_ep(ep, 0);
+ /* can't halt if fifo isn't empty... */
+- UDC_CTRL_REG = UDC_CLR_EP;
+- UDC_CTRL_REG = UDC_SET_HALT;
++ omap_writew(UDC_CLR_EP, UDC_CTRL);
++ omap_writew(UDC_SET_HALT, UDC_CTRL);
+ VDBG("%s halted by host\n", ep->name);
+ ep0out_status_stage:
+ status = 0;
+- UDC_EP_NUM_REG = UDC_EP_SEL|UDC_EP_DIR;
+- UDC_CTRL_REG = UDC_CLR_EP;
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
+- UDC_EP_NUM_REG = UDC_EP_DIR;
++ omap_writew(UDC_EP_SEL|UDC_EP_DIR, UDC_EP_NUM);
++ omap_writew(UDC_CLR_EP, UDC_CTRL);
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
++ omap_writew(UDC_EP_DIR, UDC_EP_NUM);
+ udc->ep0_pending = 0;
+ break;
+ case USB_REQ_GET_STATUS:
+@@ -1694,10 +1713,10 @@ intf_status:
+
+ zero_status:
+ /* return two zero bytes */
+- UDC_EP_NUM_REG = UDC_EP_SEL|UDC_EP_DIR;
+- UDC_DATA_REG = 0;
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
+- UDC_EP_NUM_REG = UDC_EP_DIR;
++ omap_writew(UDC_EP_SEL|UDC_EP_DIR, UDC_EP_NUM);
++ omap_writew(0, UDC_DATA);
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
++ omap_writew(UDC_EP_DIR, UDC_EP_NUM);
+ status = 0;
+ VDBG("GET_STATUS, interface %d\n", w_index);
+ /* next, status stage */
+@@ -1706,8 +1725,8 @@ zero_status:
+ delegate:
+ /* activate the ep0out fifo right away */
+ if (!udc->ep0_in && w_length) {
+- UDC_EP_NUM_REG = 0;
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
++ omap_writew(0, UDC_EP_NUM);
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+ }
+
+ /* gadget drivers see class/vendor specific requests,
+@@ -1746,11 +1765,11 @@ do_stall:
+ u.r.bRequestType, u.r.bRequest, status);
+ if (udc->ep0_set_config) {
+ if (udc->ep0_reset_config)
+- WARN("error resetting config?\n");
++ WARNING("error resetting config?\n");
+ else
+- UDC_SYSCON2_REG = UDC_CLR_CFG;
++ omap_writew(UDC_CLR_CFG, UDC_SYSCON2);
+ }
+- UDC_SYSCON2_REG = UDC_STALL_CMD;
++ omap_writew(UDC_STALL_CMD, UDC_SYSCON2);
+ udc->ep0_pending = 0;
+ }
+ }
+@@ -1764,7 +1783,7 @@ static void devstate_irq(struct omap_udc *udc, u16 irq_src)
+ {
+ u16 devstat, change;
+
+- devstat = UDC_DEVSTAT_REG;
++ devstat = omap_readw(UDC_DEVSTAT);
+ change = devstat ^ udc->devstat;
+ udc->devstat = devstat;
+
+@@ -1804,7 +1823,8 @@ static void devstate_irq(struct omap_udc *udc, u16 irq_src)
+ INFO("USB reset done, gadget %s\n",
+ udc->driver->driver.name);
+ /* ep0 traffic is legal from now on */
+- UDC_IRQ_EN_REG = UDC_DS_CHG_IE | UDC_EP0_IE;
++ omap_writew(UDC_DS_CHG_IE | UDC_EP0_IE,
++ UDC_IRQ_EN);
+ }
+ change &= ~UDC_USB_RESET;
+ }
+@@ -1848,7 +1868,7 @@ static void devstate_irq(struct omap_udc *udc, u16 irq_src)
+ VDBG("devstat %03x, ignore change %03x\n",
+ devstat, change);
+
+- UDC_IRQ_SRC_REG = UDC_DS_CHG;
++ omap_writew(UDC_DS_CHG, UDC_IRQ_SRC);
+ }
+
+ static irqreturn_t omap_udc_irq(int irq, void *_udc)
+@@ -1859,7 +1879,7 @@ static irqreturn_t omap_udc_irq(int irq, void *_udc)
+ unsigned long flags;
+
+ spin_lock_irqsave(&udc->lock, flags);
+- irq_src = UDC_IRQ_SRC_REG;
++ irq_src = omap_readw(UDC_IRQ_SRC);
+
+ /* Device state change (usb ch9 stuff) */
+ if (irq_src & UDC_DS_CHG) {
+@@ -1882,7 +1902,7 @@ static irqreturn_t omap_udc_irq(int irq, void *_udc)
+ irq_src &= ~(UDC_TXN_DONE|UDC_RXN_CNT|UDC_RXN_EOT);
+ }
+
+- irq_src &= ~(UDC_SOF|UDC_EPN_TX|UDC_EPN_RX);
++ irq_src &= ~(UDC_IRQ_SOF | UDC_EPN_TX|UDC_EPN_RX);
+ if (irq_src)
+ DBG("udc_irq, unhandled %03x\n", irq_src);
+ spin_unlock_irqrestore(&udc->lock, flags);
+@@ -1903,7 +1923,7 @@ static void pio_out_timer(unsigned long _ep)
+ spin_lock_irqsave(&ep->udc->lock, flags);
+ if (!list_empty(&ep->queue) && ep->ackwait) {
+ use_ep(ep, UDC_EP_SEL);
+- stat_flg = UDC_STAT_FLG_REG;
++ stat_flg = omap_readw(UDC_STAT_FLG);
+
+ if ((stat_flg & UDC_ACK) && (!(stat_flg & UDC_FIFO_EN)
+ || (ep->double_buf && HALF_FULL(stat_flg)))) {
+@@ -1913,8 +1933,8 @@ static void pio_out_timer(unsigned long _ep)
+ req = container_of(ep->queue.next,
+ struct omap_req, queue);
+ (void) read_fifo(ep, req);
+- UDC_EP_NUM_REG = ep->bEndpointAddress;
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
++ omap_writew(ep->bEndpointAddress, UDC_EP_NUM);
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+ ep->ackwait = 1 + ep->double_buf;
+ } else
+ deselect_ep();
+@@ -1934,20 +1954,20 @@ static irqreturn_t omap_udc_pio_irq(int irq, void *_dev)
+ unsigned long flags;
+
+ spin_lock_irqsave(&udc->lock, flags);
+- epn_stat = UDC_EPN_STAT_REG;
+- irq_src = UDC_IRQ_SRC_REG;
++ epn_stat = omap_readw(UDC_EPN_STAT);
++ irq_src = omap_readw(UDC_IRQ_SRC);
+
+ /* handle OUT first, to avoid some wasteful NAKs */
+ if (irq_src & UDC_EPN_RX) {
+ epnum = (epn_stat >> 8) & 0x0f;
+- UDC_IRQ_SRC_REG = UDC_EPN_RX;
++ omap_writew(UDC_EPN_RX, UDC_IRQ_SRC);
+ status = IRQ_HANDLED;
+ ep = &udc->ep[epnum];
+ ep->irqs++;
+
+- UDC_EP_NUM_REG = epnum | UDC_EP_SEL;
++ omap_writew(epnum | UDC_EP_SEL, UDC_EP_NUM);
+ ep->fnf = 0;
+- if ((UDC_STAT_FLG_REG & UDC_ACK)) {
++ if (omap_readw(UDC_STAT_FLG) & UDC_ACK) {
+ ep->ackwait--;
+ if (!list_empty(&ep->queue)) {
+ int stat;
+@@ -1959,15 +1979,15 @@ static irqreturn_t omap_udc_pio_irq(int irq, void *_dev)
+ }
+ }
+ /* min 6 clock delay before clearing EP_SEL ... */
+- epn_stat = UDC_EPN_STAT_REG;
+- epn_stat = UDC_EPN_STAT_REG;
+- UDC_EP_NUM_REG = epnum;
++ epn_stat = omap_readw(UDC_EPN_STAT);
++ epn_stat = omap_readw(UDC_EPN_STAT);
++ omap_writew(epnum, UDC_EP_NUM);
+
+ /* enabling fifo _after_ clearing ACK, contrary to docs,
+ * reduces lossage; timer still needed though (sigh).
+ */
+ if (ep->fnf) {
+- UDC_CTRL_REG = UDC_SET_FIFO_EN;
++ omap_writew(UDC_SET_FIFO_EN, UDC_CTRL);
+ ep->ackwait = 1 + ep->double_buf;
+ }
+ mod_timer(&ep->timer, PIO_OUT_TIMEOUT);
+@@ -1976,13 +1996,13 @@ static irqreturn_t omap_udc_pio_irq(int irq, void *_dev)
+ /* then IN transfers */
+ else if (irq_src & UDC_EPN_TX) {
+ epnum = epn_stat & 0x0f;
+- UDC_IRQ_SRC_REG = UDC_EPN_TX;
++ omap_writew(UDC_EPN_TX, UDC_IRQ_SRC);
+ status = IRQ_HANDLED;
+ ep = &udc->ep[16 + epnum];
+ ep->irqs++;
+
+- UDC_EP_NUM_REG = epnum | UDC_EP_DIR | UDC_EP_SEL;
+- if ((UDC_STAT_FLG_REG & UDC_ACK)) {
++ omap_writew(epnum | UDC_EP_DIR | UDC_EP_SEL, UDC_EP_NUM);
++ if (omap_readw(UDC_STAT_FLG) & UDC_ACK) {
+ ep->ackwait = 0;
+ if (!list_empty(&ep->queue)) {
+ req = container_of(ep->queue.next,
+@@ -1991,9 +2011,9 @@ static irqreturn_t omap_udc_pio_irq(int irq, void *_dev)
+ }
+ }
+ /* min 6 clock delay before clearing EP_SEL ... */
+- epn_stat = UDC_EPN_STAT_REG;
+- epn_stat = UDC_EPN_STAT_REG;
+- UDC_EP_NUM_REG = epnum | UDC_EP_DIR;
++ epn_stat = omap_readw(UDC_EPN_STAT);
++ epn_stat = omap_readw(UDC_EPN_STAT);
++ omap_writew(epnum | UDC_EP_DIR, UDC_EP_NUM);
+ /* then 6 clocks before it'd tx */
+ }
+
+@@ -2021,7 +2041,7 @@ static irqreturn_t omap_udc_iso_irq(int irq, void *_dev)
+ req = list_entry(ep->queue.next, struct omap_req, queue);
+
+ use_ep(ep, UDC_EP_SEL);
+- stat = UDC_STAT_FLG_REG;
++ stat = omap_readw(UDC_STAT_FLG);
+
+ /* NOTE: like the other controller drivers, this isn't
+ * currently reporting lost or damaged frames.
+@@ -2053,9 +2073,14 @@ static irqreturn_t omap_udc_iso_irq(int irq, void *_dev)
+ if (!list_empty(&ep->queue))
+ pending = 1;
+ }
+- if (!pending)
+- UDC_IRQ_EN_REG &= ~UDC_SOF_IE;
+- UDC_IRQ_SRC_REG = UDC_SOF;
++ if (!pending) {
++ u16 w;
++
++ w = omap_readw(UDC_IRQ_EN);
++ w &= ~UDC_SOF_IE;
++ omap_writew(w, UDC_IRQ_EN);
++ }
++ omap_writew(UDC_IRQ_SOF, UDC_IRQ_SRC);
+
+ spin_unlock_irqrestore(&udc->lock, flags);
+ return IRQ_HANDLED;
+@@ -2104,7 +2129,7 @@ int usb_gadget_register_driver (struct usb_gadget_driver *driver)
+ if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC)
+ continue;
+ use_ep(ep, 0);
+- UDC_CTRL_REG = UDC_SET_HALT;
++ omap_writew(UDC_SET_HALT, UDC_CTRL);
+ }
+ udc->ep0_pending = 0;
+ udc->ep[0].irqs = 0;
+@@ -2128,7 +2153,7 @@ int usb_gadget_register_driver (struct usb_gadget_driver *driver)
+ }
+ DBG("bound to driver %s\n", driver->driver.name);
+
+- UDC_IRQ_SRC_REG = UDC_IRQ_SRC_MASK;
++ omap_writew(UDC_IRQ_SRC_MASK, UDC_IRQ_SRC);
+
+ /* connect to bus through transceiver */
+ if (udc->transceiver) {
+@@ -2225,7 +2250,7 @@ static void proc_ep_show(struct seq_file *s, struct omap_ep *ep)
+ else
+ buf[0] = 0;
+
+- stat_flg = UDC_STAT_FLG_REG;
++ stat_flg = omap_readw(UDC_STAT_FLG);
+ seq_printf(s,
+ "\n%s %s%s%sirqs %ld stat %04x " EIGHTBITS FOURBITS "%s\n",
+ ep->name, buf,
+@@ -2286,17 +2311,17 @@ static int proc_otg_show(struct seq_file *s)
+ u32 trans;
+ char *ctrl_name;
+
+- tmp = OTG_REV_REG;
++ tmp = omap_readl(OTG_REV);
+ if (cpu_is_omap24xx()) {
+ ctrl_name = "control_devconf";
+- trans = CONTROL_DEVCONF_REG;
++ trans = omap_ctrl_readl(OMAP2_CONTROL_DEVCONF0);
+ } else {
+ ctrl_name = "tranceiver_ctrl";
+- trans = USB_TRANSCEIVER_CTRL_REG;
++ trans = omap_readw(USB_TRANSCEIVER_CTRL);
+ }
+ seq_printf(s, "\nOTG rev %d.%d, %s %05x\n",
+ tmp >> 4, tmp & 0xf, ctrl_name, trans);
+- tmp = OTG_SYSCON_1_REG;
++ tmp = omap_readw(OTG_SYSCON_1);
+ seq_printf(s, "otg_syscon1 %08x usb2 %s, usb1 %s, usb0 %s,"
+ FOURBITS "\n", tmp,
+ trx_mode(USB2_TRX_MODE(tmp), trans & CONF_USB2_UNI_R),
+@@ -2308,7 +2333,7 @@ static int proc_otg_show(struct seq_file *s)
+ (tmp & HST_IDLE_EN) ? " !host" : "",
+ (tmp & DEV_IDLE_EN) ? " !dev" : "",
+ (tmp & OTG_RESET_DONE) ? " reset_done" : " reset_active");
+- tmp = OTG_SYSCON_2_REG;
++ tmp = omap_readl(OTG_SYSCON_2);
+ seq_printf(s, "otg_syscon2 %08x%s" EIGHTBITS
+ " b_ase_brst=%d hmc=%d\n", tmp,
+ (tmp & OTG_EN) ? " otg_en" : "",
+@@ -2323,7 +2348,7 @@ static int proc_otg_show(struct seq_file *s)
+ (tmp & HMC_TLLATTACH) ? " tllattach" : "",
+ B_ASE_BRST(tmp),
+ OTG_HMC(tmp));
+- tmp = OTG_CTRL_REG;
++ tmp = omap_readl(OTG_CTRL);
+ seq_printf(s, "otg_ctrl %06x" EIGHTBITS EIGHTBITS "%s\n", tmp,
+ (tmp & OTG_ASESSVLD) ? " asess" : "",
+ (tmp & OTG_BSESSEND) ? " bsess_end" : "",
+@@ -2343,13 +2368,13 @@ static int proc_otg_show(struct seq_file *s)
+ (tmp & OTG_PU_VBUS) ? " pu_vb" : "",
+ (tmp & OTG_PU_ID) ? " pu_id" : ""
+ );
+- tmp = OTG_IRQ_EN_REG;
++ tmp = omap_readw(OTG_IRQ_EN);
+ seq_printf(s, "otg_irq_en %04x" "\n", tmp);
+- tmp = OTG_IRQ_SRC_REG;
++ tmp = omap_readw(OTG_IRQ_SRC);
+ seq_printf(s, "otg_irq_src %04x" "\n", tmp);
+- tmp = OTG_OUTCTRL_REG;
++ tmp = omap_readw(OTG_OUTCTRL);
+ seq_printf(s, "otg_outctrl %04x" "\n", tmp);
+- tmp = OTG_TEST_REG;
++ tmp = omap_readw(OTG_TEST);
+ seq_printf(s, "otg_test %04x" "\n", tmp);
+ return 0;
+ }
+@@ -2370,7 +2395,7 @@ static int proc_udc_show(struct seq_file *s, void *_)
+ driver_desc,
+ use_dma ? " (dma)" : "");
+
+- tmp = UDC_REV_REG & 0xff;
++ tmp = omap_readw(UDC_REV) & 0xff;
+ seq_printf(s,
+ "UDC rev %d.%d, fifo mode %d, gadget %s\n"
+ "hmc %d, transceiver %s\n",
+@@ -2384,16 +2409,16 @@ static int proc_udc_show(struct seq_file *s, void *_)
+ ? "external" : "(none)"));
+ if (cpu_class_is_omap1()) {
+ seq_printf(s, "ULPD control %04x req %04x status %04x\n",
+- __REG16(ULPD_CLOCK_CTRL),
+- __REG16(ULPD_SOFT_REQ),
+- __REG16(ULPD_STATUS_REQ));
++ omap_readw(ULPD_CLOCK_CTRL),
++ omap_readw(ULPD_SOFT_REQ),
++ omap_readw(ULPD_STATUS_REQ));
+ }
+
+ /* OTG controller registers */
+ if (!cpu_is_omap15xx())
+ proc_otg_show(s);
+
+- tmp = UDC_SYSCON1_REG;
++ tmp = omap_readw(UDC_SYSCON1);
+ seq_printf(s, "\nsyscon1 %04x" EIGHTBITS "\n", tmp,
+ (tmp & UDC_CFG_LOCK) ? " cfg_lock" : "",
+ (tmp & UDC_DATA_ENDIAN) ? " data_endian" : "",
+@@ -2412,7 +2437,7 @@ static int proc_udc_show(struct seq_file *s, void *_)
+ return 0;
+ }
+
+- tmp = UDC_DEVSTAT_REG;
++ tmp = omap_readw(UDC_DEVSTAT);
+ seq_printf(s, "devstat %04x" EIGHTBITS "%s%s\n", tmp,
+ (tmp & UDC_B_HNP_ENABLE) ? " b_hnp" : "",
+ (tmp & UDC_A_HNP_SUPPORT) ? " a_hnp" : "",
+@@ -2424,20 +2449,20 @@ static int proc_udc_show(struct seq_file *s, void *_)
+ (tmp & UDC_ADD) ? " ADD" : "",
+ (tmp & UDC_DEF) ? " DEF" : "",
+ (tmp & UDC_ATT) ? " ATT" : "");
+- seq_printf(s, "sof %04x\n", UDC_SOF_REG);
+- tmp = UDC_IRQ_EN_REG;
++ seq_printf(s, "sof %04x\n", omap_readw(UDC_SOF));
++ tmp = omap_readw(UDC_IRQ_EN);
+ seq_printf(s, "irq_en %04x" FOURBITS "%s\n", tmp,
+ (tmp & UDC_SOF_IE) ? " sof" : "",
+ (tmp & UDC_EPN_RX_IE) ? " epn_rx" : "",
+ (tmp & UDC_EPN_TX_IE) ? " epn_tx" : "",
+ (tmp & UDC_DS_CHG_IE) ? " ds_chg" : "",
+ (tmp & UDC_EP0_IE) ? " ep0" : "");
+- tmp = UDC_IRQ_SRC_REG;
++ tmp = omap_readw(UDC_IRQ_SRC);
+ seq_printf(s, "irq_src %04x" EIGHTBITS "%s%s\n", tmp,
+ (tmp & UDC_TXN_DONE) ? " txn_done" : "",
+ (tmp & UDC_RXN_CNT) ? " rxn_cnt" : "",
+ (tmp & UDC_RXN_EOT) ? " rxn_eot" : "",
+- (tmp & UDC_SOF) ? " sof" : "",
++ (tmp & UDC_IRQ_SOF) ? " sof" : "",
+ (tmp & UDC_EPN_RX) ? " epn_rx" : "",
+ (tmp & UDC_EPN_TX) ? " epn_tx" : "",
+ (tmp & UDC_DS_CHG) ? " ds_chg" : "",
+@@ -2447,7 +2472,7 @@ static int proc_udc_show(struct seq_file *s, void *_)
+ if (use_dma) {
+ unsigned i;
+
+- tmp = UDC_DMA_IRQ_EN_REG;
++ tmp = omap_readw(UDC_DMA_IRQ_EN);
+ seq_printf(s, "dma_irq_en %04x%s" EIGHTBITS "\n", tmp,
+ (tmp & UDC_TX_DONE_IE(3)) ? " tx2_done" : "",
+ (tmp & UDC_RX_CNT_IE(3)) ? " rx2_cnt" : "",
+@@ -2461,29 +2486,29 @@ static int proc_udc_show(struct seq_file *s, void *_)
+ (tmp & UDC_RX_CNT_IE(1)) ? " rx0_cnt" : "",
+ (tmp & UDC_RX_EOT_IE(1)) ? " rx0_eot" : "");
+
+- tmp = UDC_RXDMA_CFG_REG;
++ tmp = omap_readw(UDC_RXDMA_CFG);
+ seq_printf(s, "rxdma_cfg %04x\n", tmp);
+ if (tmp) {
+ for (i = 0; i < 3; i++) {
+ if ((tmp & (0x0f << (i * 4))) == 0)
+ continue;
+ seq_printf(s, "rxdma[%d] %04x\n", i,
+- UDC_RXDMA_REG(i + 1));
++ omap_readw(UDC_RXDMA(i + 1)));
+ }
+ }
+- tmp = UDC_TXDMA_CFG_REG;
++ tmp = omap_readw(UDC_TXDMA_CFG);
+ seq_printf(s, "txdma_cfg %04x\n", tmp);
+ if (tmp) {
+ for (i = 0; i < 3; i++) {
+ if (!(tmp & (0x0f << (i * 4))))
+ continue;
+ seq_printf(s, "txdma[%d] %04x\n", i,
+- UDC_TXDMA_REG(i + 1));
++ omap_readw(UDC_TXDMA(i + 1)));
+ }
+ }
+ }
+
+- tmp = UDC_DEVSTAT_REG;
++ tmp = omap_readw(UDC_DEVSTAT);
+ if (tmp & UDC_ATT) {
+ proc_ep_show(s, &udc->ep[0]);
+ if (tmp & UDC_ADD) {
+@@ -2535,7 +2560,7 @@ static inline void remove_proc_file(void) {}
+ * buffer space among the endpoints we'll be operating.
+ *
+ * NOTE: as of OMAP 1710 ES2.0, writing a new endpoint config when
+- * UDC_SYSCON_1_REG.CFG_LOCK is set can now work. We won't use that
++ * UDC_SYSCON_1.CFG_LOCK is set can now work. We won't use that
+ * capability yet though.
+ */
+ static unsigned __init
+@@ -2597,9 +2622,9 @@ omap_ep_setup(char *name, u8 addr, u8 type,
+ name, addr, epn_rxtx, maxp, dbuf ? "x2" : "", buf);
+
+ if (addr & USB_DIR_IN)
+- UDC_EP_TX_REG(addr & 0xf) = epn_rxtx;
++ omap_writew(epn_rxtx, UDC_EP_TX(addr & 0xf));
+ else
+- UDC_EP_RX_REG(addr) = epn_rxtx;
++ omap_writew(epn_rxtx, UDC_EP_RX(addr));
+
+ /* next endpoint's buffer starts after this one's */
+ buf += maxp;
+@@ -2638,15 +2663,15 @@ omap_udc_setup(struct platform_device *odev, struct otg_transceiver *xceiv)
+ unsigned tmp, buf;
+
+ /* abolish any previous hardware state */
+- UDC_SYSCON1_REG = 0;
+- UDC_IRQ_EN_REG = 0;
+- UDC_IRQ_SRC_REG = UDC_IRQ_SRC_MASK;
+- UDC_DMA_IRQ_EN_REG = 0;
+- UDC_RXDMA_CFG_REG = 0;
+- UDC_TXDMA_CFG_REG = 0;
++ omap_writew(0, UDC_SYSCON1);
++ omap_writew(0, UDC_IRQ_EN);
++ omap_writew(UDC_IRQ_SRC_MASK, UDC_IRQ_SRC);
++ omap_writew(0, UDC_DMA_IRQ_EN);
++ omap_writew(0, UDC_RXDMA_CFG);
++ omap_writew(0, UDC_TXDMA_CFG);
+
+ /* UDC_PULLUP_EN gates the chip clock */
+- // OTG_SYSCON_1_REG |= DEV_IDLE_EN;
++ // OTG_SYSCON_1 |= DEV_IDLE_EN;
+
+ udc = kzalloc(sizeof(*udc), GFP_KERNEL);
+ if (!udc)
+@@ -2662,7 +2687,7 @@ omap_udc_setup(struct platform_device *odev, struct otg_transceiver *xceiv)
+ udc->gadget.name = driver_name;
+
+ device_initialize(&udc->gadget.dev);
+- strcpy (udc->gadget.dev.bus_id, "gadget");
++ dev_set_name(&udc->gadget.dev, "gadget");
+ udc->gadget.dev.release = omap_udc_release;
+ udc->gadget.dev.parent = &odev->dev;
+ if (use_dma)
+@@ -2677,8 +2702,8 @@ omap_udc_setup(struct platform_device *odev, struct otg_transceiver *xceiv)
+
+ /* initially disable all non-ep0 endpoints */
+ for (tmp = 1; tmp < 15; tmp++) {
+- UDC_EP_RX_REG(tmp) = 0;
+- UDC_EP_TX_REG(tmp) = 0;
++ omap_writew(0, UDC_EP_RX(tmp));
++ omap_writew(0, UDC_EP_TX(tmp));
+ }
+
+ #define OMAP_BULK_EP(name,addr) \
+@@ -2763,7 +2788,7 @@ omap_udc_setup(struct platform_device *odev, struct otg_transceiver *xceiv)
+ ERR("unsupported fifo_mode #%d\n", fifo_mode);
+ return -ENODEV;
+ }
+- UDC_SYSCON1_REG = UDC_CFG_LOCK|UDC_SELF_PWR;
++ omap_writew(UDC_CFG_LOCK|UDC_SELF_PWR, UDC_SYSCON1);
+ INFO("fifo mode %d, %d bytes not used\n", fifo_mode, 2048 - buf);
+ return 0;
+ }
+@@ -2807,7 +2832,7 @@ static int __init omap_udc_probe(struct platform_device *pdev)
+ }
+
+ INFO("OMAP UDC rev %d.%d%s\n",
+- UDC_REV_REG >> 4, UDC_REV_REG & 0xf,
++ omap_readw(UDC_REV) >> 4, omap_readw(UDC_REV) & 0xf,
+ config->otg ? ", Mini-AB" : "");
+
+ /* use the mode given to us by board init code */
+@@ -2822,12 +2847,12 @@ static int __init omap_udc_probe(struct platform_device *pdev)
+ * know when to turn PULLUP_EN on/off; and that
+ * means we always "need" the 48MHz clock.
+ */
+- u32 tmp = FUNC_MUX_CTRL_0_REG;
+-
+- FUNC_MUX_CTRL_0_REG &= ~VBUS_CTRL_1510;
++ u32 tmp = omap_readl(FUNC_MUX_CTRL_0);
++ tmp &= ~VBUS_CTRL_1510;
++ omap_writel(tmp, FUNC_MUX_CTRL_0);
+ tmp |= VBUS_MODE_1510;
+ tmp &= ~VBUS_CTRL_1510;
+- FUNC_MUX_CTRL_0_REG = tmp;
++ omap_writel(tmp, FUNC_MUX_CTRL_0);
+ }
+ } else {
+ /* The transceiver may package some GPIO logic or handle
+@@ -2907,7 +2932,7 @@ known:
+ #endif
+
+ /* starting with omap1710 es2.0, clear toggle is a separate bit */
+- if (UDC_REV_REG >= 0x61)
++ if (omap_readw(UDC_REV) >= 0x61)
+ udc->clr_halt = UDC_RESET_EP | UDC_CLRDATA_TOGGLE;
+ else
+ udc->clr_halt = UDC_RESET_EP;
+@@ -3005,7 +3030,7 @@ static int __exit omap_udc_remove(struct platform_device *pdev)
+ put_device(udc->transceiver->dev);
+ udc->transceiver = NULL;
+ }
+- UDC_SYSCON1_REG = 0;
++ omap_writew(0, UDC_SYSCON1);
+
+ remove_proc_file();
+
+@@ -3036,7 +3061,7 @@ static int __exit omap_udc_remove(struct platform_device *pdev)
+ *
+ * REVISIT we should probably reject suspend requests when there's a host
+ * session active, rather than disconnecting, at least on boards that can
+- * report VBUS irqs (UDC_DEVSTAT_REG.UDC_ATT). And in any case, we need to
++ * report VBUS irqs (UDC_DEVSTAT.UDC_ATT). And in any case, we need to
+ * make host resumes and VBUS detection trigger OMAP wakeup events; that
+ * may involve talking to an external transceiver (e.g. isp1301).
+ */
+@@ -3045,14 +3070,14 @@ static int omap_udc_suspend(struct platform_device *dev, pm_message_t message)
+ {
+ u32 devstat;
+
+- devstat = UDC_DEVSTAT_REG;
++ devstat = omap_readw(UDC_DEVSTAT);
+
+ /* we're requesting 48 MHz clock if the pullup is enabled
+ * (== we're attached to the host) and we're not suspended,
+ * which would prevent entry to deep sleep...
+ */
+ if ((devstat & UDC_ATT) != 0 && (devstat & UDC_SUS) == 0) {
+- WARN("session active; suspend requires disconnect\n");
++ WARNING("session active; suspend requires disconnect\n");
+ omap_pullup(&udc->gadget, 0);
+ }
+
+diff --git a/drivers/usb/gadget/omap_udc.h b/drivers/usb/gadget/omap_udc.h
+index c6b9cbc..29edc51 100644
+--- a/drivers/usb/gadget/omap_udc.h
++++ b/drivers/usb/gadget/omap_udc.h
+@@ -8,23 +8,22 @@
+ /*
+ * USB device/endpoint management registers
+ */
+-#define UDC_REG(offset) __REG16(UDC_BASE + (offset))
+
+-#define UDC_REV_REG UDC_REG(0x0) /* Revision */
+-#define UDC_EP_NUM_REG UDC_REG(0x4) /* Which endpoint */
++#define UDC_REV (UDC_BASE + 0x0) /* Revision */
++#define UDC_EP_NUM (UDC_BASE + 0x4) /* Which endpoint */
+ # define UDC_SETUP_SEL (1 << 6)
+ # define UDC_EP_SEL (1 << 5)
+ # define UDC_EP_DIR (1 << 4)
+ /* low 4 bits for endpoint number */
+-#define UDC_DATA_REG UDC_REG(0x08) /* Endpoint FIFO */
+-#define UDC_CTRL_REG UDC_REG(0x0C) /* Endpoint control */
++#define UDC_DATA (UDC_BASE + 0x08) /* Endpoint FIFO */
++#define UDC_CTRL (UDC_BASE + 0x0C) /* Endpoint control */
+ # define UDC_CLR_HALT (1 << 7)
+ # define UDC_SET_HALT (1 << 6)
+ # define UDC_CLRDATA_TOGGLE (1 << 3)
+ # define UDC_SET_FIFO_EN (1 << 2)
+ # define UDC_CLR_EP (1 << 1)
+ # define UDC_RESET_EP (1 << 0)
+-#define UDC_STAT_FLG_REG UDC_REG(0x10) /* Endpoint status */
++#define UDC_STAT_FLG (UDC_BASE + 0x10) /* Endpoint status */
+ # define UDC_NO_RXPACKET (1 << 15)
+ # define UDC_MISS_IN (1 << 14)
+ # define UDC_DATA_FLUSH (1 << 13)
+@@ -38,8 +37,8 @@
+ # define UDC_FIFO_EN (1 << 2)
+ # define UDC_NON_ISO_FIFO_EMPTY (1 << 1)
+ # define UDC_NON_ISO_FIFO_FULL (1 << 0)
+-#define UDC_RXFSTAT_REG UDC_REG(0x14) /* OUT bytecount */
+-#define UDC_SYSCON1_REG UDC_REG(0x18) /* System config 1 */
++#define UDC_RXFSTAT (UDC_BASE + 0x14) /* OUT bytecount */
++#define UDC_SYSCON1 (UDC_BASE + 0x18) /* System config 1 */
+ # define UDC_CFG_LOCK (1 << 8)
+ # define UDC_DATA_ENDIAN (1 << 7)
+ # define UDC_DMA_ENDIAN (1 << 6)
+@@ -48,12 +47,12 @@
+ # define UDC_SELF_PWR (1 << 2)
+ # define UDC_SOFF_DIS (1 << 1)
+ # define UDC_PULLUP_EN (1 << 0)
+-#define UDC_SYSCON2_REG UDC_REG(0x1C) /* System config 2 */
++#define UDC_SYSCON2 (UDC_BASE + 0x1C) /* System config 2 */
+ # define UDC_RMT_WKP (1 << 6)
+ # define UDC_STALL_CMD (1 << 5)
+ # define UDC_DEV_CFG (1 << 3)
+ # define UDC_CLR_CFG (1 << 2)
+-#define UDC_DEVSTAT_REG UDC_REG(0x20) /* Device status */
++#define UDC_DEVSTAT (UDC_BASE + 0x20) /* Device status */
+ # define UDC_B_HNP_ENABLE (1 << 9)
+ # define UDC_A_HNP_SUPPORT (1 << 8)
+ # define UDC_A_ALT_HNP_SUPPORT (1 << 7)
+@@ -64,26 +63,26 @@
+ # define UDC_ADD (1 << 2)
+ # define UDC_DEF (1 << 1)
+ # define UDC_ATT (1 << 0)
+-#define UDC_SOF_REG UDC_REG(0x24) /* Start of frame */
++#define UDC_SOF (UDC_BASE + 0x24) /* Start of frame */
+ # define UDC_FT_LOCK (1 << 12)
+ # define UDC_TS_OK (1 << 11)
+ # define UDC_TS 0x03ff
+-#define UDC_IRQ_EN_REG UDC_REG(0x28) /* Interrupt enable */
++#define UDC_IRQ_EN (UDC_BASE + 0x28) /* Interrupt enable */
+ # define UDC_SOF_IE (1 << 7)
+ # define UDC_EPN_RX_IE (1 << 5)
+ # define UDC_EPN_TX_IE (1 << 4)
+ # define UDC_DS_CHG_IE (1 << 3)
+ # define UDC_EP0_IE (1 << 0)
+-#define UDC_DMA_IRQ_EN_REG UDC_REG(0x2C) /* DMA irq enable */
++#define UDC_DMA_IRQ_EN (UDC_BASE + 0x2C) /* DMA irq enable */
+ /* rx/tx dma channels numbered 1-3 not 0-2 */
+ # define UDC_TX_DONE_IE(n) (1 << (4 * (n) - 2))
+ # define UDC_RX_CNT_IE(n) (1 << (4 * (n) - 3))
+ # define UDC_RX_EOT_IE(n) (1 << (4 * (n) - 4))
+-#define UDC_IRQ_SRC_REG UDC_REG(0x30) /* Interrupt source */
++#define UDC_IRQ_SRC (UDC_BASE + 0x30) /* Interrupt source */
+ # define UDC_TXN_DONE (1 << 10)
+ # define UDC_RXN_CNT (1 << 9)
+ # define UDC_RXN_EOT (1 << 8)
+-# define UDC_SOF (1 << 7)
++# define UDC_IRQ_SOF (1 << 7)
+ # define UDC_EPN_RX (1 << 5)
+ # define UDC_EPN_TX (1 << 4)
+ # define UDC_DS_CHG (1 << 3)
+@@ -91,41 +90,41 @@
+ # define UDC_EP0_RX (1 << 1)
+ # define UDC_EP0_TX (1 << 0)
+ # define UDC_IRQ_SRC_MASK 0x7bf
+-#define UDC_EPN_STAT_REG UDC_REG(0x34) /* EP irq status */
+-#define UDC_DMAN_STAT_REG UDC_REG(0x38) /* DMA irq status */
++#define UDC_EPN_STAT (UDC_BASE + 0x34) /* EP irq status */
++#define UDC_DMAN_STAT (UDC_BASE + 0x38) /* DMA irq status */
+ # define UDC_DMA_RX_SB (1 << 12)
+ # define UDC_DMA_RX_SRC(x) (((x)>>8) & 0xf)
+ # define UDC_DMA_TX_SRC(x) (((x)>>0) & 0xf)
+
+
+ /* DMA configuration registers: up to three channels in each direction. */
+-#define UDC_RXDMA_CFG_REG UDC_REG(0x40) /* 3 eps for RX DMA */
++#define UDC_RXDMA_CFG (UDC_BASE + 0x40) /* 3 eps for RX DMA */
+ # define UDC_DMA_REQ (1 << 12)
+-#define UDC_TXDMA_CFG_REG UDC_REG(0x44) /* 3 eps for TX DMA */
+-#define UDC_DATA_DMA_REG UDC_REG(0x48) /* rx/tx fifo addr */
++#define UDC_TXDMA_CFG (UDC_BASE + 0x44) /* 3 eps for TX DMA */
++#define UDC_DATA_DMA (UDC_BASE + 0x48) /* rx/tx fifo addr */
+
+ /* rx/tx dma control, numbering channels 1-3 not 0-2 */
+-#define UDC_TXDMA_REG(chan) UDC_REG(0x50 - 4 + 4 * (chan))
++#define UDC_TXDMA(chan) (UDC_BASE + 0x50 - 4 + 4 * (chan))
+ # define UDC_TXN_EOT (1 << 15) /* bytes vs packets */
+ # define UDC_TXN_START (1 << 14) /* start transfer */
+ # define UDC_TXN_TSC 0x03ff /* units in xfer */
+-#define UDC_RXDMA_REG(chan) UDC_REG(0x60 - 4 + 4 * (chan))
++#define UDC_RXDMA(chan) (UDC_BASE + 0x60 - 4 + 4 * (chan))
+ # define UDC_RXN_STOP (1 << 15) /* enable EOT irq */
+ # define UDC_RXN_TC 0x00ff /* packets in xfer */
+
+
+ /*
+ * Endpoint configuration registers (used before CFG_LOCK is set)
+- * UDC_EP_TX_REG(0) is unused
++ * UDC_EP_TX(0) is unused
+ */
+-#define UDC_EP_RX_REG(endpoint) UDC_REG(0x80 + (endpoint)*4)
++#define UDC_EP_RX(endpoint) (UDC_BASE + 0x80 + (endpoint)*4)
+ # define UDC_EPN_RX_VALID (1 << 15)
+ # define UDC_EPN_RX_DB (1 << 14)
+ /* buffer size in bits 13, 12 */
+ # define UDC_EPN_RX_ISO (1 << 11)
+ /* buffer pointer in low 11 bits */
+-#define UDC_EP_TX_REG(endpoint) UDC_REG(0xc0 + (endpoint)*4)
+- /* same bitfields as in RX_REG */
++#define UDC_EP_TX(endpoint) (UDC_BASE + 0xc0 + (endpoint)*4)
++ /* same bitfields as in RX */
+
+ /*-------------------------------------------------------------------------*/
+
+@@ -189,20 +188,20 @@ struct omap_udc {
+ #endif
+
+ #define ERR(stuff...) pr_err("udc: " stuff)
+-#define WARN(stuff...) pr_warning("udc: " stuff)
++#define WARNING(stuff...) pr_warning("udc: " stuff)
+ #define INFO(stuff...) pr_info("udc: " stuff)
+ #define DBG(stuff...) pr_debug("udc: " stuff)
+
+ /*-------------------------------------------------------------------------*/
+
+-#define MOD_CONF_CTRL_0_REG __REG32(MOD_CONF_CTRL_0)
+-#define VBUS_W2FC_1510 (1 << 17) /* 0 gpio0, 1 dvdd2 pin */
++/* MOD_CONF_CTRL_0 */
++#define VBUS_W2FC_1510 (1 << 17) /* 0 gpio0, 1 dvdd2 pin */
+
+-#define FUNC_MUX_CTRL_0_REG __REG32(FUNC_MUX_CTRL_0)
++/* FUNC_MUX_CTRL_0 */
+ #define VBUS_CTRL_1510 (1 << 19) /* 1 connected (software) */
+ #define VBUS_MODE_1510 (1 << 18) /* 0 hardware, 1 software */
+
+-#define HMC_1510 ((MOD_CONF_CTRL_0_REG >> 1) & 0x3f)
+-#define HMC_1610 (OTG_SYSCON_2_REG & 0x3f)
++#define HMC_1510 ((omap_readl(MOD_CONF_CTRL_0) >> 1) & 0x3f)
++#define HMC_1610 (omap_readl(OTG_SYSCON_2) & 0x3f)
+ #define HMC (cpu_is_omap15xx() ? HMC_1510 : HMC_1610)
+
+diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
+index 76be75e..e009008 100644
+--- a/drivers/usb/gadget/printer.c
++++ b/drivers/usb/gadget/printer.c
+@@ -179,7 +179,7 @@ module_param(qlen, uint, S_IRUGO|S_IWUSR);
+
+ #define ERROR(dev, fmt, args...) \
+ xprintk(dev, KERN_ERR, fmt, ## args)
+-#define WARN(dev, fmt, args...) \
++#define WARNING(dev, fmt, args...) \
+ xprintk(dev, KERN_WARNING, fmt, ## args)
+ #define INFO(dev, fmt, args...) \
+ xprintk(dev, KERN_INFO, fmt, ## args)
+@@ -462,6 +462,7 @@ printer_open(struct inode *inode, struct file *fd)
+ unsigned long flags;
+ int ret = -EBUSY;
+
++ lock_kernel();
+ dev = container_of(inode->i_cdev, struct printer_dev, printer_cdev);
+
+ spin_lock_irqsave(&dev->lock, flags);
+@@ -477,7 +478,7 @@ printer_open(struct inode *inode, struct file *fd)
+ spin_unlock_irqrestore(&dev->lock, flags);
+
+ DBG(dev, "printer_open returned %x\n", ret);
+-
++ unlock_kernel();
+ return ret;
+ }
+
+@@ -827,9 +828,8 @@ printer_poll(struct file *fd, poll_table *wait)
+ return status;
+ }
+
+-static int
+-printer_ioctl(struct inode *inode, struct file *fd, unsigned int code,
+- unsigned long arg)
++static long
++printer_ioctl(struct file *fd, unsigned int code, unsigned long arg)
+ {
+ struct printer_dev *dev = fd->private_data;
+ unsigned long flags;
+@@ -868,7 +868,7 @@ static struct file_operations printer_io_operations = {
+ .write = printer_write,
+ .fsync = printer_fsync,
+ .poll = printer_poll,
+- .ioctl = printer_ioctl,
++ .unlocked_ioctl = printer_ioctl,
+ .release = printer_close
+ };
+
+@@ -1360,8 +1360,8 @@ printer_bind(struct usb_gadget *gadget)
+
+
+ /* Setup the sysfs files for the printer gadget. */
+- dev->pdev = device_create(usb_gadget_class, NULL, g_printer_devno,
+- "g_printer");
++ dev->pdev = device_create_drvdata(usb_gadget_class, NULL,
++ g_printer_devno, NULL, "g_printer");
+ if (IS_ERR(dev->pdev)) {
+ ERROR(dev, "Failed to create device: g_printer\n");
+ goto fail;
+diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
+new file mode 100644
+index 0000000..da6e93c
+--- /dev/null
++++ b/drivers/usb/gadget/pxa25x_udc.c
+@@ -0,0 +1,2390 @@
++/*
++ * Intel PXA25x and IXP4xx on-chip full speed USB device controllers
++ *
++ * Copyright (C) 2002 Intrinsyc, Inc. (Frank Becker)
++ * Copyright (C) 2003 Robert Schwebel, Pengutronix
++ * Copyright (C) 2003 Benedikt Spranger, Pengutronix
++ * Copyright (C) 2003 David Brownell
++ * Copyright (C) 2003 Joshua Wise
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ *
++ */
++
++/* #define VERBOSE_DEBUG */
++
++#include <linux/device.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/ioport.h>
++#include <linux/types.h>
++#include <linux/errno.h>
++#include <linux/delay.h>
++#include <linux/slab.h>
++#include <linux/init.h>
++#include <linux/timer.h>
++#include <linux/list.h>
++#include <linux/interrupt.h>
++#include <linux/mm.h>
++#include <linux/platform_device.h>
++#include <linux/dma-mapping.h>
++#include <linux/irq.h>
++#include <linux/clk.h>
++#include <linux/err.h>
++#include <linux/seq_file.h>
++#include <linux/debugfs.h>
++#include <linux/io.h>
++
++#include <asm/byteorder.h>
++#include <asm/dma.h>
++#include <asm/gpio.h>
++#include <asm/system.h>
++#include <asm/mach-types.h>
++#include <asm/unaligned.h>
++
++#include <linux/usb/ch9.h>
++#include <linux/usb/gadget.h>
++
++/*
++ * This driver is PXA25x only. Grab the right register definitions.
++ */
++#ifdef CONFIG_ARCH_PXA
++#include <mach/pxa25x-udc.h>
++#endif
++
++#include <asm/mach/udc_pxa2xx.h>
++
++
++/*
++ * This driver handles the USB Device Controller (UDC) in Intel's PXA 25x
++ * series processors. The UDC for the IXP 4xx series is very similar.
++ * There are fifteen endpoints, in addition to ep0.
++ *
++ * Such controller drivers work with a gadget driver. The gadget driver
++ * returns descriptors, implements configuration and data protocols used
++ * by the host to interact with this device, and allocates endpoints to
++ * the different protocol interfaces. The controller driver virtualizes
++ * usb hardware so that the gadget drivers will be more portable.
++ *
++ * This UDC hardware wants to implement a bit too much USB protocol, so
++ * it constrains the sorts of USB configuration change events that work.
++ * The errata for these chips are misleading; some "fixed" bugs from
++ * pxa250 a0/a1 b0/b1/b2 sure act like they're still there.
++ *
++ * Note that the UDC hardware supports DMA (except on IXP) but that's
++ * not used here. IN-DMA (to host) is simple enough, when the data is
++ * suitably aligned (16 bytes) ... the network stack doesn't do that,
++ * other software can. OUT-DMA is buggy in most chip versions, as well
++ * as poorly designed (data toggle not automatic). So this driver won't
++ * bother using DMA. (Mostly-working IN-DMA support was available in
++ * kernels before 2.6.23, but was never enabled or well tested.)
++ */
++
++#define DRIVER_VERSION "30-June-2007"
++#define DRIVER_DESC "PXA 25x USB Device Controller driver"
++
++
++static const char driver_name [] = "pxa25x_udc";
++
++static const char ep0name [] = "ep0";
++
++
++#ifdef CONFIG_ARCH_IXP4XX
++
++/* cpu-specific register addresses are compiled in to this code */
++#ifdef CONFIG_ARCH_PXA
++#error "Can't configure both IXP and PXA"
++#endif
++
++/* IXP doesn't yet support <linux/clk.h> */
++#define clk_get(dev,name) NULL
++#define clk_enable(clk) do { } while (0)
++#define clk_disable(clk) do { } while (0)
++#define clk_put(clk) do { } while (0)
++
++#endif
++
++#include "pxa25x_udc.h"
++
++
++#ifdef CONFIG_USB_PXA25X_SMALL
++#define SIZE_STR " (small)"
++#else
++#define SIZE_STR ""
++#endif
++
++/* ---------------------------------------------------------------------------
++ * endpoint related parts of the api to the usb controller hardware,
++ * used by gadget driver; and the inner talker-to-hardware core.
++ * ---------------------------------------------------------------------------
++ */
++
++static void pxa25x_ep_fifo_flush (struct usb_ep *ep);
++static void nuke (struct pxa25x_ep *, int status);
++
++/* one GPIO should be used to detect VBUS from the host */
++static int is_vbus_present(void)
++{
++ struct pxa2xx_udc_mach_info *mach = the_controller->mach;
++
++ if (mach->gpio_vbus) {
++ int value = gpio_get_value(mach->gpio_vbus);
++ return mach->gpio_vbus_inverted ? !value : value;
++ }
++ if (mach->udc_is_connected)
++ return mach->udc_is_connected();
++ return 1;
++}
++
++/* one GPIO should control a D+ pullup, so host sees this device (or not) */
++static void pullup_off(void)
++{
++ struct pxa2xx_udc_mach_info *mach = the_controller->mach;
++ int off_level = mach->gpio_pullup_inverted;
++
++ if (mach->gpio_pullup)
++ gpio_set_value(mach->gpio_pullup, off_level);
++ else if (mach->udc_command)
++ mach->udc_command(PXA2XX_UDC_CMD_DISCONNECT);
++}
++
++static void pullup_on(void)
++{
++ struct pxa2xx_udc_mach_info *mach = the_controller->mach;
++ int on_level = !mach->gpio_pullup_inverted;
++
++ if (mach->gpio_pullup)
++ gpio_set_value(mach->gpio_pullup, on_level);
++ else if (mach->udc_command)
++ mach->udc_command(PXA2XX_UDC_CMD_CONNECT);
++}
++
++static void pio_irq_enable(int bEndpointAddress)
++{
++ bEndpointAddress &= 0xf;
++ if (bEndpointAddress < 8)
++ UICR0 &= ~(1 << bEndpointAddress);
++ else {
++ bEndpointAddress -= 8;
++ UICR1 &= ~(1 << bEndpointAddress);
++ }
++}
++
++static void pio_irq_disable(int bEndpointAddress)
++{
++ bEndpointAddress &= 0xf;
++ if (bEndpointAddress < 8)
++ UICR0 |= 1 << bEndpointAddress;
++ else {
++ bEndpointAddress -= 8;
++ UICR1 |= 1 << bEndpointAddress;
++ }
++}
++
++/* The UDCCR reg contains mask and interrupt status bits,
++ * so using '|=' isn't safe as it may ack an interrupt.
++ */
++#define UDCCR_MASK_BITS (UDCCR_REM | UDCCR_SRM | UDCCR_UDE)
++
++static inline void udc_set_mask_UDCCR(int mask)
++{
++ UDCCR = (UDCCR & UDCCR_MASK_BITS) | (mask & UDCCR_MASK_BITS);
++}
++
++static inline void udc_clear_mask_UDCCR(int mask)
++{
++ UDCCR = (UDCCR & UDCCR_MASK_BITS) & ~(mask & UDCCR_MASK_BITS);
++}
++
++static inline void udc_ack_int_UDCCR(int mask)
++{
++ /* udccr contains the bits we dont want to change */
++ __u32 udccr = UDCCR & UDCCR_MASK_BITS;
++
++ UDCCR = udccr | (mask & ~UDCCR_MASK_BITS);
++}
++
++/*
++ * endpoint enable/disable
++ *
++ * we need to verify the descriptors used to enable endpoints. since pxa25x
++ * endpoint configurations are fixed, and are pretty much always enabled,
++ * there's not a lot to manage here.
++ *
++ * because pxa25x can't selectively initialize bulk (or interrupt) endpoints,
++ * (resetting endpoint halt and toggle), SET_INTERFACE is unusable except
++ * for a single interface (with only the default altsetting) and for gadget
++ * drivers that don't halt endpoints (not reset by set_interface). that also
++ * means that if you use ISO, you must violate the USB spec rule that all
++ * iso endpoints must be in non-default altsettings.
++ */
++static int pxa25x_ep_enable (struct usb_ep *_ep,
++ const struct usb_endpoint_descriptor *desc)
++{
++ struct pxa25x_ep *ep;
++ struct pxa25x_udc *dev;
++
++ ep = container_of (_ep, struct pxa25x_ep, ep);
++ if (!_ep || !desc || ep->desc || _ep->name == ep0name
++ || desc->bDescriptorType != USB_DT_ENDPOINT
++ || ep->bEndpointAddress != desc->bEndpointAddress
++ || ep->fifo_size < le16_to_cpu
++ (desc->wMaxPacketSize)) {
++ DMSG("%s, bad ep or descriptor\n", __func__);
++ return -EINVAL;
++ }
++
++ /* xfer types must match, except that interrupt ~= bulk */
++ if (ep->bmAttributes != desc->bmAttributes
++ && ep->bmAttributes != USB_ENDPOINT_XFER_BULK
++ && desc->bmAttributes != USB_ENDPOINT_XFER_INT) {
++ DMSG("%s, %s type mismatch\n", __func__, _ep->name);
++ return -EINVAL;
++ }
++
++ /* hardware _could_ do smaller, but driver doesn't */
++ if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK
++ && le16_to_cpu (desc->wMaxPacketSize)
++ != BULK_FIFO_SIZE)
++ || !desc->wMaxPacketSize) {
++ DMSG("%s, bad %s maxpacket\n", __func__, _ep->name);
++ return -ERANGE;
++ }
++
++ dev = ep->dev;
++ if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
++ DMSG("%s, bogus device state\n", __func__);
++ return -ESHUTDOWN;
++ }
++
++ ep->desc = desc;
++ ep->stopped = 0;
++ ep->pio_irqs = 0;
++ ep->ep.maxpacket = le16_to_cpu (desc->wMaxPacketSize);
++
++ /* flush fifo (mostly for OUT buffers) */
++ pxa25x_ep_fifo_flush (_ep);
++
++ /* ... reset halt state too, if we could ... */
++
++ DBG(DBG_VERBOSE, "enabled %s\n", _ep->name);
++ return 0;
++}
++
++static int pxa25x_ep_disable (struct usb_ep *_ep)
++{
++ struct pxa25x_ep *ep;
++ unsigned long flags;
++
++ ep = container_of (_ep, struct pxa25x_ep, ep);
++ if (!_ep || !ep->desc) {
++ DMSG("%s, %s not enabled\n", __func__,
++ _ep ? ep->ep.name : NULL);
++ return -EINVAL;
++ }
++ local_irq_save(flags);
++
++ nuke (ep, -ESHUTDOWN);
++
++ /* flush fifo (mostly for IN buffers) */
++ pxa25x_ep_fifo_flush (_ep);
++
++ ep->desc = NULL;
++ ep->stopped = 1;
++
++ local_irq_restore(flags);
++ DBG(DBG_VERBOSE, "%s disabled\n", _ep->name);
++ return 0;
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* for the pxa25x, these can just wrap kmalloc/kfree. gadget drivers
++ * must still pass correctly initialized endpoints, since other controller
++ * drivers may care about how it's currently set up (dma issues etc).
++ */
++
++/*
++ * pxa25x_ep_alloc_request - allocate a request data structure
++ */
++static struct usb_request *
++pxa25x_ep_alloc_request (struct usb_ep *_ep, gfp_t gfp_flags)
++{
++ struct pxa25x_request *req;
++
++ req = kzalloc(sizeof(*req), gfp_flags);
++ if (!req)
++ return NULL;
++
++ INIT_LIST_HEAD (&req->queue);
++ return &req->req;
++}
++
++
++/*
++ * pxa25x_ep_free_request - deallocate a request data structure
++ */
++static void
++pxa25x_ep_free_request (struct usb_ep *_ep, struct usb_request *_req)
++{
++ struct pxa25x_request *req;
++
++ req = container_of (_req, struct pxa25x_request, req);
++ WARN_ON(!list_empty (&req->queue));
++ kfree(req);
++}
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * done - retire a request; caller blocked irqs
++ */
++static void done(struct pxa25x_ep *ep, struct pxa25x_request *req, int status)
++{
++ unsigned stopped = ep->stopped;
++
++ list_del_init(&req->queue);
++
++ if (likely (req->req.status == -EINPROGRESS))
++ req->req.status = status;
++ else
++ status = req->req.status;
++
++ if (status && status != -ESHUTDOWN)
++ DBG(DBG_VERBOSE, "complete %s req %p stat %d len %u/%u\n",
++ ep->ep.name, &req->req, status,
++ req->req.actual, req->req.length);
++
++ /* don't modify queue heads during completion callback */
++ ep->stopped = 1;
++ req->req.complete(&ep->ep, &req->req);
++ ep->stopped = stopped;
++}
++
++
++static inline void ep0_idle (struct pxa25x_udc *dev)
++{
++ dev->ep0state = EP0_IDLE;
++}
++
++static int
++write_packet(volatile u32 *uddr, struct pxa25x_request *req, unsigned max)
++{
++ u8 *buf;
++ unsigned length, count;
++
++ buf = req->req.buf + req->req.actual;
++ prefetch(buf);
++
++ /* how big will this packet be? */
++ length = min(req->req.length - req->req.actual, max);
++ req->req.actual += length;
++
++ count = length;
++ while (likely(count--))
++ *uddr = *buf++;
++
++ return length;
++}
++
++/*
++ * write to an IN endpoint fifo, as many packets as possible.
++ * irqs will use this to write the rest later.
++ * caller guarantees at least one packet buffer is ready (or a zlp).
++ */
++static int
++write_fifo (struct pxa25x_ep *ep, struct pxa25x_request *req)
++{
++ unsigned max;
++
++ max = le16_to_cpu(ep->desc->wMaxPacketSize);
++ do {
++ unsigned count;
++ int is_last, is_short;
++
++ count = write_packet(ep->reg_uddr, req, max);
++
++ /* last packet is usually short (or a zlp) */
++ if (unlikely (count != max))
++ is_last = is_short = 1;
++ else {
++ if (likely(req->req.length != req->req.actual)
++ || req->req.zero)
++ is_last = 0;
++ else
++ is_last = 1;
++ /* interrupt/iso maxpacket may not fill the fifo */
++ is_short = unlikely (max < ep->fifo_size);
++ }
++
++ DBG(DBG_VERY_NOISY, "wrote %s %d bytes%s%s %d left %p\n",
++ ep->ep.name, count,
++ is_last ? "/L" : "", is_short ? "/S" : "",
++ req->req.length - req->req.actual, req);
++
++ /* let loose that packet. maybe try writing another one,
++ * double buffering might work. TSP, TPC, and TFS
++ * bit values are the same for all normal IN endpoints.
++ */
++ *ep->reg_udccs = UDCCS_BI_TPC;
++ if (is_short)
++ *ep->reg_udccs = UDCCS_BI_TSP;
++
++ /* requests complete when all IN data is in the FIFO */
++ if (is_last) {
++ done (ep, req, 0);
++ if (list_empty(&ep->queue))
++ pio_irq_disable (ep->bEndpointAddress);
++ return 1;
++ }
++
++ // TODO experiment: how robust can fifo mode tweaking be?
++ // double buffering is off in the default fifo mode, which
++ // prevents TFS from being set here.
++
++ } while (*ep->reg_udccs & UDCCS_BI_TFS);
++ return 0;
++}
++
++/* caller asserts req->pending (ep0 irq status nyet cleared); starts
++ * ep0 data stage. these chips want very simple state transitions.
++ */
++static inline
++void ep0start(struct pxa25x_udc *dev, u32 flags, const char *tag)
++{
++ UDCCS0 = flags|UDCCS0_SA|UDCCS0_OPR;
++ USIR0 = USIR0_IR0;
++ dev->req_pending = 0;
++ DBG(DBG_VERY_NOISY, "%s %s, %02x/%02x\n",
++ __func__, tag, UDCCS0, flags);
++}
++
++static int
++write_ep0_fifo (struct pxa25x_ep *ep, struct pxa25x_request *req)
++{
++ unsigned count;
++ int is_short;
++
++ count = write_packet(&UDDR0, req, EP0_FIFO_SIZE);
++ ep->dev->stats.write.bytes += count;
++
++ /* last packet "must be" short (or a zlp) */
++ is_short = (count != EP0_FIFO_SIZE);
++
++ DBG(DBG_VERY_NOISY, "ep0in %d bytes %d left %p\n", count,
++ req->req.length - req->req.actual, req);
++
++ if (unlikely (is_short)) {
++ if (ep->dev->req_pending)
++ ep0start(ep->dev, UDCCS0_IPR, "short IN");
++ else
++ UDCCS0 = UDCCS0_IPR;
++
++ count = req->req.length;
++ done (ep, req, 0);
++ ep0_idle(ep->dev);
++#ifndef CONFIG_ARCH_IXP4XX
++#if 1
++ /* This seems to get rid of lost status irqs in some cases:
++ * host responds quickly, or next request involves config
++ * change automagic, or should have been hidden, or ...
++ *
++ * FIXME get rid of all udelays possible...
++ */
++ if (count >= EP0_FIFO_SIZE) {
++ count = 100;
++ do {
++ if ((UDCCS0 & UDCCS0_OPR) != 0) {
++ /* clear OPR, generate ack */
++ UDCCS0 = UDCCS0_OPR;
++ break;
++ }
++ count--;
++ udelay(1);
++ } while (count);
++ }
++#endif
++#endif
++ } else if (ep->dev->req_pending)
++ ep0start(ep->dev, 0, "IN");
++ return is_short;
++}
++
++
++/*
++ * read_fifo - unload packet(s) from the fifo we use for usb OUT
++ * transfers and put them into the request. caller should have made
++ * sure there's at least one packet ready.
++ *
++ * returns true if the request completed because of short packet or the
++ * request buffer having filled (and maybe overran till end-of-packet).
++ */
++static int
++read_fifo (struct pxa25x_ep *ep, struct pxa25x_request *req)
++{
++ for (;;) {
++ u32 udccs;
++ u8 *buf;
++ unsigned bufferspace, count, is_short;
++
++ /* make sure there's a packet in the FIFO.
++ * UDCCS_{BO,IO}_RPC are all the same bit value.
++ * UDCCS_{BO,IO}_RNE are all the same bit value.
++ */
++ udccs = *ep->reg_udccs;
++ if (unlikely ((udccs & UDCCS_BO_RPC) == 0))
++ break;
++ buf = req->req.buf + req->req.actual;
++ prefetchw(buf);
++ bufferspace = req->req.length - req->req.actual;
++
++ /* read all bytes from this packet */
++ if (likely (udccs & UDCCS_BO_RNE)) {
++ count = 1 + (0x0ff & *ep->reg_ubcr);
++ req->req.actual += min (count, bufferspace);
++ } else /* zlp */
++ count = 0;
++ is_short = (count < ep->ep.maxpacket);
++ DBG(DBG_VERY_NOISY, "read %s %02x, %d bytes%s req %p %d/%d\n",
++ ep->ep.name, udccs, count,
++ is_short ? "/S" : "",
++ req, req->req.actual, req->req.length);
++ while (likely (count-- != 0)) {
++ u8 byte = (u8) *ep->reg_uddr;
++
++ if (unlikely (bufferspace == 0)) {
++ /* this happens when the driver's buffer
++ * is smaller than what the host sent.
++ * discard the extra data.
++ */
++ if (req->req.status != -EOVERFLOW)
++ DMSG("%s overflow %d\n",
++ ep->ep.name, count);
++ req->req.status = -EOVERFLOW;
++ } else {
++ *buf++ = byte;
++ bufferspace--;
++ }
++ }
++ *ep->reg_udccs = UDCCS_BO_RPC;
++ /* RPC/RSP/RNE could now reflect the other packet buffer */
++
++ /* iso is one request per packet */
++ if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
++ if (udccs & UDCCS_IO_ROF)
++ req->req.status = -EHOSTUNREACH;
++ /* more like "is_done" */
++ is_short = 1;
++ }
++
++ /* completion */
++ if (is_short || req->req.actual == req->req.length) {
++ done (ep, req, 0);
++ if (list_empty(&ep->queue))
++ pio_irq_disable (ep->bEndpointAddress);
++ return 1;
++ }
++
++ /* finished that packet. the next one may be waiting... */
++ }
++ return 0;
++}
++
++/*
++ * special ep0 version of the above. no UBCR0 or double buffering; status
++ * handshaking is magic. most device protocols don't need control-OUT.
++ * CDC vendor commands (and RNDIS), mass storage CB/CBI, and some other
++ * protocols do use them.
++ */
++static int
++read_ep0_fifo (struct pxa25x_ep *ep, struct pxa25x_request *req)
++{
++ u8 *buf, byte;
++ unsigned bufferspace;
++
++ buf = req->req.buf + req->req.actual;
++ bufferspace = req->req.length - req->req.actual;
++
++ while (UDCCS0 & UDCCS0_RNE) {
++ byte = (u8) UDDR0;
++
++ if (unlikely (bufferspace == 0)) {
++ /* this happens when the driver's buffer
++ * is smaller than what the host sent.
++ * discard the extra data.
++ */
++ if (req->req.status != -EOVERFLOW)
++ DMSG("%s overflow\n", ep->ep.name);
++ req->req.status = -EOVERFLOW;
++ } else {
++ *buf++ = byte;
++ req->req.actual++;
++ bufferspace--;
++ }
++ }
++
++ UDCCS0 = UDCCS0_OPR | UDCCS0_IPR;
++
++ /* completion */
++ if (req->req.actual >= req->req.length)
++ return 1;
++
++ /* finished that packet. the next one may be waiting... */
++ return 0;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static int
++pxa25x_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
++{
++ struct pxa25x_request *req;
++ struct pxa25x_ep *ep;
++ struct pxa25x_udc *dev;
++ unsigned long flags;
++
++ req = container_of(_req, struct pxa25x_request, req);
++ if (unlikely (!_req || !_req->complete || !_req->buf
++ || !list_empty(&req->queue))) {
++ DMSG("%s, bad params\n", __func__);
++ return -EINVAL;
++ }
++
++ ep = container_of(_ep, struct pxa25x_ep, ep);
++ if (unlikely (!_ep || (!ep->desc && ep->ep.name != ep0name))) {
++ DMSG("%s, bad ep\n", __func__);
++ return -EINVAL;
++ }
++
++ dev = ep->dev;
++ if (unlikely (!dev->driver
++ || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
++ DMSG("%s, bogus device state\n", __func__);
++ return -ESHUTDOWN;
++ }
++
++ /* iso is always one packet per request, that's the only way
++ * we can report per-packet status. that also helps with dma.
++ */
++ if (unlikely (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC
++ && req->req.length > le16_to_cpu
++ (ep->desc->wMaxPacketSize)))
++ return -EMSGSIZE;
++
++ DBG(DBG_NOISY, "%s queue req %p, len %d buf %p\n",
++ _ep->name, _req, _req->length, _req->buf);
++
++ local_irq_save(flags);
++
++ _req->status = -EINPROGRESS;
++ _req->actual = 0;
++
++ /* kickstart this i/o queue? */
++ if (list_empty(&ep->queue) && !ep->stopped) {
++ if (ep->desc == NULL/* ep0 */) {
++ unsigned length = _req->length;
++
++ switch (dev->ep0state) {
++ case EP0_IN_DATA_PHASE:
++ dev->stats.write.ops++;
++ if (write_ep0_fifo(ep, req))
++ req = NULL;
++ break;
++
++ case EP0_OUT_DATA_PHASE:
++ dev->stats.read.ops++;
++ /* messy ... */
++ if (dev->req_config) {
++ DBG(DBG_VERBOSE, "ep0 config ack%s\n",
++ dev->has_cfr ? "" : " raced");
++ if (dev->has_cfr)
++ UDCCFR = UDCCFR_AREN|UDCCFR_ACM
++ |UDCCFR_MB1;
++ done(ep, req, 0);
++ dev->ep0state = EP0_END_XFER;
++ local_irq_restore (flags);
++ return 0;
++ }
++ if (dev->req_pending)
++ ep0start(dev, UDCCS0_IPR, "OUT");
++ if (length == 0 || ((UDCCS0 & UDCCS0_RNE) != 0
++ && read_ep0_fifo(ep, req))) {
++ ep0_idle(dev);
++ done(ep, req, 0);
++ req = NULL;
++ }
++ break;
++
++ default:
++ DMSG("ep0 i/o, odd state %d\n", dev->ep0state);
++ local_irq_restore (flags);
++ return -EL2HLT;
++ }
++ /* can the FIFO can satisfy the request immediately? */
++ } else if ((ep->bEndpointAddress & USB_DIR_IN) != 0) {
++ if ((*ep->reg_udccs & UDCCS_BI_TFS) != 0
++ && write_fifo(ep, req))
++ req = NULL;
++ } else if ((*ep->reg_udccs & UDCCS_BO_RFS) != 0
++ && read_fifo(ep, req)) {
++ req = NULL;
++ }
++
++ if (likely (req && ep->desc))
++ pio_irq_enable(ep->bEndpointAddress);
++ }
++
++ /* pio or dma irq handler advances the queue. */
++ if (likely(req != NULL))
++ list_add_tail(&req->queue, &ep->queue);
++ local_irq_restore(flags);
++
++ return 0;
++}
++
++
++/*
++ * nuke - dequeue ALL requests
++ */
++static void nuke(struct pxa25x_ep *ep, int status)
++{
++ struct pxa25x_request *req;
++
++ /* called with irqs blocked */
++ while (!list_empty(&ep->queue)) {
++ req = list_entry(ep->queue.next,
++ struct pxa25x_request,
++ queue);
++ done(ep, req, status);
++ }
++ if (ep->desc)
++ pio_irq_disable (ep->bEndpointAddress);
++}
++
++
++/* dequeue JUST ONE request */
++static int pxa25x_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
++{
++ struct pxa25x_ep *ep;
++ struct pxa25x_request *req;
++ unsigned long flags;
++
++ ep = container_of(_ep, struct pxa25x_ep, ep);
++ if (!_ep || ep->ep.name == ep0name)
++ return -EINVAL;
++
++ local_irq_save(flags);
++
++ /* make sure it's actually queued on this endpoint */
++ list_for_each_entry (req, &ep->queue, queue) {
++ if (&req->req == _req)
++ break;
++ }
++ if (&req->req != _req) {
++ local_irq_restore(flags);
++ return -EINVAL;
++ }
++
++ done(ep, req, -ECONNRESET);
++
++ local_irq_restore(flags);
++ return 0;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static int pxa25x_ep_set_halt(struct usb_ep *_ep, int value)
++{
++ struct pxa25x_ep *ep;
++ unsigned long flags;
++
++ ep = container_of(_ep, struct pxa25x_ep, ep);
++ if (unlikely (!_ep
++ || (!ep->desc && ep->ep.name != ep0name))
++ || ep->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
++ DMSG("%s, bad ep\n", __func__);
++ return -EINVAL;
++ }
++ if (value == 0) {
++ /* this path (reset toggle+halt) is needed to implement
++ * SET_INTERFACE on normal hardware. but it can't be
++ * done from software on the PXA UDC, and the hardware
++ * forgets to do it as part of SET_INTERFACE automagic.
++ */
++ DMSG("only host can clear %s halt\n", _ep->name);
++ return -EROFS;
++ }
++
++ local_irq_save(flags);
++
++ if ((ep->bEndpointAddress & USB_DIR_IN) != 0
++ && ((*ep->reg_udccs & UDCCS_BI_TFS) == 0
++ || !list_empty(&ep->queue))) {
++ local_irq_restore(flags);
++ return -EAGAIN;
++ }
++
++ /* FST bit is the same for control, bulk in, bulk out, interrupt in */
++ *ep->reg_udccs = UDCCS_BI_FST|UDCCS_BI_FTF;
++
++ /* ep0 needs special care */
++ if (!ep->desc) {
++ start_watchdog(ep->dev);
++ ep->dev->req_pending = 0;
++ ep->dev->ep0state = EP0_STALL;
++
++ /* and bulk/intr endpoints like dropping stalls too */
++ } else {
++ unsigned i;
++ for (i = 0; i < 1000; i += 20) {
++ if (*ep->reg_udccs & UDCCS_BI_SST)
++ break;
++ udelay(20);
++ }
++ }
++ local_irq_restore(flags);
++
++ DBG(DBG_VERBOSE, "%s halt\n", _ep->name);
++ return 0;
++}
++
++static int pxa25x_ep_fifo_status(struct usb_ep *_ep)
++{
++ struct pxa25x_ep *ep;
++
++ ep = container_of(_ep, struct pxa25x_ep, ep);
++ if (!_ep) {
++ DMSG("%s, bad ep\n", __func__);
++ return -ENODEV;
++ }
++ /* pxa can't report unclaimed bytes from IN fifos */
++ if ((ep->bEndpointAddress & USB_DIR_IN) != 0)
++ return -EOPNOTSUPP;
++ if (ep->dev->gadget.speed == USB_SPEED_UNKNOWN
++ || (*ep->reg_udccs & UDCCS_BO_RFS) == 0)
++ return 0;
++ else
++ return (*ep->reg_ubcr & 0xfff) + 1;
++}
++
++static void pxa25x_ep_fifo_flush(struct usb_ep *_ep)
++{
++ struct pxa25x_ep *ep;
++
++ ep = container_of(_ep, struct pxa25x_ep, ep);
++ if (!_ep || ep->ep.name == ep0name || !list_empty(&ep->queue)) {
++ DMSG("%s, bad ep\n", __func__);
++ return;
++ }
++
++ /* toggle and halt bits stay unchanged */
++
++ /* for OUT, just read and discard the FIFO contents. */
++ if ((ep->bEndpointAddress & USB_DIR_IN) == 0) {
++ while (((*ep->reg_udccs) & UDCCS_BO_RNE) != 0)
++ (void) *ep->reg_uddr;
++ return;
++ }
++
++ /* most IN status is the same, but ISO can't stall */
++ *ep->reg_udccs = UDCCS_BI_TPC|UDCCS_BI_FTF|UDCCS_BI_TUR
++ | (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC)
++ ? 0 : UDCCS_BI_SST;
++}
++
++
++static struct usb_ep_ops pxa25x_ep_ops = {
++ .enable = pxa25x_ep_enable,
++ .disable = pxa25x_ep_disable,
++
++ .alloc_request = pxa25x_ep_alloc_request,
++ .free_request = pxa25x_ep_free_request,
++
++ .queue = pxa25x_ep_queue,
++ .dequeue = pxa25x_ep_dequeue,
++
++ .set_halt = pxa25x_ep_set_halt,
++ .fifo_status = pxa25x_ep_fifo_status,
++ .fifo_flush = pxa25x_ep_fifo_flush,
++};
++
++
++/* ---------------------------------------------------------------------------
++ * device-scoped parts of the api to the usb controller hardware
++ * ---------------------------------------------------------------------------
++ */
++
++static int pxa25x_udc_get_frame(struct usb_gadget *_gadget)
++{
++ return ((UFNRH & 0x07) << 8) | (UFNRL & 0xff);
++}
++
++static int pxa25x_udc_wakeup(struct usb_gadget *_gadget)
++{
++ /* host may not have enabled remote wakeup */
++ if ((UDCCS0 & UDCCS0_DRWF) == 0)
++ return -EHOSTUNREACH;
++ udc_set_mask_UDCCR(UDCCR_RSM);
++ return 0;
++}
++
++static void stop_activity(struct pxa25x_udc *, struct usb_gadget_driver *);
++static void udc_enable (struct pxa25x_udc *);
++static void udc_disable(struct pxa25x_udc *);
++
++/* We disable the UDC -- and its 48 MHz clock -- whenever it's not
++ * in active use.
++ */
++static int pullup(struct pxa25x_udc *udc)
++{
++ int is_active = udc->vbus && udc->pullup && !udc->suspended;
++ DMSG("%s\n", is_active ? "active" : "inactive");
++ if (is_active) {
++ if (!udc->active) {
++ udc->active = 1;
++ /* Enable clock for USB device */
++ clk_enable(udc->clk);
++ udc_enable(udc);
++ }
++ } else {
++ if (udc->active) {
++ if (udc->gadget.speed != USB_SPEED_UNKNOWN) {
++ DMSG("disconnect %s\n", udc->driver
++ ? udc->driver->driver.name
++ : "(no driver)");
++ stop_activity(udc, udc->driver);
++ }
++ udc_disable(udc);
++ /* Disable clock for USB device */
++ clk_disable(udc->clk);
++ udc->active = 0;
++ }
++
++ }
++ return 0;
++}
++
++/* VBUS reporting logically comes from a transceiver */
++static int pxa25x_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
++{
++ struct pxa25x_udc *udc;
++
++ udc = container_of(_gadget, struct pxa25x_udc, gadget);
++ udc->vbus = (is_active != 0);
++ DMSG("vbus %s\n", is_active ? "supplied" : "inactive");
++ pullup(udc);
++ return 0;
++}
++
++/* drivers may have software control over D+ pullup */
++static int pxa25x_udc_pullup(struct usb_gadget *_gadget, int is_active)
++{
++ struct pxa25x_udc *udc;
++
++ udc = container_of(_gadget, struct pxa25x_udc, gadget);
++
++ /* not all boards support pullup control */
++ if (!udc->mach->gpio_pullup && !udc->mach->udc_command)
++ return -EOPNOTSUPP;
++
++ udc->pullup = (is_active != 0);
++ pullup(udc);
++ return 0;
++}
++
++static const struct usb_gadget_ops pxa25x_udc_ops = {
++ .get_frame = pxa25x_udc_get_frame,
++ .wakeup = pxa25x_udc_wakeup,
++ .vbus_session = pxa25x_udc_vbus_session,
++ .pullup = pxa25x_udc_pullup,
++
++ // .vbus_draw ... boards may consume current from VBUS, up to
++ // 100-500mA based on config. the 500uA suspend ceiling means
++ // that exclusively vbus-powered PXA designs violate USB specs.
++};
++
++/*-------------------------------------------------------------------------*/
++
++#ifdef CONFIG_USB_GADGET_DEBUG_FS
++
++static int
++udc_seq_show(struct seq_file *m, void *_d)
++{
++ struct pxa25x_udc *dev = m->private;
++ unsigned long flags;
++ int i;
++ u32 tmp;
++
++ local_irq_save(flags);
++
++ /* basic device status */
++ seq_printf(m, DRIVER_DESC "\n"
++ "%s version: %s\nGadget driver: %s\nHost %s\n\n",
++ driver_name, DRIVER_VERSION SIZE_STR "(pio)",
++ dev->driver ? dev->driver->driver.name : "(none)",
++ is_vbus_present() ? "full speed" : "disconnected");
++
++ /* registers for device and ep0 */
++ seq_printf(m,
++ "uicr %02X.%02X, usir %02X.%02x, ufnr %02X.%02X\n",
++ UICR1, UICR0, USIR1, USIR0, UFNRH, UFNRL);
++
++ tmp = UDCCR;
++ seq_printf(m,
++ "udccr %02X =%s%s%s%s%s%s%s%s\n", tmp,
++ (tmp & UDCCR_REM) ? " rem" : "",
++ (tmp & UDCCR_RSTIR) ? " rstir" : "",
++ (tmp & UDCCR_SRM) ? " srm" : "",
++ (tmp & UDCCR_SUSIR) ? " susir" : "",
++ (tmp & UDCCR_RESIR) ? " resir" : "",
++ (tmp & UDCCR_RSM) ? " rsm" : "",
++ (tmp & UDCCR_UDA) ? " uda" : "",
++ (tmp & UDCCR_UDE) ? " ude" : "");
++
++ tmp = UDCCS0;
++ seq_printf(m,
++ "udccs0 %02X =%s%s%s%s%s%s%s%s\n", tmp,
++ (tmp & UDCCS0_SA) ? " sa" : "",
++ (tmp & UDCCS0_RNE) ? " rne" : "",
++ (tmp & UDCCS0_FST) ? " fst" : "",
++ (tmp & UDCCS0_SST) ? " sst" : "",
++ (tmp & UDCCS0_DRWF) ? " dwrf" : "",
++ (tmp & UDCCS0_FTF) ? " ftf" : "",
++ (tmp & UDCCS0_IPR) ? " ipr" : "",
++ (tmp & UDCCS0_OPR) ? " opr" : "");
++
++ if (dev->has_cfr) {
++ tmp = UDCCFR;
++ seq_printf(m,
++ "udccfr %02X =%s%s\n", tmp,
++ (tmp & UDCCFR_AREN) ? " aren" : "",
++ (tmp & UDCCFR_ACM) ? " acm" : "");
++ }
++
++ if (!is_vbus_present() || !dev->driver)
++ goto done;
++
++ seq_printf(m, "ep0 IN %lu/%lu, OUT %lu/%lu\nirqs %lu\n\n",
++ dev->stats.write.bytes, dev->stats.write.ops,
++ dev->stats.read.bytes, dev->stats.read.ops,
++ dev->stats.irqs);
++
++ /* dump endpoint queues */
++ for (i = 0; i < PXA_UDC_NUM_ENDPOINTS; i++) {
++ struct pxa25x_ep *ep = &dev->ep [i];
++ struct pxa25x_request *req;
++
++ if (i != 0) {
++ const struct usb_endpoint_descriptor *desc;
++
++ desc = ep->desc;
++ if (!desc)
++ continue;
++ tmp = *dev->ep [i].reg_udccs;
++ seq_printf(m,
++ "%s max %d %s udccs %02x irqs %lu\n",
++ ep->ep.name, le16_to_cpu(desc->wMaxPacketSize),
++ "pio", tmp, ep->pio_irqs);
++ /* TODO translate all five groups of udccs bits! */
++
++ } else /* ep0 should only have one transfer queued */
++ seq_printf(m, "ep0 max 16 pio irqs %lu\n",
++ ep->pio_irqs);
++
++ if (list_empty(&ep->queue)) {
++ seq_printf(m, "\t(nothing queued)\n");
++ continue;
++ }
++ list_for_each_entry(req, &ep->queue, queue) {
++ seq_printf(m,
++ "\treq %p len %d/%d buf %p\n",
++ &req->req, req->req.actual,
++ req->req.length, req->req.buf);
++ }
++ }
++
++done:
++ local_irq_restore(flags);
++ return 0;
++}
++
++static int
++udc_debugfs_open(struct inode *inode, struct file *file)
++{
++ return single_open(file, udc_seq_show, inode->i_private);
++}
++
++static const struct file_operations debug_fops = {
++ .open = udc_debugfs_open,
++ .read = seq_read,
++ .llseek = seq_lseek,
++ .release = single_release,
++ .owner = THIS_MODULE,
++};
++
++#define create_debug_files(dev) \
++ do { \
++ dev->debugfs_udc = debugfs_create_file(dev->gadget.name, \
++ S_IRUGO, NULL, dev, &debug_fops); \
++ } while (0)
++#define remove_debug_files(dev) \
++ do { \
++ if (dev->debugfs_udc) \
++ debugfs_remove(dev->debugfs_udc); \
++ } while (0)
++
++#else /* !CONFIG_USB_GADGET_DEBUG_FILES */
++
++#define create_debug_files(dev) do {} while (0)
++#define remove_debug_files(dev) do {} while (0)
++
++#endif /* CONFIG_USB_GADGET_DEBUG_FILES */
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * udc_disable - disable USB device controller
++ */
++static void udc_disable(struct pxa25x_udc *dev)
++{
++ /* block all irqs */
++ udc_set_mask_UDCCR(UDCCR_SRM|UDCCR_REM);
++ UICR0 = UICR1 = 0xff;
++ UFNRH = UFNRH_SIM;
++
++ /* if hardware supports it, disconnect from usb */
++ pullup_off();
++
++ udc_clear_mask_UDCCR(UDCCR_UDE);
++
++ ep0_idle (dev);
++ dev->gadget.speed = USB_SPEED_UNKNOWN;
++}
++
++
++/*
++ * udc_reinit - initialize software state
++ */
++static void udc_reinit(struct pxa25x_udc *dev)
++{
++ u32 i;
++
++ /* device/ep0 records init */
++ INIT_LIST_HEAD (&dev->gadget.ep_list);
++ INIT_LIST_HEAD (&dev->gadget.ep0->ep_list);
++ dev->ep0state = EP0_IDLE;
++
++ /* basic endpoint records init */
++ for (i = 0; i < PXA_UDC_NUM_ENDPOINTS; i++) {
++ struct pxa25x_ep *ep = &dev->ep[i];
++
++ if (i != 0)
++ list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
++
++ ep->desc = NULL;
++ ep->stopped = 0;
++ INIT_LIST_HEAD (&ep->queue);
++ ep->pio_irqs = 0;
++ }
++
++ /* the rest was statically initialized, and is read-only */
++}
++
++/* until it's enabled, this UDC should be completely invisible
++ * to any USB host.
++ */
++static void udc_enable (struct pxa25x_udc *dev)
++{
++ udc_clear_mask_UDCCR(UDCCR_UDE);
++
++ /* try to clear these bits before we enable the udc */
++ udc_ack_int_UDCCR(UDCCR_SUSIR|/*UDCCR_RSTIR|*/UDCCR_RESIR);
++
++ ep0_idle(dev);
++ dev->gadget.speed = USB_SPEED_UNKNOWN;
++ dev->stats.irqs = 0;
++
++ /*
++ * sequence taken from chapter 12.5.10, PXA250 AppProcDevManual:
++ * - enable UDC
++ * - if RESET is already in progress, ack interrupt
++ * - unmask reset interrupt
++ */
++ udc_set_mask_UDCCR(UDCCR_UDE);
++ if (!(UDCCR & UDCCR_UDA))
++ udc_ack_int_UDCCR(UDCCR_RSTIR);
++
++ if (dev->has_cfr /* UDC_RES2 is defined */) {
++ /* pxa255 (a0+) can avoid a set_config race that could
++ * prevent gadget drivers from configuring correctly
++ */
++ UDCCFR = UDCCFR_ACM | UDCCFR_MB1;
++ } else {
++ /* "USB test mode" for pxa250 errata 40-42 (stepping a0, a1)
++ * which could result in missing packets and interrupts.
++ * supposedly one bit per endpoint, controlling whether it
++ * double buffers or not; ACM/AREN bits fit into the holes.
++ * zero bits (like USIR0_IRx) disable double buffering.
++ */
++ UDC_RES1 = 0x00;
++ UDC_RES2 = 0x00;
++ }
++
++ /* enable suspend/resume and reset irqs */
++ udc_clear_mask_UDCCR(UDCCR_SRM | UDCCR_REM);
++
++ /* enable ep0 irqs */
++ UICR0 &= ~UICR0_IM0;
++
++ /* if hardware supports it, pullup D+ and wait for reset */
++ pullup_on();
++}
++
++
++/* when a driver is successfully registered, it will receive
++ * control requests including set_configuration(), which enables
++ * non-control requests. then usb traffic follows until a
++ * disconnect is reported. then a host may connect again, or
++ * the driver might get unbound.
++ */
++int usb_gadget_register_driver(struct usb_gadget_driver *driver)
++{
++ struct pxa25x_udc *dev = the_controller;
++ int retval;
++
++ if (!driver
++ || driver->speed < USB_SPEED_FULL
++ || !driver->bind
++ || !driver->disconnect
++ || !driver->setup)
++ return -EINVAL;
++ if (!dev)
++ return -ENODEV;
++ if (dev->driver)
++ return -EBUSY;
++
++ /* first hook up the driver ... */
++ dev->driver = driver;
++ dev->gadget.dev.driver = &driver->driver;
++ dev->pullup = 1;
++
++ retval = device_add (&dev->gadget.dev);
++ if (retval) {
++fail:
++ dev->driver = NULL;
++ dev->gadget.dev.driver = NULL;
++ return retval;
++ }
++ retval = driver->bind(&dev->gadget);
++ if (retval) {
++ DMSG("bind to driver %s --> error %d\n",
++ driver->driver.name, retval);
++ device_del (&dev->gadget.dev);
++ goto fail;
++ }
++
++ /* ... then enable host detection and ep0; and we're ready
++ * for set_configuration as well as eventual disconnect.
++ */
++ DMSG("registered gadget driver '%s'\n", driver->driver.name);
++ pullup(dev);
++ dump_state(dev);
++ return 0;
++}
++EXPORT_SYMBOL(usb_gadget_register_driver);
++
++static void
++stop_activity(struct pxa25x_udc *dev, struct usb_gadget_driver *driver)
++{
++ int i;
++
++ /* don't disconnect drivers more than once */
++ if (dev->gadget.speed == USB_SPEED_UNKNOWN)
++ driver = NULL;
++ dev->gadget.speed = USB_SPEED_UNKNOWN;
++
++ /* prevent new request submissions, kill any outstanding requests */
++ for (i = 0; i < PXA_UDC_NUM_ENDPOINTS; i++) {
++ struct pxa25x_ep *ep = &dev->ep[i];
++
++ ep->stopped = 1;
++ nuke(ep, -ESHUTDOWN);
++ }
++ del_timer_sync(&dev->timer);
++
++ /* report disconnect; the driver is already quiesced */
++ if (driver)
++ driver->disconnect(&dev->gadget);
++
++ /* re-init driver-visible data structures */
++ udc_reinit(dev);
++}
++
++int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
++{
++ struct pxa25x_udc *dev = the_controller;
++
++ if (!dev)
++ return -ENODEV;
++ if (!driver || driver != dev->driver || !driver->unbind)
++ return -EINVAL;
++
++ local_irq_disable();
++ dev->pullup = 0;
++ pullup(dev);
++ stop_activity(dev, driver);
++ local_irq_enable();
++
++ driver->unbind(&dev->gadget);
++ dev->gadget.dev.driver = NULL;
++ dev->driver = NULL;
++
++ device_del (&dev->gadget.dev);
++
++ DMSG("unregistered gadget driver '%s'\n", driver->driver.name);
++ dump_state(dev);
++ return 0;
++}
++EXPORT_SYMBOL(usb_gadget_unregister_driver);
++
++
++/*-------------------------------------------------------------------------*/
++
++#ifdef CONFIG_ARCH_LUBBOCK
++
++/* Lubbock has separate connect and disconnect irqs. More typical designs
++ * use one GPIO as the VBUS IRQ, and another to control the D+ pullup.
++ */
++
++static irqreturn_t
++lubbock_vbus_irq(int irq, void *_dev)
++{
++ struct pxa25x_udc *dev = _dev;
++ int vbus;
++
++ dev->stats.irqs++;
++ switch (irq) {
++ case LUBBOCK_USB_IRQ:
++ vbus = 1;
++ disable_irq(LUBBOCK_USB_IRQ);
++ enable_irq(LUBBOCK_USB_DISC_IRQ);
++ break;
++ case LUBBOCK_USB_DISC_IRQ:
++ vbus = 0;
++ disable_irq(LUBBOCK_USB_DISC_IRQ);
++ enable_irq(LUBBOCK_USB_IRQ);
++ break;
++ default:
++ return IRQ_NONE;
++ }
++
++ pxa25x_udc_vbus_session(&dev->gadget, vbus);
++ return IRQ_HANDLED;
++}
++
++#endif
++
++static irqreturn_t udc_vbus_irq(int irq, void *_dev)
++{
++ struct pxa25x_udc *dev = _dev;
++ int vbus = gpio_get_value(dev->mach->gpio_vbus);
++
++ if (dev->mach->gpio_vbus_inverted)
++ vbus = !vbus;
++
++ pxa25x_udc_vbus_session(&dev->gadget, vbus);
++ return IRQ_HANDLED;
++}
++
++
++/*-------------------------------------------------------------------------*/
++
++static inline void clear_ep_state (struct pxa25x_udc *dev)
++{
++ unsigned i;
++
++ /* hardware SET_{CONFIGURATION,INTERFACE} automagic resets endpoint
++ * fifos, and pending transactions mustn't be continued in any case.
++ */
++ for (i = 1; i < PXA_UDC_NUM_ENDPOINTS; i++)
++ nuke(&dev->ep[i], -ECONNABORTED);
++}
++
++static void udc_watchdog(unsigned long _dev)
++{
++ struct pxa25x_udc *dev = (void *)_dev;
++
++ local_irq_disable();
++ if (dev->ep0state == EP0_STALL
++ && (UDCCS0 & UDCCS0_FST) == 0
++ && (UDCCS0 & UDCCS0_SST) == 0) {
++ UDCCS0 = UDCCS0_FST|UDCCS0_FTF;
++ DBG(DBG_VERBOSE, "ep0 re-stall\n");
++ start_watchdog(dev);
++ }
++ local_irq_enable();
++}
++
++static void handle_ep0 (struct pxa25x_udc *dev)
++{
++ u32 udccs0 = UDCCS0;
++ struct pxa25x_ep *ep = &dev->ep [0];
++ struct pxa25x_request *req;
++ union {
++ struct usb_ctrlrequest r;
++ u8 raw [8];
++ u32 word [2];
++ } u;
++
++ if (list_empty(&ep->queue))
++ req = NULL;
++ else
++ req = list_entry(ep->queue.next, struct pxa25x_request, queue);
++
++ /* clear stall status */
++ if (udccs0 & UDCCS0_SST) {
++ nuke(ep, -EPIPE);
++ UDCCS0 = UDCCS0_SST;
++ del_timer(&dev->timer);
++ ep0_idle(dev);
++ }
++
++ /* previous request unfinished? non-error iff back-to-back ... */
++ if ((udccs0 & UDCCS0_SA) != 0 && dev->ep0state != EP0_IDLE) {
++ nuke(ep, 0);
++ del_timer(&dev->timer);
++ ep0_idle(dev);
++ }
++
++ switch (dev->ep0state) {
++ case EP0_IDLE:
++ /* late-breaking status? */
++ udccs0 = UDCCS0;
++
++ /* start control request? */
++ if (likely((udccs0 & (UDCCS0_OPR|UDCCS0_SA|UDCCS0_RNE))
++ == (UDCCS0_OPR|UDCCS0_SA|UDCCS0_RNE))) {
++ int i;
++
++ nuke (ep, -EPROTO);
++
++ /* read SETUP packet */
++ for (i = 0; i < 8; i++) {
++ if (unlikely(!(UDCCS0 & UDCCS0_RNE))) {
++bad_setup:
++ DMSG("SETUP %d!\n", i);
++ goto stall;
++ }
++ u.raw [i] = (u8) UDDR0;
++ }
++ if (unlikely((UDCCS0 & UDCCS0_RNE) != 0))
++ goto bad_setup;
++
++got_setup:
++ DBG(DBG_VERBOSE, "SETUP %02x.%02x v%04x i%04x l%04x\n",
++ u.r.bRequestType, u.r.bRequest,
++ le16_to_cpu(u.r.wValue),
++ le16_to_cpu(u.r.wIndex),
++ le16_to_cpu(u.r.wLength));
++
++ /* cope with automagic for some standard requests. */
++ dev->req_std = (u.r.bRequestType & USB_TYPE_MASK)
++ == USB_TYPE_STANDARD;
++ dev->req_config = 0;
++ dev->req_pending = 1;
++ switch (u.r.bRequest) {
++ /* hardware restricts gadget drivers here! */
++ case USB_REQ_SET_CONFIGURATION:
++ if (u.r.bRequestType == USB_RECIP_DEVICE) {
++ /* reflect hardware's automagic
++ * up to the gadget driver.
++ */
++config_change:
++ dev->req_config = 1;
++ clear_ep_state(dev);
++ /* if !has_cfr, there's no synch
++ * else use AREN (later) not SA|OPR
++ * USIR0_IR0 acts edge sensitive
++ */
++ }
++ break;
++ /* ... and here, even more ... */
++ case USB_REQ_SET_INTERFACE:
++ if (u.r.bRequestType == USB_RECIP_INTERFACE) {
++ /* udc hardware is broken by design:
++ * - altsetting may only be zero;
++ * - hw resets all interfaces' eps;
++ * - ep reset doesn't include halt(?).
++ */
++ DMSG("broken set_interface (%d/%d)\n",
++ le16_to_cpu(u.r.wIndex),
++ le16_to_cpu(u.r.wValue));
++ goto config_change;
++ }
++ break;
++ /* hardware was supposed to hide this */
++ case USB_REQ_SET_ADDRESS:
++ if (u.r.bRequestType == USB_RECIP_DEVICE) {
++ ep0start(dev, 0, "address");
++ return;
++ }
++ break;
++ }
++
++ if (u.r.bRequestType & USB_DIR_IN)
++ dev->ep0state = EP0_IN_DATA_PHASE;
++ else
++ dev->ep0state = EP0_OUT_DATA_PHASE;
++
++ i = dev->driver->setup(&dev->gadget, &u.r);
++ if (i < 0) {
++ /* hardware automagic preventing STALL... */
++ if (dev->req_config) {
++ /* hardware sometimes neglects to tell
++ * tell us about config change events,
++ * so later ones may fail...
++ */
++ WARNING("config change %02x fail %d?\n",
++ u.r.bRequest, i);
++ return;
++ /* TODO experiment: if has_cfr,
++ * hardware didn't ACK; maybe we
++ * could actually STALL!
++ */
++ }
++ DBG(DBG_VERBOSE, "protocol STALL, "
++ "%02x err %d\n", UDCCS0, i);
++stall:
++ /* the watchdog timer helps deal with cases
++ * where udc seems to clear FST wrongly, and
++ * then NAKs instead of STALLing.
++ */
++ ep0start(dev, UDCCS0_FST|UDCCS0_FTF, "stall");
++ start_watchdog(dev);
++ dev->ep0state = EP0_STALL;
++
++ /* deferred i/o == no response yet */
++ } else if (dev->req_pending) {
++ if (likely(dev->ep0state == EP0_IN_DATA_PHASE
++ || dev->req_std || u.r.wLength))
++ ep0start(dev, 0, "defer");
++ else
++ ep0start(dev, UDCCS0_IPR, "defer/IPR");
++ }
++
++ /* expect at least one data or status stage irq */
++ return;
++
++ } else if (likely((udccs0 & (UDCCS0_OPR|UDCCS0_SA))
++ == (UDCCS0_OPR|UDCCS0_SA))) {
++ unsigned i;
++
++ /* pxa210/250 erratum 131 for B0/B1 says RNE lies.
++ * still observed on a pxa255 a0.
++ */
++ DBG(DBG_VERBOSE, "e131\n");
++ nuke(ep, -EPROTO);
++
++ /* read SETUP data, but don't trust it too much */
++ for (i = 0; i < 8; i++)
++ u.raw [i] = (u8) UDDR0;
++ if ((u.r.bRequestType & USB_RECIP_MASK)
++ > USB_RECIP_OTHER)
++ goto stall;
++ if (u.word [0] == 0 && u.word [1] == 0)
++ goto stall;
++ goto got_setup;
++ } else {
++ /* some random early IRQ:
++ * - we acked FST
++ * - IPR cleared
++ * - OPR got set, without SA (likely status stage)
++ */
++ UDCCS0 = udccs0 & (UDCCS0_SA|UDCCS0_OPR);
++ }
++ break;
++ case EP0_IN_DATA_PHASE: /* GET_DESCRIPTOR etc */
++ if (udccs0 & UDCCS0_OPR) {
++ UDCCS0 = UDCCS0_OPR|UDCCS0_FTF;
++ DBG(DBG_VERBOSE, "ep0in premature status\n");
++ if (req)
++ done(ep, req, 0);
++ ep0_idle(dev);
++ } else /* irq was IPR clearing */ {
++ if (req) {
++ /* this IN packet might finish the request */
++ (void) write_ep0_fifo(ep, req);
++ } /* else IN token before response was written */
++ }
++ break;
++ case EP0_OUT_DATA_PHASE: /* SET_DESCRIPTOR etc */
++ if (udccs0 & UDCCS0_OPR) {
++ if (req) {
++ /* this OUT packet might finish the request */
++ if (read_ep0_fifo(ep, req))
++ done(ep, req, 0);
++ /* else more OUT packets expected */
++ } /* else OUT token before read was issued */
++ } else /* irq was IPR clearing */ {
++ DBG(DBG_VERBOSE, "ep0out premature status\n");
++ if (req)
++ done(ep, req, 0);
++ ep0_idle(dev);
++ }
++ break;
++ case EP0_END_XFER:
++ if (req)
++ done(ep, req, 0);
++ /* ack control-IN status (maybe in-zlp was skipped)
++ * also appears after some config change events.
++ */
++ if (udccs0 & UDCCS0_OPR)
++ UDCCS0 = UDCCS0_OPR;
++ ep0_idle(dev);
++ break;
++ case EP0_STALL:
++ UDCCS0 = UDCCS0_FST;
++ break;
++ }
++ USIR0 = USIR0_IR0;
++}
++
++static void handle_ep(struct pxa25x_ep *ep)
++{
++ struct pxa25x_request *req;
++ int is_in = ep->bEndpointAddress & USB_DIR_IN;
++ int completed;
++ u32 udccs, tmp;
++
++ do {
++ completed = 0;
++ if (likely (!list_empty(&ep->queue)))
++ req = list_entry(ep->queue.next,
++ struct pxa25x_request, queue);
++ else
++ req = NULL;
++
++ // TODO check FST handling
++
++ udccs = *ep->reg_udccs;
++ if (unlikely(is_in)) { /* irq from TPC, SST, or (ISO) TUR */
++ tmp = UDCCS_BI_TUR;
++ if (likely(ep->bmAttributes == USB_ENDPOINT_XFER_BULK))
++ tmp |= UDCCS_BI_SST;
++ tmp &= udccs;
++ if (likely (tmp))
++ *ep->reg_udccs = tmp;
++ if (req && likely ((udccs & UDCCS_BI_TFS) != 0))
++ completed = write_fifo(ep, req);
++
++ } else { /* irq from RPC (or for ISO, ROF) */
++ if (likely(ep->bmAttributes == USB_ENDPOINT_XFER_BULK))
++ tmp = UDCCS_BO_SST | UDCCS_BO_DME;
++ else
++ tmp = UDCCS_IO_ROF | UDCCS_IO_DME;
++ tmp &= udccs;
++ if (likely(tmp))
++ *ep->reg_udccs = tmp;
++
++ /* fifos can hold packets, ready for reading... */
++ if (likely(req)) {
++ completed = read_fifo(ep, req);
++ } else
++ pio_irq_disable (ep->bEndpointAddress);
++ }
++ ep->pio_irqs++;
++ } while (completed);
++}
++
++/*
++ * pxa25x_udc_irq - interrupt handler
++ *
++ * avoid delays in ep0 processing. the control handshaking isn't always
++ * under software control (pxa250c0 and the pxa255 are better), and delays
++ * could cause usb protocol errors.
++ */
++static irqreturn_t
++pxa25x_udc_irq(int irq, void *_dev)
++{
++ struct pxa25x_udc *dev = _dev;
++ int handled;
++
++ dev->stats.irqs++;
++ do {
++ u32 udccr = UDCCR;
++
++ handled = 0;
++
++ /* SUSpend Interrupt Request */
++ if (unlikely(udccr & UDCCR_SUSIR)) {
++ udc_ack_int_UDCCR(UDCCR_SUSIR);
++ handled = 1;
++ DBG(DBG_VERBOSE, "USB suspend%s\n", is_vbus_present()
++ ? "" : "+disconnect");
++
++ if (!is_vbus_present())
++ stop_activity(dev, dev->driver);
++ else if (dev->gadget.speed != USB_SPEED_UNKNOWN
++ && dev->driver
++ && dev->driver->suspend)
++ dev->driver->suspend(&dev->gadget);
++ ep0_idle (dev);
++ }
++
++ /* RESume Interrupt Request */
++ if (unlikely(udccr & UDCCR_RESIR)) {
++ udc_ack_int_UDCCR(UDCCR_RESIR);
++ handled = 1;
++ DBG(DBG_VERBOSE, "USB resume\n");
++
++ if (dev->gadget.speed != USB_SPEED_UNKNOWN
++ && dev->driver
++ && dev->driver->resume
++ && is_vbus_present())
++ dev->driver->resume(&dev->gadget);
++ }
++
++ /* ReSeT Interrupt Request - USB reset */
++ if (unlikely(udccr & UDCCR_RSTIR)) {
++ udc_ack_int_UDCCR(UDCCR_RSTIR);
++ handled = 1;
++
++ if ((UDCCR & UDCCR_UDA) == 0) {
++ DBG(DBG_VERBOSE, "USB reset start\n");
++
++ /* reset driver and endpoints,
++ * in case that's not yet done
++ */
++ stop_activity (dev, dev->driver);
++
++ } else {
++ DBG(DBG_VERBOSE, "USB reset end\n");
++ dev->gadget.speed = USB_SPEED_FULL;
++ memset(&dev->stats, 0, sizeof dev->stats);
++ /* driver and endpoints are still reset */
++ }
++
++ } else {
++ u32 usir0 = USIR0 & ~UICR0;
++ u32 usir1 = USIR1 & ~UICR1;
++ int i;
++
++ if (unlikely (!usir0 && !usir1))
++ continue;
++
++ DBG(DBG_VERY_NOISY, "irq %02x.%02x\n", usir1, usir0);
++
++ /* control traffic */
++ if (usir0 & USIR0_IR0) {
++ dev->ep[0].pio_irqs++;
++ handle_ep0(dev);
++ handled = 1;
++ }
++
++ /* endpoint data transfers */
++ for (i = 0; i < 8; i++) {
++ u32 tmp = 1 << i;
++
++ if (i && (usir0 & tmp)) {
++ handle_ep(&dev->ep[i]);
++ USIR0 |= tmp;
++ handled = 1;
++ }
++ if (usir1 & tmp) {
++ handle_ep(&dev->ep[i+8]);
++ USIR1 |= tmp;
++ handled = 1;
++ }
++ }
++ }
++
++ /* we could also ask for 1 msec SOF (SIR) interrupts */
++
++ } while (handled);
++ return IRQ_HANDLED;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static void nop_release (struct device *dev)
++{
++ DMSG("%s %s\n", __func__, dev_name(dev));
++}
++
++/* this uses load-time allocation and initialization (instead of
++ * doing it at run-time) to save code, eliminate fault paths, and
++ * be more obviously correct.
++ */
++static struct pxa25x_udc memory = {
++ .gadget = {
++ .ops = &pxa25x_udc_ops,
++ .ep0 = &memory.ep[0].ep,
++ .name = driver_name,
++ .dev = {
++ .bus_id = "gadget",
++ .release = nop_release,
++ },
++ },
++
++ /* control endpoint */
++ .ep[0] = {
++ .ep = {
++ .name = ep0name,
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = EP0_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .reg_udccs = &UDCCS0,
++ .reg_uddr = &UDDR0,
++ },
++
++ /* first group of endpoints */
++ .ep[1] = {
++ .ep = {
++ .name = "ep1in-bulk",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = BULK_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = BULK_FIFO_SIZE,
++ .bEndpointAddress = USB_DIR_IN | 1,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .reg_udccs = &UDCCS1,
++ .reg_uddr = &UDDR1,
++ },
++ .ep[2] = {
++ .ep = {
++ .name = "ep2out-bulk",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = BULK_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = BULK_FIFO_SIZE,
++ .bEndpointAddress = 2,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .reg_udccs = &UDCCS2,
++ .reg_ubcr = &UBCR2,
++ .reg_uddr = &UDDR2,
++ },
++#ifndef CONFIG_USB_PXA25X_SMALL
++ .ep[3] = {
++ .ep = {
++ .name = "ep3in-iso",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = ISO_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = ISO_FIFO_SIZE,
++ .bEndpointAddress = USB_DIR_IN | 3,
++ .bmAttributes = USB_ENDPOINT_XFER_ISOC,
++ .reg_udccs = &UDCCS3,
++ .reg_uddr = &UDDR3,
++ },
++ .ep[4] = {
++ .ep = {
++ .name = "ep4out-iso",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = ISO_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = ISO_FIFO_SIZE,
++ .bEndpointAddress = 4,
++ .bmAttributes = USB_ENDPOINT_XFER_ISOC,
++ .reg_udccs = &UDCCS4,
++ .reg_ubcr = &UBCR4,
++ .reg_uddr = &UDDR4,
++ },
++ .ep[5] = {
++ .ep = {
++ .name = "ep5in-int",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = INT_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = INT_FIFO_SIZE,
++ .bEndpointAddress = USB_DIR_IN | 5,
++ .bmAttributes = USB_ENDPOINT_XFER_INT,
++ .reg_udccs = &UDCCS5,
++ .reg_uddr = &UDDR5,
++ },
++
++ /* second group of endpoints */
++ .ep[6] = {
++ .ep = {
++ .name = "ep6in-bulk",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = BULK_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = BULK_FIFO_SIZE,
++ .bEndpointAddress = USB_DIR_IN | 6,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .reg_udccs = &UDCCS6,
++ .reg_uddr = &UDDR6,
++ },
++ .ep[7] = {
++ .ep = {
++ .name = "ep7out-bulk",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = BULK_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = BULK_FIFO_SIZE,
++ .bEndpointAddress = 7,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .reg_udccs = &UDCCS7,
++ .reg_ubcr = &UBCR7,
++ .reg_uddr = &UDDR7,
++ },
++ .ep[8] = {
++ .ep = {
++ .name = "ep8in-iso",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = ISO_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = ISO_FIFO_SIZE,
++ .bEndpointAddress = USB_DIR_IN | 8,
++ .bmAttributes = USB_ENDPOINT_XFER_ISOC,
++ .reg_udccs = &UDCCS8,
++ .reg_uddr = &UDDR8,
++ },
++ .ep[9] = {
++ .ep = {
++ .name = "ep9out-iso",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = ISO_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = ISO_FIFO_SIZE,
++ .bEndpointAddress = 9,
++ .bmAttributes = USB_ENDPOINT_XFER_ISOC,
++ .reg_udccs = &UDCCS9,
++ .reg_ubcr = &UBCR9,
++ .reg_uddr = &UDDR9,
++ },
++ .ep[10] = {
++ .ep = {
++ .name = "ep10in-int",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = INT_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = INT_FIFO_SIZE,
++ .bEndpointAddress = USB_DIR_IN | 10,
++ .bmAttributes = USB_ENDPOINT_XFER_INT,
++ .reg_udccs = &UDCCS10,
++ .reg_uddr = &UDDR10,
++ },
++
++ /* third group of endpoints */
++ .ep[11] = {
++ .ep = {
++ .name = "ep11in-bulk",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = BULK_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = BULK_FIFO_SIZE,
++ .bEndpointAddress = USB_DIR_IN | 11,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .reg_udccs = &UDCCS11,
++ .reg_uddr = &UDDR11,
++ },
++ .ep[12] = {
++ .ep = {
++ .name = "ep12out-bulk",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = BULK_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = BULK_FIFO_SIZE,
++ .bEndpointAddress = 12,
++ .bmAttributes = USB_ENDPOINT_XFER_BULK,
++ .reg_udccs = &UDCCS12,
++ .reg_ubcr = &UBCR12,
++ .reg_uddr = &UDDR12,
++ },
++ .ep[13] = {
++ .ep = {
++ .name = "ep13in-iso",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = ISO_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = ISO_FIFO_SIZE,
++ .bEndpointAddress = USB_DIR_IN | 13,
++ .bmAttributes = USB_ENDPOINT_XFER_ISOC,
++ .reg_udccs = &UDCCS13,
++ .reg_uddr = &UDDR13,
++ },
++ .ep[14] = {
++ .ep = {
++ .name = "ep14out-iso",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = ISO_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = ISO_FIFO_SIZE,
++ .bEndpointAddress = 14,
++ .bmAttributes = USB_ENDPOINT_XFER_ISOC,
++ .reg_udccs = &UDCCS14,
++ .reg_ubcr = &UBCR14,
++ .reg_uddr = &UDDR14,
++ },
++ .ep[15] = {
++ .ep = {
++ .name = "ep15in-int",
++ .ops = &pxa25x_ep_ops,
++ .maxpacket = INT_FIFO_SIZE,
++ },
++ .dev = &memory,
++ .fifo_size = INT_FIFO_SIZE,
++ .bEndpointAddress = USB_DIR_IN | 15,
++ .bmAttributes = USB_ENDPOINT_XFER_INT,
++ .reg_udccs = &UDCCS15,
++ .reg_uddr = &UDDR15,
++ },
++#endif /* !CONFIG_USB_PXA25X_SMALL */
++};
++
++#define CP15R0_VENDOR_MASK 0xffffe000
++
++#if defined(CONFIG_ARCH_PXA)
++#define CP15R0_XSCALE_VALUE 0x69052000 /* intel/arm/xscale */
++
++#elif defined(CONFIG_ARCH_IXP4XX)
++#define CP15R0_XSCALE_VALUE 0x69054000 /* intel/arm/ixp4xx */
++
++#endif
++
++#define CP15R0_PROD_MASK 0x000003f0
++#define PXA25x 0x00000100 /* and PXA26x */
++#define PXA210 0x00000120
++
++#define CP15R0_REV_MASK 0x0000000f
++
++#define CP15R0_PRODREV_MASK (CP15R0_PROD_MASK | CP15R0_REV_MASK)
++
++#define PXA255_A0 0x00000106 /* or PXA260_B1 */
++#define PXA250_C0 0x00000105 /* or PXA26x_B0 */
++#define PXA250_B2 0x00000104
++#define PXA250_B1 0x00000103 /* or PXA260_A0 */
++#define PXA250_B0 0x00000102
++#define PXA250_A1 0x00000101
++#define PXA250_A0 0x00000100
++
++#define PXA210_C0 0x00000125
++#define PXA210_B2 0x00000124
++#define PXA210_B1 0x00000123
++#define PXA210_B0 0x00000122
++#define IXP425_A0 0x000001c1
++#define IXP425_B0 0x000001f1
++#define IXP465_AD 0x00000200
++
++/*
++ * probe - binds to the platform device
++ */
++static int __init pxa25x_udc_probe(struct platform_device *pdev)
++{
++ struct pxa25x_udc *dev = &memory;
++ int retval, vbus_irq, irq;
++ u32 chiprev;
++
++ /* insist on Intel/ARM/XScale */
++ asm("mrc%? p15, 0, %0, c0, c0" : "=r" (chiprev));
++ if ((chiprev & CP15R0_VENDOR_MASK) != CP15R0_XSCALE_VALUE) {
++ pr_err("%s: not XScale!\n", driver_name);
++ return -ENODEV;
++ }
++
++ /* trigger chiprev-specific logic */
++ switch (chiprev & CP15R0_PRODREV_MASK) {
++#if defined(CONFIG_ARCH_PXA)
++ case PXA255_A0:
++ dev->has_cfr = 1;
++ break;
++ case PXA250_A0:
++ case PXA250_A1:
++ /* A0/A1 "not released"; ep 13, 15 unusable */
++ /* fall through */
++ case PXA250_B2: case PXA210_B2:
++ case PXA250_B1: case PXA210_B1:
++ case PXA250_B0: case PXA210_B0:
++ /* OUT-DMA is broken ... */
++ /* fall through */
++ case PXA250_C0: case PXA210_C0:
++ break;
++#elif defined(CONFIG_ARCH_IXP4XX)
++ case IXP425_A0:
++ case IXP425_B0:
++ case IXP465_AD:
++ dev->has_cfr = 1;
++ break;
++#endif
++ default:
++ pr_err("%s: unrecognized processor: %08x\n",
++ driver_name, chiprev);
++ /* iop3xx, ixp4xx, ... */
++ return -ENODEV;
++ }
++
++ irq = platform_get_irq(pdev, 0);
++ if (irq < 0)
++ return -ENODEV;
++
++ dev->clk = clk_get(&pdev->dev, "UDCCLK");
++ if (IS_ERR(dev->clk)) {
++ retval = PTR_ERR(dev->clk);
++ goto err_clk;
++ }
++
++ pr_debug("%s: IRQ %d%s%s\n", driver_name, irq,
++ dev->has_cfr ? "" : " (!cfr)",
++ SIZE_STR "(pio)"
++ );
++
++ /* other non-static parts of init */
++ dev->dev = &pdev->dev;
++ dev->mach = pdev->dev.platform_data;
++
++ if (dev->mach->gpio_vbus) {
++ if ((retval = gpio_request(dev->mach->gpio_vbus,
++ "pxa25x_udc GPIO VBUS"))) {
++ dev_dbg(&pdev->dev,
++ "can't get vbus gpio %d, err: %d\n",
++ dev->mach->gpio_vbus, retval);
++ goto err_gpio_vbus;
++ }
++ gpio_direction_input(dev->mach->gpio_vbus);
++ vbus_irq = gpio_to_irq(dev->mach->gpio_vbus);
++ } else
++ vbus_irq = 0;
++
++ if (dev->mach->gpio_pullup) {
++ if ((retval = gpio_request(dev->mach->gpio_pullup,
++ "pca25x_udc GPIO PULLUP"))) {
++ dev_dbg(&pdev->dev,
++ "can't get pullup gpio %d, err: %d\n",
++ dev->mach->gpio_pullup, retval);
++ goto err_gpio_pullup;
++ }
++ gpio_direction_output(dev->mach->gpio_pullup, 0);
++ }
++
++ init_timer(&dev->timer);
++ dev->timer.function = udc_watchdog;
++ dev->timer.data = (unsigned long) dev;
++
++ device_initialize(&dev->gadget.dev);
++ dev->gadget.dev.parent = &pdev->dev;
++ dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
++
++ the_controller = dev;
++ platform_set_drvdata(pdev, dev);
++
++ udc_disable(dev);
++ udc_reinit(dev);
++
++ dev->vbus = is_vbus_present();
++
++ /* irq setup after old hardware state is cleaned up */
++ retval = request_irq(irq, pxa25x_udc_irq,
++ IRQF_DISABLED, driver_name, dev);
++ if (retval != 0) {
++ pr_err("%s: can't get irq %d, err %d\n",
++ driver_name, irq, retval);
++ goto err_irq1;
++ }
++ dev->got_irq = 1;
++
++#ifdef CONFIG_ARCH_LUBBOCK
++ if (machine_is_lubbock()) {
++ retval = request_irq(LUBBOCK_USB_DISC_IRQ,
++ lubbock_vbus_irq,
++ IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
++ driver_name, dev);
++ if (retval != 0) {
++ pr_err("%s: can't get irq %i, err %d\n",
++ driver_name, LUBBOCK_USB_DISC_IRQ, retval);
++lubbock_fail0:
++ goto err_irq_lub;
++ }
++ retval = request_irq(LUBBOCK_USB_IRQ,
++ lubbock_vbus_irq,
++ IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
++ driver_name, dev);
++ if (retval != 0) {
++ pr_err("%s: can't get irq %i, err %d\n",
++ driver_name, LUBBOCK_USB_IRQ, retval);
++ free_irq(LUBBOCK_USB_DISC_IRQ, dev);
++ goto lubbock_fail0;
++ }
++ } else
++#endif
++ if (vbus_irq) {
++ retval = request_irq(vbus_irq, udc_vbus_irq,
++ IRQF_DISABLED | IRQF_SAMPLE_RANDOM |
++ IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
++ driver_name, dev);
++ if (retval != 0) {
++ pr_err("%s: can't get irq %i, err %d\n",
++ driver_name, vbus_irq, retval);
++ goto err_vbus_irq;
++ }
++ }
++ create_debug_files(dev);
++
++ return 0;
++
++ err_vbus_irq:
++#ifdef CONFIG_ARCH_LUBBOCK
++ free_irq(LUBBOCK_USB_DISC_IRQ, dev);
++ err_irq_lub:
++#endif
++ free_irq(irq, dev);
++ err_irq1:
++ if (dev->mach->gpio_pullup)
++ gpio_free(dev->mach->gpio_pullup);
++ err_gpio_pullup:
++ if (dev->mach->gpio_vbus)
++ gpio_free(dev->mach->gpio_vbus);
++ err_gpio_vbus:
++ clk_put(dev->clk);
++ err_clk:
++ return retval;
++}
++
++static void pxa25x_udc_shutdown(struct platform_device *_dev)
++{
++ pullup_off();
++}
++
++static int __exit pxa25x_udc_remove(struct platform_device *pdev)
++{
++ struct pxa25x_udc *dev = platform_get_drvdata(pdev);
++
++ if (dev->driver)
++ return -EBUSY;
++
++ dev->pullup = 0;
++ pullup(dev);
++
++ remove_debug_files(dev);
++
++ if (dev->got_irq) {
++ free_irq(platform_get_irq(pdev, 0), dev);
++ dev->got_irq = 0;
++ }
++#ifdef CONFIG_ARCH_LUBBOCK
++ if (machine_is_lubbock()) {
++ free_irq(LUBBOCK_USB_DISC_IRQ, dev);
++ free_irq(LUBBOCK_USB_IRQ, dev);
++ }
++#endif
++ if (dev->mach->gpio_vbus) {
++ free_irq(gpio_to_irq(dev->mach->gpio_vbus), dev);
++ gpio_free(dev->mach->gpio_vbus);
++ }
++ if (dev->mach->gpio_pullup)
++ gpio_free(dev->mach->gpio_pullup);
++
++ clk_put(dev->clk);
++
++ platform_set_drvdata(pdev, NULL);
++ the_controller = NULL;
++ return 0;
++}
++
++/*-------------------------------------------------------------------------*/
++
++#ifdef CONFIG_PM
++
++/* USB suspend (controlled by the host) and system suspend (controlled
++ * by the PXA) don't necessarily work well together. If USB is active,
++ * the 48 MHz clock is required; so the system can't enter 33 MHz idle
++ * mode, or any deeper PM saving state.
++ *
++ * For now, we punt and forcibly disconnect from the USB host when PXA
++ * enters any suspend state. While we're disconnected, we always disable
++ * the 48MHz USB clock ... allowing PXA sleep and/or 33 MHz idle states.
++ * Boards without software pullup control shouldn't use those states.
++ * VBUS IRQs should probably be ignored so that the PXA device just acts
++ * "dead" to USB hosts until system resume.
++ */
++static int pxa25x_udc_suspend(struct platform_device *dev, pm_message_t state)
++{
++ struct pxa25x_udc *udc = platform_get_drvdata(dev);
++ unsigned long flags;
++
++ if (!udc->mach->gpio_pullup && !udc->mach->udc_command)
++ WARNING("USB host won't detect disconnect!\n");
++ udc->suspended = 1;
++
++ local_irq_save(flags);
++ pullup(udc);
++ local_irq_restore(flags);
++
++ return 0;
++}
++
++static int pxa25x_udc_resume(struct platform_device *dev)
++{
++ struct pxa25x_udc *udc = platform_get_drvdata(dev);
++ unsigned long flags;
++
++ udc->suspended = 0;
++ local_irq_save(flags);
++ pullup(udc);
++ local_irq_restore(flags);
++
++ return 0;
++}
++
++#else
++#define pxa25x_udc_suspend NULL
++#define pxa25x_udc_resume NULL
++#endif
++
++/*-------------------------------------------------------------------------*/
++
++static struct platform_driver udc_driver = {
++ .shutdown = pxa25x_udc_shutdown,
++ .remove = __exit_p(pxa25x_udc_remove),
++ .suspend = pxa25x_udc_suspend,
++ .resume = pxa25x_udc_resume,
++ .driver = {
++ .owner = THIS_MODULE,
++ .name = "pxa25x-udc",
++ },
++};
++
++static int __init udc_init(void)
++{
++ pr_info("%s: version %s\n", driver_name, DRIVER_VERSION);
++ return platform_driver_probe(&udc_driver, pxa25x_udc_probe);
++}
++module_init(udc_init);
++
++static void __exit udc_exit(void)
++{
++ platform_driver_unregister(&udc_driver);
++}
++module_exit(udc_exit);
++
++MODULE_DESCRIPTION(DRIVER_DESC);
++MODULE_AUTHOR("Frank Becker, Robert Schwebel, David Brownell");
++MODULE_LICENSE("GPL");
++MODULE_ALIAS("platform:pxa25x-udc");
+diff --git a/drivers/usb/gadget/pxa25x_udc.h b/drivers/usb/gadget/pxa25x_udc.h
+new file mode 100644
+index 0000000..1d51aa2
+--- /dev/null
++++ b/drivers/usb/gadget/pxa25x_udc.h
+@@ -0,0 +1,266 @@
++/*
++ * Intel PXA25x on-chip full speed USB device controller
++ *
++ * Copyright (C) 2003 Robert Schwebel <r.schwebel@pengutronix.de>, Pengutronix
++ * Copyright (C) 2003 David Brownell
++ *
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++#ifndef __LINUX_USB_GADGET_PXA25X_H
++#define __LINUX_USB_GADGET_PXA25X_H
++
++#include <linux/types.h>
++
++/*-------------------------------------------------------------------------*/
++
++/* pxa25x has this (move to include/asm-arm/arch-pxa/pxa-regs.h) */
++#define UFNRH_SIR (1 << 7) /* SOF interrupt request */
++#define UFNRH_SIM (1 << 6) /* SOF interrupt mask */
++#define UFNRH_IPE14 (1 << 5) /* ISO packet error, ep14 */
++#define UFNRH_IPE9 (1 << 4) /* ISO packet error, ep9 */
++#define UFNRH_IPE4 (1 << 3) /* ISO packet error, ep4 */
++
++/* pxa255 has this (move to include/asm-arm/arch-pxa/pxa-regs.h) */
++#define UDCCFR UDC_RES2 /* UDC Control Function Register */
++#define UDCCFR_AREN (1 << 7) /* ACK response enable (now) */
++#define UDCCFR_ACM (1 << 2) /* ACK control mode (wait for AREN) */
++
++/* latest pxa255 errata define new "must be one" bits in UDCCFR */
++#define UDCCFR_MB1 (0xff & ~(UDCCFR_AREN|UDCCFR_ACM))
++
++/*-------------------------------------------------------------------------*/
++
++struct pxa25x_udc;
++
++struct pxa25x_ep {
++ struct usb_ep ep;
++ struct pxa25x_udc *dev;
++
++ const struct usb_endpoint_descriptor *desc;
++ struct list_head queue;
++ unsigned long pio_irqs;
++
++ unsigned short fifo_size;
++ u8 bEndpointAddress;
++ u8 bmAttributes;
++
++ unsigned stopped : 1;
++ unsigned dma_fixup : 1;
++
++ /* UDCCS = UDC Control/Status for this EP
++ * UBCR = UDC Byte Count Remaining (contents of OUT fifo)
++ * UDDR = UDC Endpoint Data Register (the fifo)
++ * DRCM = DMA Request Channel Map
++ */
++ volatile u32 *reg_udccs;
++ volatile u32 *reg_ubcr;
++ volatile u32 *reg_uddr;
++};
++
++struct pxa25x_request {
++ struct usb_request req;
++ struct list_head queue;
++};
++
++enum ep0_state {
++ EP0_IDLE,
++ EP0_IN_DATA_PHASE,
++ EP0_OUT_DATA_PHASE,
++ EP0_END_XFER,
++ EP0_STALL,
++};
++
++#define EP0_FIFO_SIZE ((unsigned)16)
++#define BULK_FIFO_SIZE ((unsigned)64)
++#define ISO_FIFO_SIZE ((unsigned)256)
++#define INT_FIFO_SIZE ((unsigned)8)
++
++struct udc_stats {
++ struct ep0stats {
++ unsigned long ops;
++ unsigned long bytes;
++ } read, write;
++ unsigned long irqs;
++};
++
++#ifdef CONFIG_USB_PXA25X_SMALL
++/* when memory's tight, SMALL config saves code+data. */
++#define PXA_UDC_NUM_ENDPOINTS 3
++#endif
++
++#ifndef PXA_UDC_NUM_ENDPOINTS
++#define PXA_UDC_NUM_ENDPOINTS 16
++#endif
++
++struct pxa25x_udc {
++ struct usb_gadget gadget;
++ struct usb_gadget_driver *driver;
++
++ enum ep0_state ep0state;
++ struct udc_stats stats;
++ unsigned got_irq : 1,
++ vbus : 1,
++ pullup : 1,
++ has_cfr : 1,
++ req_pending : 1,
++ req_std : 1,
++ req_config : 1,
++ suspended : 1,
++ active : 1;
++
++#define start_watchdog(dev) mod_timer(&dev->timer, jiffies + (HZ/200))
++ struct timer_list timer;
++
++ struct device *dev;
++ struct clk *clk;
++ struct pxa2xx_udc_mach_info *mach;
++ u64 dma_mask;
++ struct pxa25x_ep ep [PXA_UDC_NUM_ENDPOINTS];
++
++#ifdef CONFIG_USB_GADGET_DEBUG_FS
++ struct dentry *debugfs_udc;
++#endif
++};
++
++/*-------------------------------------------------------------------------*/
++
++#ifdef CONFIG_ARCH_LUBBOCK
++#include <mach/lubbock.h>
++/* lubbock can also report usb connect/disconnect irqs */
++#endif
++
++static struct pxa25x_udc *the_controller;
++
++/*-------------------------------------------------------------------------*/
++
++/*
++ * Debugging support vanishes in non-debug builds. DBG_NORMAL should be
++ * mostly silent during normal use/testing, with no timing side-effects.
++ */
++#define DBG_NORMAL 1 /* error paths, device state transitions */
++#define DBG_VERBOSE 2 /* add some success path trace info */
++#define DBG_NOISY 3 /* ... even more: request level */
++#define DBG_VERY_NOISY 4 /* ... even more: packet level */
++
++#define DMSG(stuff...) pr_debug("udc: " stuff)
++
++#ifdef DEBUG
++
++static int is_vbus_present(void);
++
++static const char *state_name[] = {
++ "EP0_IDLE",
++ "EP0_IN_DATA_PHASE", "EP0_OUT_DATA_PHASE",
++ "EP0_END_XFER", "EP0_STALL"
++};
++
++#ifdef VERBOSE_DEBUG
++# define UDC_DEBUG DBG_VERBOSE
++#else
++# define UDC_DEBUG DBG_NORMAL
++#endif
++
++static void __maybe_unused
++dump_udccr(const char *label)
++{
++ u32 udccr = UDCCR;
++ DMSG("%s %02X =%s%s%s%s%s%s%s%s\n",
++ label, udccr,
++ (udccr & UDCCR_REM) ? " rem" : "",
++ (udccr & UDCCR_RSTIR) ? " rstir" : "",
++ (udccr & UDCCR_SRM) ? " srm" : "",
++ (udccr & UDCCR_SUSIR) ? " susir" : "",
++ (udccr & UDCCR_RESIR) ? " resir" : "",
++ (udccr & UDCCR_RSM) ? " rsm" : "",
++ (udccr & UDCCR_UDA) ? " uda" : "",
++ (udccr & UDCCR_UDE) ? " ude" : "");
++}
++
++static void __maybe_unused
++dump_udccs0(const char *label)
++{
++ u32 udccs0 = UDCCS0;
++
++ DMSG("%s %s %02X =%s%s%s%s%s%s%s%s\n",
++ label, state_name[the_controller->ep0state], udccs0,
++ (udccs0 & UDCCS0_SA) ? " sa" : "",
++ (udccs0 & UDCCS0_RNE) ? " rne" : "",
++ (udccs0 & UDCCS0_FST) ? " fst" : "",
++ (udccs0 & UDCCS0_SST) ? " sst" : "",
++ (udccs0 & UDCCS0_DRWF) ? " dwrf" : "",
++ (udccs0 & UDCCS0_FTF) ? " ftf" : "",
++ (udccs0 & UDCCS0_IPR) ? " ipr" : "",
++ (udccs0 & UDCCS0_OPR) ? " opr" : "");
++}
++
++static void __maybe_unused
++dump_state(struct pxa25x_udc *dev)
++{
++ u32 tmp;
++ unsigned i;
++
++ DMSG("%s %s, uicr %02X.%02X, usir %02X.%02x, ufnr %02X.%02X\n",
++ is_vbus_present() ? "host " : "disconnected",
++ state_name[dev->ep0state],
++ UICR1, UICR0, USIR1, USIR0, UFNRH, UFNRL);
++ dump_udccr("udccr");
++ if (dev->has_cfr) {
++ tmp = UDCCFR;
++ DMSG("udccfr %02X =%s%s\n", tmp,
++ (tmp & UDCCFR_AREN) ? " aren" : "",
++ (tmp & UDCCFR_ACM) ? " acm" : "");
++ }
++
++ if (!dev->driver) {
++ DMSG("no gadget driver bound\n");
++ return;
++ } else
++ DMSG("ep0 driver '%s'\n", dev->driver->driver.name);
++
++ if (!is_vbus_present())
++ return;
++
++ dump_udccs0 ("udccs0");
++ DMSG("ep0 IN %lu/%lu, OUT %lu/%lu\n",
++ dev->stats.write.bytes, dev->stats.write.ops,
++ dev->stats.read.bytes, dev->stats.read.ops);
++
++ for (i = 1; i < PXA_UDC_NUM_ENDPOINTS; i++) {
++ if (dev->ep [i].desc == NULL)
++ continue;
++ DMSG ("udccs%d = %02x\n", i, *dev->ep->reg_udccs);
++ }
++}
++
++#else
++
++#define dump_udccr(x) do{}while(0)
++#define dump_udccs0(x) do{}while(0)
++#define dump_state(x) do{}while(0)
++
++#define UDC_DEBUG ((unsigned)0)
++
++#endif
++
++#define DBG(lvl, stuff...) do{if ((lvl) <= UDC_DEBUG) DMSG(stuff);}while(0)
++
++#define ERR(stuff...) pr_err("udc: " stuff)
++#define WARNING(stuff...) pr_warning("udc: " stuff)
++#define INFO(stuff...) pr_info("udc: " stuff)
++
++
++#endif /* __LINUX_USB_GADGET_PXA25X_H */
+diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
+index e02bfd4..7cbc78a 100644
+--- a/drivers/usb/gadget/pxa27x_udc.c
++++ b/drivers/usb/gadget/pxa27x_udc.c
+@@ -33,13 +33,13 @@
+ #include <linux/irq.h>
+
+ #include <asm/byteorder.h>
+-#include <asm/hardware.h>
++#include <mach/hardware.h>
+
+ #include <linux/usb.h>
+ #include <linux/usb/ch9.h>
+ #include <linux/usb/gadget.h>
+-
+-#include <asm/arch/udc.h>
++#include <mach/pxa2xx-regs.h> /* FIXME: for PSSR */
++#include <mach/udc.h>
+
+ #include "pxa27x_udc.h"
+
+@@ -1575,7 +1575,6 @@ static void udc_enable(struct pxa_udc *udc)
+ {
+ udc_writel(udc, UDCICR0, 0);
+ udc_writel(udc, UDCICR1, 0);
+- udc_writel(udc, UP2OCR, UP2OCR_HXOE);
+ udc_clear_mask_UDCCR(udc, UDCCR_UDE);
+
+ clk_enable(udc->clk);
+@@ -1623,7 +1622,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+ struct pxa_udc *udc = the_controller;
+ int retval;
+
+- if (!driver || driver->speed != USB_SPEED_FULL || !driver->bind
++ if (!driver || driver->speed < USB_SPEED_FULL || !driver->bind
+ || !driver->disconnect || !driver->setup)
+ return -EINVAL;
+ if (!udc)
+@@ -2360,18 +2359,19 @@ static int pxa_udc_resume(struct platform_device *_dev)
+ * Software must configure the USB OTG pad, UDC, and UHC
+ * to the state they were in before entering sleep mode.
+ */
+- PSSR |= PSSR_OTGPH;
++ if (cpu_is_pxa27x())
++ PSSR |= PSSR_OTGPH;
+
+ return 0;
+ }
+ #endif
+
+ /* work with hotplug and coldplug */
+-MODULE_ALIAS("platform:pxa2xx-udc");
++MODULE_ALIAS("platform:pxa27x-udc");
+
+ static struct platform_driver udc_driver = {
+ .driver = {
+- .name = "pxa2xx-udc",
++ .name = "pxa27x-udc",
+ .owner = THIS_MODULE,
+ },
+ .remove = __exit_p(pxa_udc_remove),
+diff --git a/drivers/usb/gadget/pxa27x_udc.h b/drivers/usb/gadget/pxa27x_udc.h
+index 97453db..1d1b793 100644
+--- a/drivers/usb/gadget/pxa27x_udc.h
++++ b/drivers/usb/gadget/pxa27x_udc.h
+@@ -484,12 +484,4 @@ static inline struct pxa_udc *to_gadget_udc(struct usb_gadget *gadget)
+ #define ep_warn(ep, fmt, arg...) \
+ dev_warn(ep->dev->dev, "%s:%s:" fmt, EPNAME(ep), __func__, ## arg)
+
+-/*
+- * Cannot include pxa-regs.h, as register names are similar.
+- * So PSSR is redefined here. This should be removed once UDC registers will
+- * be gone from pxa-regs.h.
+- */
+-#define PSSR __REG(0x40F00004) /* Power Manager Sleep Status */
+-#define PSSR_OTGPH (1 << 6) /* OTG Peripheral Hold */
+-
+ #endif /* __LINUX_USB_GADGET_PXA27X_H */
+diff --git a/drivers/usb/gadget/pxa2xx_udc.c b/drivers/usb/gadget/pxa2xx_udc.c
+deleted file mode 100644
+index 08f699b..0000000
+--- a/drivers/usb/gadget/pxa2xx_udc.c
++++ /dev/null
+@@ -1,2383 +0,0 @@
+-/*
+- * linux/drivers/usb/gadget/pxa2xx_udc.c
+- * Intel PXA25x and IXP4xx on-chip full speed USB device controllers
+- *
+- * Copyright (C) 2002 Intrinsyc, Inc. (Frank Becker)
+- * Copyright (C) 2003 Robert Schwebel, Pengutronix
+- * Copyright (C) 2003 Benedikt Spranger, Pengutronix
+- * Copyright (C) 2003 David Brownell
+- * Copyright (C) 2003 Joshua Wise
+- *
+- * 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.
+- *
+- * This program is distributed in the hope that it will be useful,
+- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+- * GNU General Public License for more details.
+- *
+- * You should have received a copy of the GNU General Public License
+- * along with this program; if not, write to the Free Software
+- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+- *
+- */
+-
+-/* #define VERBOSE_DEBUG */
+-
+-#include <linux/device.h>
+-#include <linux/module.h>
+-#include <linux/kernel.h>
+-#include <linux/ioport.h>
+-#include <linux/types.h>
+-#include <linux/errno.h>
+-#include <linux/delay.h>
+-#include <linux/slab.h>
+-#include <linux/init.h>
+-#include <linux/timer.h>
+-#include <linux/list.h>
+-#include <linux/interrupt.h>
+-#include <linux/mm.h>
+-#include <linux/platform_device.h>
+-#include <linux/dma-mapping.h>
+-#include <linux/irq.h>
+-#include <linux/clk.h>
+-#include <linux/err.h>
+-#include <linux/seq_file.h>
+-#include <linux/debugfs.h>
+-
+-#include <asm/byteorder.h>
+-#include <asm/dma.h>
+-#include <asm/gpio.h>
+-#include <asm/io.h>
+-#include <asm/system.h>
+-#include <asm/mach-types.h>
+-#include <asm/unaligned.h>
+-#include <asm/hardware.h>
+-
+-#include <linux/usb/ch9.h>
+-#include <linux/usb/gadget.h>
+-
+-#include <asm/mach/udc_pxa2xx.h>
+-
+-
+-/*
+- * This driver handles the USB Device Controller (UDC) in Intel's PXA 25x
+- * series processors. The UDC for the IXP 4xx series is very similar.
+- * There are fifteen endpoints, in addition to ep0.
+- *
+- * Such controller drivers work with a gadget driver. The gadget driver
+- * returns descriptors, implements configuration and data protocols used
+- * by the host to interact with this device, and allocates endpoints to
+- * the different protocol interfaces. The controller driver virtualizes
+- * usb hardware so that the gadget drivers will be more portable.
+- *
+- * This UDC hardware wants to implement a bit too much USB protocol, so
+- * it constrains the sorts of USB configuration change events that work.
+- * The errata for these chips are misleading; some "fixed" bugs from
+- * pxa250 a0/a1 b0/b1/b2 sure act like they're still there.
+- *
+- * Note that the UDC hardware supports DMA (except on IXP) but that's
+- * not used here. IN-DMA (to host) is simple enough, when the data is
+- * suitably aligned (16 bytes) ... the network stack doesn't do that,
+- * other software can. OUT-DMA is buggy in most chip versions, as well
+- * as poorly designed (data toggle not automatic). So this driver won't
+- * bother using DMA. (Mostly-working IN-DMA support was available in
+- * kernels before 2.6.23, but was never enabled or well tested.)
+- */
+-
+-#define DRIVER_VERSION "30-June-2007"
+-#define DRIVER_DESC "PXA 25x USB Device Controller driver"
+-
+-
+-static const char driver_name [] = "pxa2xx_udc";
+-
+-static const char ep0name [] = "ep0";
+-
+-
+-#ifdef CONFIG_ARCH_IXP4XX
+-
+-/* cpu-specific register addresses are compiled in to this code */
+-#ifdef CONFIG_ARCH_PXA
+-#error "Can't configure both IXP and PXA"
+-#endif
+-
+-/* IXP doesn't yet support <linux/clk.h> */
+-#define clk_get(dev,name) NULL
+-#define clk_enable(clk) do { } while (0)
+-#define clk_disable(clk) do { } while (0)
+-#define clk_put(clk) do { } while (0)
+-
+-#endif
+-
+-#include "pxa2xx_udc.h"
+-
+-
+-#ifdef CONFIG_USB_PXA2XX_SMALL
+-#define SIZE_STR " (small)"
+-#else
+-#define SIZE_STR ""
+-#endif
+-
+-/* ---------------------------------------------------------------------------
+- * endpoint related parts of the api to the usb controller hardware,
+- * used by gadget driver; and the inner talker-to-hardware core.
+- * ---------------------------------------------------------------------------
+- */
+-
+-static void pxa2xx_ep_fifo_flush (struct usb_ep *ep);
+-static void nuke (struct pxa2xx_ep *, int status);
+-
+-/* one GPIO should be used to detect VBUS from the host */
+-static int is_vbus_present(void)
+-{
+- struct pxa2xx_udc_mach_info *mach = the_controller->mach;
+-
+- if (mach->gpio_vbus) {
+- int value = gpio_get_value(mach->gpio_vbus);
+- return mach->gpio_vbus_inverted ? !value : value;
+- }
+- if (mach->udc_is_connected)
+- return mach->udc_is_connected();
+- return 1;
+-}
+-
+-/* one GPIO should control a D+ pullup, so host sees this device (or not) */
+-static void pullup_off(void)
+-{
+- struct pxa2xx_udc_mach_info *mach = the_controller->mach;
+-
+- if (mach->gpio_pullup)
+- gpio_set_value(mach->gpio_pullup, 0);
+- else if (mach->udc_command)
+- mach->udc_command(PXA2XX_UDC_CMD_DISCONNECT);
+-}
+-
+-static void pullup_on(void)
+-{
+- struct pxa2xx_udc_mach_info *mach = the_controller->mach;
+-
+- if (mach->gpio_pullup)
+- gpio_set_value(mach->gpio_pullup, 1);
+- else if (mach->udc_command)
+- mach->udc_command(PXA2XX_UDC_CMD_CONNECT);
+-}
+-
+-static void pio_irq_enable(int bEndpointAddress)
+-{
+- bEndpointAddress &= 0xf;
+- if (bEndpointAddress < 8)
+- UICR0 &= ~(1 << bEndpointAddress);
+- else {
+- bEndpointAddress -= 8;
+- UICR1 &= ~(1 << bEndpointAddress);
+- }
+-}
+-
+-static void pio_irq_disable(int bEndpointAddress)
+-{
+- bEndpointAddress &= 0xf;
+- if (bEndpointAddress < 8)
+- UICR0 |= 1 << bEndpointAddress;
+- else {
+- bEndpointAddress -= 8;
+- UICR1 |= 1 << bEndpointAddress;
+- }
+-}
+-
+-/* The UDCCR reg contains mask and interrupt status bits,
+- * so using '|=' isn't safe as it may ack an interrupt.
+- */
+-#define UDCCR_MASK_BITS (UDCCR_REM | UDCCR_SRM | UDCCR_UDE)
+-
+-static inline void udc_set_mask_UDCCR(int mask)
+-{
+- UDCCR = (UDCCR & UDCCR_MASK_BITS) | (mask & UDCCR_MASK_BITS);
+-}
+-
+-static inline void udc_clear_mask_UDCCR(int mask)
+-{
+- UDCCR = (UDCCR & UDCCR_MASK_BITS) & ~(mask & UDCCR_MASK_BITS);
+-}
+-
+-static inline void udc_ack_int_UDCCR(int mask)
+-{
+- /* udccr contains the bits we dont want to change */
+- __u32 udccr = UDCCR & UDCCR_MASK_BITS;
+-
+- UDCCR = udccr | (mask & ~UDCCR_MASK_BITS);
+-}
+-
+-/*
+- * endpoint enable/disable
+- *
+- * we need to verify the descriptors used to enable endpoints. since pxa2xx
+- * endpoint configurations are fixed, and are pretty much always enabled,
+- * there's not a lot to manage here.
+- *
+- * because pxa2xx can't selectively initialize bulk (or interrupt) endpoints,
+- * (resetting endpoint halt and toggle), SET_INTERFACE is unusable except
+- * for a single interface (with only the default altsetting) and for gadget
+- * drivers that don't halt endpoints (not reset by set_interface). that also
+- * means that if you use ISO, you must violate the USB spec rule that all
+- * iso endpoints must be in non-default altsettings.
+- */
+-static int pxa2xx_ep_enable (struct usb_ep *_ep,
+- const struct usb_endpoint_descriptor *desc)
+-{
+- struct pxa2xx_ep *ep;
+- struct pxa2xx_udc *dev;
+-
+- ep = container_of (_ep, struct pxa2xx_ep, ep);
+- if (!_ep || !desc || ep->desc || _ep->name == ep0name
+- || desc->bDescriptorType != USB_DT_ENDPOINT
+- || ep->bEndpointAddress != desc->bEndpointAddress
+- || ep->fifo_size < le16_to_cpu
+- (desc->wMaxPacketSize)) {
+- DMSG("%s, bad ep or descriptor\n", __func__);
+- return -EINVAL;
+- }
+-
+- /* xfer types must match, except that interrupt ~= bulk */
+- if (ep->bmAttributes != desc->bmAttributes
+- && ep->bmAttributes != USB_ENDPOINT_XFER_BULK
+- && desc->bmAttributes != USB_ENDPOINT_XFER_INT) {
+- DMSG("%s, %s type mismatch\n", __func__, _ep->name);
+- return -EINVAL;
+- }
+-
+- /* hardware _could_ do smaller, but driver doesn't */
+- if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK
+- && le16_to_cpu (desc->wMaxPacketSize)
+- != BULK_FIFO_SIZE)
+- || !desc->wMaxPacketSize) {
+- DMSG("%s, bad %s maxpacket\n", __func__, _ep->name);
+- return -ERANGE;
+- }
+-
+- dev = ep->dev;
+- if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
+- DMSG("%s, bogus device state\n", __func__);
+- return -ESHUTDOWN;
+- }
+-
+- ep->desc = desc;
+- ep->stopped = 0;
+- ep->pio_irqs = 0;
+- ep->ep.maxpacket = le16_to_cpu (desc->wMaxPacketSize);
+-
+- /* flush fifo (mostly for OUT buffers) */
+- pxa2xx_ep_fifo_flush (_ep);
+-
+- /* ... reset halt state too, if we could ... */
+-
+- DBG(DBG_VERBOSE, "enabled %s\n", _ep->name);
+- return 0;
+-}
+-
+-static int pxa2xx_ep_disable (struct usb_ep *_ep)
+-{
+- struct pxa2xx_ep *ep;
+- unsigned long flags;
+-
+- ep = container_of (_ep, struct pxa2xx_ep, ep);
+- if (!_ep || !ep->desc) {
+- DMSG("%s, %s not enabled\n", __func__,
+- _ep ? ep->ep.name : NULL);
+- return -EINVAL;
+- }
+- local_irq_save(flags);
+-
+- nuke (ep, -ESHUTDOWN);
+-
+- /* flush fifo (mostly for IN buffers) */
+- pxa2xx_ep_fifo_flush (_ep);
+-
+- ep->desc = NULL;
+- ep->stopped = 1;
+-
+- local_irq_restore(flags);
+- DBG(DBG_VERBOSE, "%s disabled\n", _ep->name);
+- return 0;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/* for the pxa2xx, these can just wrap kmalloc/kfree. gadget drivers
+- * must still pass correctly initialized endpoints, since other controller
+- * drivers may care about how it's currently set up (dma issues etc).
+- */
+-
+-/*
+- * pxa2xx_ep_alloc_request - allocate a request data structure
+- */
+-static struct usb_request *
+-pxa2xx_ep_alloc_request (struct usb_ep *_ep, gfp_t gfp_flags)
+-{
+- struct pxa2xx_request *req;
+-
+- req = kzalloc(sizeof(*req), gfp_flags);
+- if (!req)
+- return NULL;
+-
+- INIT_LIST_HEAD (&req->queue);
+- return &req->req;
+-}
+-
+-
+-/*
+- * pxa2xx_ep_free_request - deallocate a request data structure
+- */
+-static void
+-pxa2xx_ep_free_request (struct usb_ep *_ep, struct usb_request *_req)
+-{
+- struct pxa2xx_request *req;
+-
+- req = container_of (_req, struct pxa2xx_request, req);
+- WARN_ON (!list_empty (&req->queue));
+- kfree(req);
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/*
+- * done - retire a request; caller blocked irqs
+- */
+-static void done(struct pxa2xx_ep *ep, struct pxa2xx_request *req, int status)
+-{
+- unsigned stopped = ep->stopped;
+-
+- list_del_init(&req->queue);
+-
+- if (likely (req->req.status == -EINPROGRESS))
+- req->req.status = status;
+- else
+- status = req->req.status;
+-
+- if (status && status != -ESHUTDOWN)
+- DBG(DBG_VERBOSE, "complete %s req %p stat %d len %u/%u\n",
+- ep->ep.name, &req->req, status,
+- req->req.actual, req->req.length);
+-
+- /* don't modify queue heads during completion callback */
+- ep->stopped = 1;
+- req->req.complete(&ep->ep, &req->req);
+- ep->stopped = stopped;
+-}
+-
+-
+-static inline void ep0_idle (struct pxa2xx_udc *dev)
+-{
+- dev->ep0state = EP0_IDLE;
+-}
+-
+-static int
+-write_packet(volatile u32 *uddr, struct pxa2xx_request *req, unsigned max)
+-{
+- u8 *buf;
+- unsigned length, count;
+-
+- buf = req->req.buf + req->req.actual;
+- prefetch(buf);
+-
+- /* how big will this packet be? */
+- length = min(req->req.length - req->req.actual, max);
+- req->req.actual += length;
+-
+- count = length;
+- while (likely(count--))
+- *uddr = *buf++;
+-
+- return length;
+-}
+-
+-/*
+- * write to an IN endpoint fifo, as many packets as possible.
+- * irqs will use this to write the rest later.
+- * caller guarantees at least one packet buffer is ready (or a zlp).
+- */
+-static int
+-write_fifo (struct pxa2xx_ep *ep, struct pxa2xx_request *req)
+-{
+- unsigned max;
+-
+- max = le16_to_cpu(ep->desc->wMaxPacketSize);
+- do {
+- unsigned count;
+- int is_last, is_short;
+-
+- count = write_packet(ep->reg_uddr, req, max);
+-
+- /* last packet is usually short (or a zlp) */
+- if (unlikely (count != max))
+- is_last = is_short = 1;
+- else {
+- if (likely(req->req.length != req->req.actual)
+- || req->req.zero)
+- is_last = 0;
+- else
+- is_last = 1;
+- /* interrupt/iso maxpacket may not fill the fifo */
+- is_short = unlikely (max < ep->fifo_size);
+- }
+-
+- DBG(DBG_VERY_NOISY, "wrote %s %d bytes%s%s %d left %p\n",
+- ep->ep.name, count,
+- is_last ? "/L" : "", is_short ? "/S" : "",
+- req->req.length - req->req.actual, req);
+-
+- /* let loose that packet. maybe try writing another one,
+- * double buffering might work. TSP, TPC, and TFS
+- * bit values are the same for all normal IN endpoints.
+- */
+- *ep->reg_udccs = UDCCS_BI_TPC;
+- if (is_short)
+- *ep->reg_udccs = UDCCS_BI_TSP;
+-
+- /* requests complete when all IN data is in the FIFO */
+- if (is_last) {
+- done (ep, req, 0);
+- if (list_empty(&ep->queue))
+- pio_irq_disable (ep->bEndpointAddress);
+- return 1;
+- }
+-
+- // TODO experiment: how robust can fifo mode tweaking be?
+- // double buffering is off in the default fifo mode, which
+- // prevents TFS from being set here.
+-
+- } while (*ep->reg_udccs & UDCCS_BI_TFS);
+- return 0;
+-}
+-
+-/* caller asserts req->pending (ep0 irq status nyet cleared); starts
+- * ep0 data stage. these chips want very simple state transitions.
+- */
+-static inline
+-void ep0start(struct pxa2xx_udc *dev, u32 flags, const char *tag)
+-{
+- UDCCS0 = flags|UDCCS0_SA|UDCCS0_OPR;
+- USIR0 = USIR0_IR0;
+- dev->req_pending = 0;
+- DBG(DBG_VERY_NOISY, "%s %s, %02x/%02x\n",
+- __func__, tag, UDCCS0, flags);
+-}
+-
+-static int
+-write_ep0_fifo (struct pxa2xx_ep *ep, struct pxa2xx_request *req)
+-{
+- unsigned count;
+- int is_short;
+-
+- count = write_packet(&UDDR0, req, EP0_FIFO_SIZE);
+- ep->dev->stats.write.bytes += count;
+-
+- /* last packet "must be" short (or a zlp) */
+- is_short = (count != EP0_FIFO_SIZE);
+-
+- DBG(DBG_VERY_NOISY, "ep0in %d bytes %d left %p\n", count,
+- req->req.length - req->req.actual, req);
+-
+- if (unlikely (is_short)) {
+- if (ep->dev->req_pending)
+- ep0start(ep->dev, UDCCS0_IPR, "short IN");
+- else
+- UDCCS0 = UDCCS0_IPR;
+-
+- count = req->req.length;
+- done (ep, req, 0);
+- ep0_idle(ep->dev);
+-#ifndef CONFIG_ARCH_IXP4XX
+-#if 1
+- /* This seems to get rid of lost status irqs in some cases:
+- * host responds quickly, or next request involves config
+- * change automagic, or should have been hidden, or ...
+- *
+- * FIXME get rid of all udelays possible...
+- */
+- if (count >= EP0_FIFO_SIZE) {
+- count = 100;
+- do {
+- if ((UDCCS0 & UDCCS0_OPR) != 0) {
+- /* clear OPR, generate ack */
+- UDCCS0 = UDCCS0_OPR;
+- break;
+- }
+- count--;
+- udelay(1);
+- } while (count);
+- }
+-#endif
+-#endif
+- } else if (ep->dev->req_pending)
+- ep0start(ep->dev, 0, "IN");
+- return is_short;
+-}
+-
+-
+-/*
+- * read_fifo - unload packet(s) from the fifo we use for usb OUT
+- * transfers and put them into the request. caller should have made
+- * sure there's at least one packet ready.
+- *
+- * returns true if the request completed because of short packet or the
+- * request buffer having filled (and maybe overran till end-of-packet).
+- */
+-static int
+-read_fifo (struct pxa2xx_ep *ep, struct pxa2xx_request *req)
+-{
+- for (;;) {
+- u32 udccs;
+- u8 *buf;
+- unsigned bufferspace, count, is_short;
+-
+- /* make sure there's a packet in the FIFO.
+- * UDCCS_{BO,IO}_RPC are all the same bit value.
+- * UDCCS_{BO,IO}_RNE are all the same bit value.
+- */
+- udccs = *ep->reg_udccs;
+- if (unlikely ((udccs & UDCCS_BO_RPC) == 0))
+- break;
+- buf = req->req.buf + req->req.actual;
+- prefetchw(buf);
+- bufferspace = req->req.length - req->req.actual;
+-
+- /* read all bytes from this packet */
+- if (likely (udccs & UDCCS_BO_RNE)) {
+- count = 1 + (0x0ff & *ep->reg_ubcr);
+- req->req.actual += min (count, bufferspace);
+- } else /* zlp */
+- count = 0;
+- is_short = (count < ep->ep.maxpacket);
+- DBG(DBG_VERY_NOISY, "read %s %02x, %d bytes%s req %p %d/%d\n",
+- ep->ep.name, udccs, count,
+- is_short ? "/S" : "",
+- req, req->req.actual, req->req.length);
+- while (likely (count-- != 0)) {
+- u8 byte = (u8) *ep->reg_uddr;
+-
+- if (unlikely (bufferspace == 0)) {
+- /* this happens when the driver's buffer
+- * is smaller than what the host sent.
+- * discard the extra data.
+- */
+- if (req->req.status != -EOVERFLOW)
+- DMSG("%s overflow %d\n",
+- ep->ep.name, count);
+- req->req.status = -EOVERFLOW;
+- } else {
+- *buf++ = byte;
+- bufferspace--;
+- }
+- }
+- *ep->reg_udccs = UDCCS_BO_RPC;
+- /* RPC/RSP/RNE could now reflect the other packet buffer */
+-
+- /* iso is one request per packet */
+- if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
+- if (udccs & UDCCS_IO_ROF)
+- req->req.status = -EHOSTUNREACH;
+- /* more like "is_done" */
+- is_short = 1;
+- }
+-
+- /* completion */
+- if (is_short || req->req.actual == req->req.length) {
+- done (ep, req, 0);
+- if (list_empty(&ep->queue))
+- pio_irq_disable (ep->bEndpointAddress);
+- return 1;
+- }
+-
+- /* finished that packet. the next one may be waiting... */
+- }
+- return 0;
+-}
+-
+-/*
+- * special ep0 version of the above. no UBCR0 or double buffering; status
+- * handshaking is magic. most device protocols don't need control-OUT.
+- * CDC vendor commands (and RNDIS), mass storage CB/CBI, and some other
+- * protocols do use them.
+- */
+-static int
+-read_ep0_fifo (struct pxa2xx_ep *ep, struct pxa2xx_request *req)
+-{
+- u8 *buf, byte;
+- unsigned bufferspace;
+-
+- buf = req->req.buf + req->req.actual;
+- bufferspace = req->req.length - req->req.actual;
+-
+- while (UDCCS0 & UDCCS0_RNE) {
+- byte = (u8) UDDR0;
+-
+- if (unlikely (bufferspace == 0)) {
+- /* this happens when the driver's buffer
+- * is smaller than what the host sent.
+- * discard the extra data.
+- */
+- if (req->req.status != -EOVERFLOW)
+- DMSG("%s overflow\n", ep->ep.name);
+- req->req.status = -EOVERFLOW;
+- } else {
+- *buf++ = byte;
+- req->req.actual++;
+- bufferspace--;
+- }
+- }
+-
+- UDCCS0 = UDCCS0_OPR | UDCCS0_IPR;
+-
+- /* completion */
+- if (req->req.actual >= req->req.length)
+- return 1;
+-
+- /* finished that packet. the next one may be waiting... */
+- return 0;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static int
+-pxa2xx_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
+-{
+- struct pxa2xx_request *req;
+- struct pxa2xx_ep *ep;
+- struct pxa2xx_udc *dev;
+- unsigned long flags;
+-
+- req = container_of(_req, struct pxa2xx_request, req);
+- if (unlikely (!_req || !_req->complete || !_req->buf
+- || !list_empty(&req->queue))) {
+- DMSG("%s, bad params\n", __func__);
+- return -EINVAL;
+- }
+-
+- ep = container_of(_ep, struct pxa2xx_ep, ep);
+- if (unlikely (!_ep || (!ep->desc && ep->ep.name != ep0name))) {
+- DMSG("%s, bad ep\n", __func__);
+- return -EINVAL;
+- }
+-
+- dev = ep->dev;
+- if (unlikely (!dev->driver
+- || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
+- DMSG("%s, bogus device state\n", __func__);
+- return -ESHUTDOWN;
+- }
+-
+- /* iso is always one packet per request, that's the only way
+- * we can report per-packet status. that also helps with dma.
+- */
+- if (unlikely (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC
+- && req->req.length > le16_to_cpu
+- (ep->desc->wMaxPacketSize)))
+- return -EMSGSIZE;
+-
+- DBG(DBG_NOISY, "%s queue req %p, len %d buf %p\n",
+- _ep->name, _req, _req->length, _req->buf);
+-
+- local_irq_save(flags);
+-
+- _req->status = -EINPROGRESS;
+- _req->actual = 0;
+-
+- /* kickstart this i/o queue? */
+- if (list_empty(&ep->queue) && !ep->stopped) {
+- if (ep->desc == NULL/* ep0 */) {
+- unsigned length = _req->length;
+-
+- switch (dev->ep0state) {
+- case EP0_IN_DATA_PHASE:
+- dev->stats.write.ops++;
+- if (write_ep0_fifo(ep, req))
+- req = NULL;
+- break;
+-
+- case EP0_OUT_DATA_PHASE:
+- dev->stats.read.ops++;
+- /* messy ... */
+- if (dev->req_config) {
+- DBG(DBG_VERBOSE, "ep0 config ack%s\n",
+- dev->has_cfr ? "" : " raced");
+- if (dev->has_cfr)
+- UDCCFR = UDCCFR_AREN|UDCCFR_ACM
+- |UDCCFR_MB1;
+- done(ep, req, 0);
+- dev->ep0state = EP0_END_XFER;
+- local_irq_restore (flags);
+- return 0;
+- }
+- if (dev->req_pending)
+- ep0start(dev, UDCCS0_IPR, "OUT");
+- if (length == 0 || ((UDCCS0 & UDCCS0_RNE) != 0
+- && read_ep0_fifo(ep, req))) {
+- ep0_idle(dev);
+- done(ep, req, 0);
+- req = NULL;
+- }
+- break;
+-
+- default:
+- DMSG("ep0 i/o, odd state %d\n", dev->ep0state);
+- local_irq_restore (flags);
+- return -EL2HLT;
+- }
+- /* can the FIFO can satisfy the request immediately? */
+- } else if ((ep->bEndpointAddress & USB_DIR_IN) != 0) {
+- if ((*ep->reg_udccs & UDCCS_BI_TFS) != 0
+- && write_fifo(ep, req))
+- req = NULL;
+- } else if ((*ep->reg_udccs & UDCCS_BO_RFS) != 0
+- && read_fifo(ep, req)) {
+- req = NULL;
+- }
+-
+- if (likely (req && ep->desc))
+- pio_irq_enable(ep->bEndpointAddress);
+- }
+-
+- /* pio or dma irq handler advances the queue. */
+- if (likely(req != NULL))
+- list_add_tail(&req->queue, &ep->queue);
+- local_irq_restore(flags);
+-
+- return 0;
+-}
+-
+-
+-/*
+- * nuke - dequeue ALL requests
+- */
+-static void nuke(struct pxa2xx_ep *ep, int status)
+-{
+- struct pxa2xx_request *req;
+-
+- /* called with irqs blocked */
+- while (!list_empty(&ep->queue)) {
+- req = list_entry(ep->queue.next,
+- struct pxa2xx_request,
+- queue);
+- done(ep, req, status);
+- }
+- if (ep->desc)
+- pio_irq_disable (ep->bEndpointAddress);
+-}
+-
+-
+-/* dequeue JUST ONE request */
+-static int pxa2xx_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
+-{
+- struct pxa2xx_ep *ep;
+- struct pxa2xx_request *req;
+- unsigned long flags;
+-
+- ep = container_of(_ep, struct pxa2xx_ep, ep);
+- if (!_ep || ep->ep.name == ep0name)
+- return -EINVAL;
+-
+- local_irq_save(flags);
+-
+- /* make sure it's actually queued on this endpoint */
+- list_for_each_entry (req, &ep->queue, queue) {
+- if (&req->req == _req)
+- break;
+- }
+- if (&req->req != _req) {
+- local_irq_restore(flags);
+- return -EINVAL;
+- }
+-
+- done(ep, req, -ECONNRESET);
+-
+- local_irq_restore(flags);
+- return 0;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static int pxa2xx_ep_set_halt(struct usb_ep *_ep, int value)
+-{
+- struct pxa2xx_ep *ep;
+- unsigned long flags;
+-
+- ep = container_of(_ep, struct pxa2xx_ep, ep);
+- if (unlikely (!_ep
+- || (!ep->desc && ep->ep.name != ep0name))
+- || ep->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
+- DMSG("%s, bad ep\n", __func__);
+- return -EINVAL;
+- }
+- if (value == 0) {
+- /* this path (reset toggle+halt) is needed to implement
+- * SET_INTERFACE on normal hardware. but it can't be
+- * done from software on the PXA UDC, and the hardware
+- * forgets to do it as part of SET_INTERFACE automagic.
+- */
+- DMSG("only host can clear %s halt\n", _ep->name);
+- return -EROFS;
+- }
+-
+- local_irq_save(flags);
+-
+- if ((ep->bEndpointAddress & USB_DIR_IN) != 0
+- && ((*ep->reg_udccs & UDCCS_BI_TFS) == 0
+- || !list_empty(&ep->queue))) {
+- local_irq_restore(flags);
+- return -EAGAIN;
+- }
+-
+- /* FST bit is the same for control, bulk in, bulk out, interrupt in */
+- *ep->reg_udccs = UDCCS_BI_FST|UDCCS_BI_FTF;
+-
+- /* ep0 needs special care */
+- if (!ep->desc) {
+- start_watchdog(ep->dev);
+- ep->dev->req_pending = 0;
+- ep->dev->ep0state = EP0_STALL;
+-
+- /* and bulk/intr endpoints like dropping stalls too */
+- } else {
+- unsigned i;
+- for (i = 0; i < 1000; i += 20) {
+- if (*ep->reg_udccs & UDCCS_BI_SST)
+- break;
+- udelay(20);
+- }
+- }
+- local_irq_restore(flags);
+-
+- DBG(DBG_VERBOSE, "%s halt\n", _ep->name);
+- return 0;
+-}
+-
+-static int pxa2xx_ep_fifo_status(struct usb_ep *_ep)
+-{
+- struct pxa2xx_ep *ep;
+-
+- ep = container_of(_ep, struct pxa2xx_ep, ep);
+- if (!_ep) {
+- DMSG("%s, bad ep\n", __func__);
+- return -ENODEV;
+- }
+- /* pxa can't report unclaimed bytes from IN fifos */
+- if ((ep->bEndpointAddress & USB_DIR_IN) != 0)
+- return -EOPNOTSUPP;
+- if (ep->dev->gadget.speed == USB_SPEED_UNKNOWN
+- || (*ep->reg_udccs & UDCCS_BO_RFS) == 0)
+- return 0;
+- else
+- return (*ep->reg_ubcr & 0xfff) + 1;
+-}
+-
+-static void pxa2xx_ep_fifo_flush(struct usb_ep *_ep)
+-{
+- struct pxa2xx_ep *ep;
+-
+- ep = container_of(_ep, struct pxa2xx_ep, ep);
+- if (!_ep || ep->ep.name == ep0name || !list_empty(&ep->queue)) {
+- DMSG("%s, bad ep\n", __func__);
+- return;
+- }
+-
+- /* toggle and halt bits stay unchanged */
+-
+- /* for OUT, just read and discard the FIFO contents. */
+- if ((ep->bEndpointAddress & USB_DIR_IN) == 0) {
+- while (((*ep->reg_udccs) & UDCCS_BO_RNE) != 0)
+- (void) *ep->reg_uddr;
+- return;
+- }
+-
+- /* most IN status is the same, but ISO can't stall */
+- *ep->reg_udccs = UDCCS_BI_TPC|UDCCS_BI_FTF|UDCCS_BI_TUR
+- | (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC)
+- ? 0 : UDCCS_BI_SST;
+-}
+-
+-
+-static struct usb_ep_ops pxa2xx_ep_ops = {
+- .enable = pxa2xx_ep_enable,
+- .disable = pxa2xx_ep_disable,
+-
+- .alloc_request = pxa2xx_ep_alloc_request,
+- .free_request = pxa2xx_ep_free_request,
+-
+- .queue = pxa2xx_ep_queue,
+- .dequeue = pxa2xx_ep_dequeue,
+-
+- .set_halt = pxa2xx_ep_set_halt,
+- .fifo_status = pxa2xx_ep_fifo_status,
+- .fifo_flush = pxa2xx_ep_fifo_flush,
+-};
+-
+-
+-/* ---------------------------------------------------------------------------
+- * device-scoped parts of the api to the usb controller hardware
+- * ---------------------------------------------------------------------------
+- */
+-
+-static int pxa2xx_udc_get_frame(struct usb_gadget *_gadget)
+-{
+- return ((UFNRH & 0x07) << 8) | (UFNRL & 0xff);
+-}
+-
+-static int pxa2xx_udc_wakeup(struct usb_gadget *_gadget)
+-{
+- /* host may not have enabled remote wakeup */
+- if ((UDCCS0 & UDCCS0_DRWF) == 0)
+- return -EHOSTUNREACH;
+- udc_set_mask_UDCCR(UDCCR_RSM);
+- return 0;
+-}
+-
+-static void stop_activity(struct pxa2xx_udc *, struct usb_gadget_driver *);
+-static void udc_enable (struct pxa2xx_udc *);
+-static void udc_disable(struct pxa2xx_udc *);
+-
+-/* We disable the UDC -- and its 48 MHz clock -- whenever it's not
+- * in active use.
+- */
+-static int pullup(struct pxa2xx_udc *udc)
+-{
+- int is_active = udc->vbus && udc->pullup && !udc->suspended;
+- DMSG("%s\n", is_active ? "active" : "inactive");
+- if (is_active) {
+- if (!udc->active) {
+- udc->active = 1;
+- /* Enable clock for USB device */
+- clk_enable(udc->clk);
+- udc_enable(udc);
+- }
+- } else {
+- if (udc->active) {
+- if (udc->gadget.speed != USB_SPEED_UNKNOWN) {
+- DMSG("disconnect %s\n", udc->driver
+- ? udc->driver->driver.name
+- : "(no driver)");
+- stop_activity(udc, udc->driver);
+- }
+- udc_disable(udc);
+- /* Disable clock for USB device */
+- clk_disable(udc->clk);
+- udc->active = 0;
+- }
+-
+- }
+- return 0;
+-}
+-
+-/* VBUS reporting logically comes from a transceiver */
+-static int pxa2xx_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
+-{
+- struct pxa2xx_udc *udc;
+-
+- udc = container_of(_gadget, struct pxa2xx_udc, gadget);
+- udc->vbus = (is_active != 0);
+- DMSG("vbus %s\n", is_active ? "supplied" : "inactive");
+- pullup(udc);
+- return 0;
+-}
+-
+-/* drivers may have software control over D+ pullup */
+-static int pxa2xx_udc_pullup(struct usb_gadget *_gadget, int is_active)
+-{
+- struct pxa2xx_udc *udc;
+-
+- udc = container_of(_gadget, struct pxa2xx_udc, gadget);
+-
+- /* not all boards support pullup control */
+- if (!udc->mach->gpio_pullup && !udc->mach->udc_command)
+- return -EOPNOTSUPP;
+-
+- udc->pullup = (is_active != 0);
+- pullup(udc);
+- return 0;
+-}
+-
+-static const struct usb_gadget_ops pxa2xx_udc_ops = {
+- .get_frame = pxa2xx_udc_get_frame,
+- .wakeup = pxa2xx_udc_wakeup,
+- .vbus_session = pxa2xx_udc_vbus_session,
+- .pullup = pxa2xx_udc_pullup,
+-
+- // .vbus_draw ... boards may consume current from VBUS, up to
+- // 100-500mA based on config. the 500uA suspend ceiling means
+- // that exclusively vbus-powered PXA designs violate USB specs.
+-};
+-
+-/*-------------------------------------------------------------------------*/
+-
+-#ifdef CONFIG_USB_GADGET_DEBUG_FS
+-
+-static int
+-udc_seq_show(struct seq_file *m, void *_d)
+-{
+- struct pxa2xx_udc *dev = m->private;
+- unsigned long flags;
+- int i;
+- u32 tmp;
+-
+- local_irq_save(flags);
+-
+- /* basic device status */
+- seq_printf(m, DRIVER_DESC "\n"
+- "%s version: %s\nGadget driver: %s\nHost %s\n\n",
+- driver_name, DRIVER_VERSION SIZE_STR "(pio)",
+- dev->driver ? dev->driver->driver.name : "(none)",
+- is_vbus_present() ? "full speed" : "disconnected");
+-
+- /* registers for device and ep0 */
+- seq_printf(m,
+- "uicr %02X.%02X, usir %02X.%02x, ufnr %02X.%02X\n",
+- UICR1, UICR0, USIR1, USIR0, UFNRH, UFNRL);
+-
+- tmp = UDCCR;
+- seq_printf(m,
+- "udccr %02X =%s%s%s%s%s%s%s%s\n", tmp,
+- (tmp & UDCCR_REM) ? " rem" : "",
+- (tmp & UDCCR_RSTIR) ? " rstir" : "",
+- (tmp & UDCCR_SRM) ? " srm" : "",
+- (tmp & UDCCR_SUSIR) ? " susir" : "",
+- (tmp & UDCCR_RESIR) ? " resir" : "",
+- (tmp & UDCCR_RSM) ? " rsm" : "",
+- (tmp & UDCCR_UDA) ? " uda" : "",
+- (tmp & UDCCR_UDE) ? " ude" : "");
+-
+- tmp = UDCCS0;
+- seq_printf(m,
+- "udccs0 %02X =%s%s%s%s%s%s%s%s\n", tmp,
+- (tmp & UDCCS0_SA) ? " sa" : "",
+- (tmp & UDCCS0_RNE) ? " rne" : "",
+- (tmp & UDCCS0_FST) ? " fst" : "",
+- (tmp & UDCCS0_SST) ? " sst" : "",
+- (tmp & UDCCS0_DRWF) ? " dwrf" : "",
+- (tmp & UDCCS0_FTF) ? " ftf" : "",
+- (tmp & UDCCS0_IPR) ? " ipr" : "",
+- (tmp & UDCCS0_OPR) ? " opr" : "");
+-
+- if (dev->has_cfr) {
+- tmp = UDCCFR;
+- seq_printf(m,
+- "udccfr %02X =%s%s\n", tmp,
+- (tmp & UDCCFR_AREN) ? " aren" : "",
+- (tmp & UDCCFR_ACM) ? " acm" : "");
+- }
+-
+- if (!is_vbus_present() || !dev->driver)
+- goto done;
+-
+- seq_printf(m, "ep0 IN %lu/%lu, OUT %lu/%lu\nirqs %lu\n\n",
+- dev->stats.write.bytes, dev->stats.write.ops,
+- dev->stats.read.bytes, dev->stats.read.ops,
+- dev->stats.irqs);
+-
+- /* dump endpoint queues */
+- for (i = 0; i < PXA_UDC_NUM_ENDPOINTS; i++) {
+- struct pxa2xx_ep *ep = &dev->ep [i];
+- struct pxa2xx_request *req;
+-
+- if (i != 0) {
+- const struct usb_endpoint_descriptor *desc;
+-
+- desc = ep->desc;
+- if (!desc)
+- continue;
+- tmp = *dev->ep [i].reg_udccs;
+- seq_printf(m,
+- "%s max %d %s udccs %02x irqs %lu\n",
+- ep->ep.name, le16_to_cpu(desc->wMaxPacketSize),
+- "pio", tmp, ep->pio_irqs);
+- /* TODO translate all five groups of udccs bits! */
+-
+- } else /* ep0 should only have one transfer queued */
+- seq_printf(m, "ep0 max 16 pio irqs %lu\n",
+- ep->pio_irqs);
+-
+- if (list_empty(&ep->queue)) {
+- seq_printf(m, "\t(nothing queued)\n");
+- continue;
+- }
+- list_for_each_entry(req, &ep->queue, queue) {
+- seq_printf(m,
+- "\treq %p len %d/%d buf %p\n",
+- &req->req, req->req.actual,
+- req->req.length, req->req.buf);
+- }
+- }
+-
+-done:
+- local_irq_restore(flags);
+- return 0;
+-}
+-
+-static int
+-udc_debugfs_open(struct inode *inode, struct file *file)
+-{
+- return single_open(file, udc_seq_show, inode->i_private);
+-}
+-
+-static const struct file_operations debug_fops = {
+- .open = udc_debugfs_open,
+- .read = seq_read,
+- .llseek = seq_lseek,
+- .release = single_release,
+- .owner = THIS_MODULE,
+-};
+-
+-#define create_debug_files(dev) \
+- do { \
+- dev->debugfs_udc = debugfs_create_file(dev->gadget.name, \
+- S_IRUGO, NULL, dev, &debug_fops); \
+- } while (0)
+-#define remove_debug_files(dev) \
+- do { \
+- if (dev->debugfs_udc) \
+- debugfs_remove(dev->debugfs_udc); \
+- } while (0)
+-
+-#else /* !CONFIG_USB_GADGET_DEBUG_FILES */
+-
+-#define create_debug_files(dev) do {} while (0)
+-#define remove_debug_files(dev) do {} while (0)
+-
+-#endif /* CONFIG_USB_GADGET_DEBUG_FILES */
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/*
+- * udc_disable - disable USB device controller
+- */
+-static void udc_disable(struct pxa2xx_udc *dev)
+-{
+- /* block all irqs */
+- udc_set_mask_UDCCR(UDCCR_SRM|UDCCR_REM);
+- UICR0 = UICR1 = 0xff;
+- UFNRH = UFNRH_SIM;
+-
+- /* if hardware supports it, disconnect from usb */
+- pullup_off();
+-
+- udc_clear_mask_UDCCR(UDCCR_UDE);
+-
+- ep0_idle (dev);
+- dev->gadget.speed = USB_SPEED_UNKNOWN;
+-}
+-
+-
+-/*
+- * udc_reinit - initialize software state
+- */
+-static void udc_reinit(struct pxa2xx_udc *dev)
+-{
+- u32 i;
+-
+- /* device/ep0 records init */
+- INIT_LIST_HEAD (&dev->gadget.ep_list);
+- INIT_LIST_HEAD (&dev->gadget.ep0->ep_list);
+- dev->ep0state = EP0_IDLE;
+-
+- /* basic endpoint records init */
+- for (i = 0; i < PXA_UDC_NUM_ENDPOINTS; i++) {
+- struct pxa2xx_ep *ep = &dev->ep[i];
+-
+- if (i != 0)
+- list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
+-
+- ep->desc = NULL;
+- ep->stopped = 0;
+- INIT_LIST_HEAD (&ep->queue);
+- ep->pio_irqs = 0;
+- }
+-
+- /* the rest was statically initialized, and is read-only */
+-}
+-
+-/* until it's enabled, this UDC should be completely invisible
+- * to any USB host.
+- */
+-static void udc_enable (struct pxa2xx_udc *dev)
+-{
+- udc_clear_mask_UDCCR(UDCCR_UDE);
+-
+- /* try to clear these bits before we enable the udc */
+- udc_ack_int_UDCCR(UDCCR_SUSIR|/*UDCCR_RSTIR|*/UDCCR_RESIR);
+-
+- ep0_idle(dev);
+- dev->gadget.speed = USB_SPEED_UNKNOWN;
+- dev->stats.irqs = 0;
+-
+- /*
+- * sequence taken from chapter 12.5.10, PXA250 AppProcDevManual:
+- * - enable UDC
+- * - if RESET is already in progress, ack interrupt
+- * - unmask reset interrupt
+- */
+- udc_set_mask_UDCCR(UDCCR_UDE);
+- if (!(UDCCR & UDCCR_UDA))
+- udc_ack_int_UDCCR(UDCCR_RSTIR);
+-
+- if (dev->has_cfr /* UDC_RES2 is defined */) {
+- /* pxa255 (a0+) can avoid a set_config race that could
+- * prevent gadget drivers from configuring correctly
+- */
+- UDCCFR = UDCCFR_ACM | UDCCFR_MB1;
+- } else {
+- /* "USB test mode" for pxa250 errata 40-42 (stepping a0, a1)
+- * which could result in missing packets and interrupts.
+- * supposedly one bit per endpoint, controlling whether it
+- * double buffers or not; ACM/AREN bits fit into the holes.
+- * zero bits (like USIR0_IRx) disable double buffering.
+- */
+- UDC_RES1 = 0x00;
+- UDC_RES2 = 0x00;
+- }
+-
+- /* enable suspend/resume and reset irqs */
+- udc_clear_mask_UDCCR(UDCCR_SRM | UDCCR_REM);
+-
+- /* enable ep0 irqs */
+- UICR0 &= ~UICR0_IM0;
+-
+- /* if hardware supports it, pullup D+ and wait for reset */
+- pullup_on();
+-}
+-
+-
+-/* when a driver is successfully registered, it will receive
+- * control requests including set_configuration(), which enables
+- * non-control requests. then usb traffic follows until a
+- * disconnect is reported. then a host may connect again, or
+- * the driver might get unbound.
+- */
+-int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+-{
+- struct pxa2xx_udc *dev = the_controller;
+- int retval;
+-
+- if (!driver
+- || driver->speed < USB_SPEED_FULL
+- || !driver->bind
+- || !driver->disconnect
+- || !driver->setup)
+- return -EINVAL;
+- if (!dev)
+- return -ENODEV;
+- if (dev->driver)
+- return -EBUSY;
+-
+- /* first hook up the driver ... */
+- dev->driver = driver;
+- dev->gadget.dev.driver = &driver->driver;
+- dev->pullup = 1;
+-
+- retval = device_add (&dev->gadget.dev);
+- if (retval) {
+-fail:
+- dev->driver = NULL;
+- dev->gadget.dev.driver = NULL;
+- return retval;
+- }
+- retval = driver->bind(&dev->gadget);
+- if (retval) {
+- DMSG("bind to driver %s --> error %d\n",
+- driver->driver.name, retval);
+- device_del (&dev->gadget.dev);
+- goto fail;
+- }
+-
+- /* ... then enable host detection and ep0; and we're ready
+- * for set_configuration as well as eventual disconnect.
+- */
+- DMSG("registered gadget driver '%s'\n", driver->driver.name);
+- pullup(dev);
+- dump_state(dev);
+- return 0;
+-}
+-EXPORT_SYMBOL(usb_gadget_register_driver);
+-
+-static void
+-stop_activity(struct pxa2xx_udc *dev, struct usb_gadget_driver *driver)
+-{
+- int i;
+-
+- /* don't disconnect drivers more than once */
+- if (dev->gadget.speed == USB_SPEED_UNKNOWN)
+- driver = NULL;
+- dev->gadget.speed = USB_SPEED_UNKNOWN;
+-
+- /* prevent new request submissions, kill any outstanding requests */
+- for (i = 0; i < PXA_UDC_NUM_ENDPOINTS; i++) {
+- struct pxa2xx_ep *ep = &dev->ep[i];
+-
+- ep->stopped = 1;
+- nuke(ep, -ESHUTDOWN);
+- }
+- del_timer_sync(&dev->timer);
+-
+- /* report disconnect; the driver is already quiesced */
+- if (driver)
+- driver->disconnect(&dev->gadget);
+-
+- /* re-init driver-visible data structures */
+- udc_reinit(dev);
+-}
+-
+-int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+-{
+- struct pxa2xx_udc *dev = the_controller;
+-
+- if (!dev)
+- return -ENODEV;
+- if (!driver || driver != dev->driver || !driver->unbind)
+- return -EINVAL;
+-
+- local_irq_disable();
+- dev->pullup = 0;
+- pullup(dev);
+- stop_activity(dev, driver);
+- local_irq_enable();
+-
+- driver->unbind(&dev->gadget);
+- dev->gadget.dev.driver = NULL;
+- dev->driver = NULL;
+-
+- device_del (&dev->gadget.dev);
+-
+- DMSG("unregistered gadget driver '%s'\n", driver->driver.name);
+- dump_state(dev);
+- return 0;
+-}
+-EXPORT_SYMBOL(usb_gadget_unregister_driver);
+-
+-
+-/*-------------------------------------------------------------------------*/
+-
+-#ifdef CONFIG_ARCH_LUBBOCK
+-
+-/* Lubbock has separate connect and disconnect irqs. More typical designs
+- * use one GPIO as the VBUS IRQ, and another to control the D+ pullup.
+- */
+-
+-static irqreturn_t
+-lubbock_vbus_irq(int irq, void *_dev)
+-{
+- struct pxa2xx_udc *dev = _dev;
+- int vbus;
+-
+- dev->stats.irqs++;
+- switch (irq) {
+- case LUBBOCK_USB_IRQ:
+- vbus = 1;
+- disable_irq(LUBBOCK_USB_IRQ);
+- enable_irq(LUBBOCK_USB_DISC_IRQ);
+- break;
+- case LUBBOCK_USB_DISC_IRQ:
+- vbus = 0;
+- disable_irq(LUBBOCK_USB_DISC_IRQ);
+- enable_irq(LUBBOCK_USB_IRQ);
+- break;
+- default:
+- return IRQ_NONE;
+- }
+-
+- pxa2xx_udc_vbus_session(&dev->gadget, vbus);
+- return IRQ_HANDLED;
+-}
+-
+-#endif
+-
+-static irqreturn_t udc_vbus_irq(int irq, void *_dev)
+-{
+- struct pxa2xx_udc *dev = _dev;
+- int vbus = gpio_get_value(dev->mach->gpio_vbus);
+-
+- if (dev->mach->gpio_vbus_inverted)
+- vbus = !vbus;
+-
+- pxa2xx_udc_vbus_session(&dev->gadget, vbus);
+- return IRQ_HANDLED;
+-}
+-
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static inline void clear_ep_state (struct pxa2xx_udc *dev)
+-{
+- unsigned i;
+-
+- /* hardware SET_{CONFIGURATION,INTERFACE} automagic resets endpoint
+- * fifos, and pending transactions mustn't be continued in any case.
+- */
+- for (i = 1; i < PXA_UDC_NUM_ENDPOINTS; i++)
+- nuke(&dev->ep[i], -ECONNABORTED);
+-}
+-
+-static void udc_watchdog(unsigned long _dev)
+-{
+- struct pxa2xx_udc *dev = (void *)_dev;
+-
+- local_irq_disable();
+- if (dev->ep0state == EP0_STALL
+- && (UDCCS0 & UDCCS0_FST) == 0
+- && (UDCCS0 & UDCCS0_SST) == 0) {
+- UDCCS0 = UDCCS0_FST|UDCCS0_FTF;
+- DBG(DBG_VERBOSE, "ep0 re-stall\n");
+- start_watchdog(dev);
+- }
+- local_irq_enable();
+-}
+-
+-static void handle_ep0 (struct pxa2xx_udc *dev)
+-{
+- u32 udccs0 = UDCCS0;
+- struct pxa2xx_ep *ep = &dev->ep [0];
+- struct pxa2xx_request *req;
+- union {
+- struct usb_ctrlrequest r;
+- u8 raw [8];
+- u32 word [2];
+- } u;
+-
+- if (list_empty(&ep->queue))
+- req = NULL;
+- else
+- req = list_entry(ep->queue.next, struct pxa2xx_request, queue);
+-
+- /* clear stall status */
+- if (udccs0 & UDCCS0_SST) {
+- nuke(ep, -EPIPE);
+- UDCCS0 = UDCCS0_SST;
+- del_timer(&dev->timer);
+- ep0_idle(dev);
+- }
+-
+- /* previous request unfinished? non-error iff back-to-back ... */
+- if ((udccs0 & UDCCS0_SA) != 0 && dev->ep0state != EP0_IDLE) {
+- nuke(ep, 0);
+- del_timer(&dev->timer);
+- ep0_idle(dev);
+- }
+-
+- switch (dev->ep0state) {
+- case EP0_IDLE:
+- /* late-breaking status? */
+- udccs0 = UDCCS0;
+-
+- /* start control request? */
+- if (likely((udccs0 & (UDCCS0_OPR|UDCCS0_SA|UDCCS0_RNE))
+- == (UDCCS0_OPR|UDCCS0_SA|UDCCS0_RNE))) {
+- int i;
+-
+- nuke (ep, -EPROTO);
+-
+- /* read SETUP packet */
+- for (i = 0; i < 8; i++) {
+- if (unlikely(!(UDCCS0 & UDCCS0_RNE))) {
+-bad_setup:
+- DMSG("SETUP %d!\n", i);
+- goto stall;
+- }
+- u.raw [i] = (u8) UDDR0;
+- }
+- if (unlikely((UDCCS0 & UDCCS0_RNE) != 0))
+- goto bad_setup;
+-
+-got_setup:
+- DBG(DBG_VERBOSE, "SETUP %02x.%02x v%04x i%04x l%04x\n",
+- u.r.bRequestType, u.r.bRequest,
+- le16_to_cpu(u.r.wValue),
+- le16_to_cpu(u.r.wIndex),
+- le16_to_cpu(u.r.wLength));
+-
+- /* cope with automagic for some standard requests. */
+- dev->req_std = (u.r.bRequestType & USB_TYPE_MASK)
+- == USB_TYPE_STANDARD;
+- dev->req_config = 0;
+- dev->req_pending = 1;
+- switch (u.r.bRequest) {
+- /* hardware restricts gadget drivers here! */
+- case USB_REQ_SET_CONFIGURATION:
+- if (u.r.bRequestType == USB_RECIP_DEVICE) {
+- /* reflect hardware's automagic
+- * up to the gadget driver.
+- */
+-config_change:
+- dev->req_config = 1;
+- clear_ep_state(dev);
+- /* if !has_cfr, there's no synch
+- * else use AREN (later) not SA|OPR
+- * USIR0_IR0 acts edge sensitive
+- */
+- }
+- break;
+- /* ... and here, even more ... */
+- case USB_REQ_SET_INTERFACE:
+- if (u.r.bRequestType == USB_RECIP_INTERFACE) {
+- /* udc hardware is broken by design:
+- * - altsetting may only be zero;
+- * - hw resets all interfaces' eps;
+- * - ep reset doesn't include halt(?).
+- */
+- DMSG("broken set_interface (%d/%d)\n",
+- le16_to_cpu(u.r.wIndex),
+- le16_to_cpu(u.r.wValue));
+- goto config_change;
+- }
+- break;
+- /* hardware was supposed to hide this */
+- case USB_REQ_SET_ADDRESS:
+- if (u.r.bRequestType == USB_RECIP_DEVICE) {
+- ep0start(dev, 0, "address");
+- return;
+- }
+- break;
+- }
+-
+- if (u.r.bRequestType & USB_DIR_IN)
+- dev->ep0state = EP0_IN_DATA_PHASE;
+- else
+- dev->ep0state = EP0_OUT_DATA_PHASE;
+-
+- i = dev->driver->setup(&dev->gadget, &u.r);
+- if (i < 0) {
+- /* hardware automagic preventing STALL... */
+- if (dev->req_config) {
+- /* hardware sometimes neglects to tell
+- * tell us about config change events,
+- * so later ones may fail...
+- */
+- WARN("config change %02x fail %d?\n",
+- u.r.bRequest, i);
+- return;
+- /* TODO experiment: if has_cfr,
+- * hardware didn't ACK; maybe we
+- * could actually STALL!
+- */
+- }
+- DBG(DBG_VERBOSE, "protocol STALL, "
+- "%02x err %d\n", UDCCS0, i);
+-stall:
+- /* the watchdog timer helps deal with cases
+- * where udc seems to clear FST wrongly, and
+- * then NAKs instead of STALLing.
+- */
+- ep0start(dev, UDCCS0_FST|UDCCS0_FTF, "stall");
+- start_watchdog(dev);
+- dev->ep0state = EP0_STALL;
+-
+- /* deferred i/o == no response yet */
+- } else if (dev->req_pending) {
+- if (likely(dev->ep0state == EP0_IN_DATA_PHASE
+- || dev->req_std || u.r.wLength))
+- ep0start(dev, 0, "defer");
+- else
+- ep0start(dev, UDCCS0_IPR, "defer/IPR");
+- }
+-
+- /* expect at least one data or status stage irq */
+- return;
+-
+- } else if (likely((udccs0 & (UDCCS0_OPR|UDCCS0_SA))
+- == (UDCCS0_OPR|UDCCS0_SA))) {
+- unsigned i;
+-
+- /* pxa210/250 erratum 131 for B0/B1 says RNE lies.
+- * still observed on a pxa255 a0.
+- */
+- DBG(DBG_VERBOSE, "e131\n");
+- nuke(ep, -EPROTO);
+-
+- /* read SETUP data, but don't trust it too much */
+- for (i = 0; i < 8; i++)
+- u.raw [i] = (u8) UDDR0;
+- if ((u.r.bRequestType & USB_RECIP_MASK)
+- > USB_RECIP_OTHER)
+- goto stall;
+- if (u.word [0] == 0 && u.word [1] == 0)
+- goto stall;
+- goto got_setup;
+- } else {
+- /* some random early IRQ:
+- * - we acked FST
+- * - IPR cleared
+- * - OPR got set, without SA (likely status stage)
+- */
+- UDCCS0 = udccs0 & (UDCCS0_SA|UDCCS0_OPR);
+- }
+- break;
+- case EP0_IN_DATA_PHASE: /* GET_DESCRIPTOR etc */
+- if (udccs0 & UDCCS0_OPR) {
+- UDCCS0 = UDCCS0_OPR|UDCCS0_FTF;
+- DBG(DBG_VERBOSE, "ep0in premature status\n");
+- if (req)
+- done(ep, req, 0);
+- ep0_idle(dev);
+- } else /* irq was IPR clearing */ {
+- if (req) {
+- /* this IN packet might finish the request */
+- (void) write_ep0_fifo(ep, req);
+- } /* else IN token before response was written */
+- }
+- break;
+- case EP0_OUT_DATA_PHASE: /* SET_DESCRIPTOR etc */
+- if (udccs0 & UDCCS0_OPR) {
+- if (req) {
+- /* this OUT packet might finish the request */
+- if (read_ep0_fifo(ep, req))
+- done(ep, req, 0);
+- /* else more OUT packets expected */
+- } /* else OUT token before read was issued */
+- } else /* irq was IPR clearing */ {
+- DBG(DBG_VERBOSE, "ep0out premature status\n");
+- if (req)
+- done(ep, req, 0);
+- ep0_idle(dev);
+- }
+- break;
+- case EP0_END_XFER:
+- if (req)
+- done(ep, req, 0);
+- /* ack control-IN status (maybe in-zlp was skipped)
+- * also appears after some config change events.
+- */
+- if (udccs0 & UDCCS0_OPR)
+- UDCCS0 = UDCCS0_OPR;
+- ep0_idle(dev);
+- break;
+- case EP0_STALL:
+- UDCCS0 = UDCCS0_FST;
+- break;
+- }
+- USIR0 = USIR0_IR0;
+-}
+-
+-static void handle_ep(struct pxa2xx_ep *ep)
+-{
+- struct pxa2xx_request *req;
+- int is_in = ep->bEndpointAddress & USB_DIR_IN;
+- int completed;
+- u32 udccs, tmp;
+-
+- do {
+- completed = 0;
+- if (likely (!list_empty(&ep->queue)))
+- req = list_entry(ep->queue.next,
+- struct pxa2xx_request, queue);
+- else
+- req = NULL;
+-
+- // TODO check FST handling
+-
+- udccs = *ep->reg_udccs;
+- if (unlikely(is_in)) { /* irq from TPC, SST, or (ISO) TUR */
+- tmp = UDCCS_BI_TUR;
+- if (likely(ep->bmAttributes == USB_ENDPOINT_XFER_BULK))
+- tmp |= UDCCS_BI_SST;
+- tmp &= udccs;
+- if (likely (tmp))
+- *ep->reg_udccs = tmp;
+- if (req && likely ((udccs & UDCCS_BI_TFS) != 0))
+- completed = write_fifo(ep, req);
+-
+- } else { /* irq from RPC (or for ISO, ROF) */
+- if (likely(ep->bmAttributes == USB_ENDPOINT_XFER_BULK))
+- tmp = UDCCS_BO_SST | UDCCS_BO_DME;
+- else
+- tmp = UDCCS_IO_ROF | UDCCS_IO_DME;
+- tmp &= udccs;
+- if (likely(tmp))
+- *ep->reg_udccs = tmp;
+-
+- /* fifos can hold packets, ready for reading... */
+- if (likely(req)) {
+- completed = read_fifo(ep, req);
+- } else
+- pio_irq_disable (ep->bEndpointAddress);
+- }
+- ep->pio_irqs++;
+- } while (completed);
+-}
+-
+-/*
+- * pxa2xx_udc_irq - interrupt handler
+- *
+- * avoid delays in ep0 processing. the control handshaking isn't always
+- * under software control (pxa250c0 and the pxa255 are better), and delays
+- * could cause usb protocol errors.
+- */
+-static irqreturn_t
+-pxa2xx_udc_irq(int irq, void *_dev)
+-{
+- struct pxa2xx_udc *dev = _dev;
+- int handled;
+-
+- dev->stats.irqs++;
+- do {
+- u32 udccr = UDCCR;
+-
+- handled = 0;
+-
+- /* SUSpend Interrupt Request */
+- if (unlikely(udccr & UDCCR_SUSIR)) {
+- udc_ack_int_UDCCR(UDCCR_SUSIR);
+- handled = 1;
+- DBG(DBG_VERBOSE, "USB suspend%s\n", is_vbus_present()
+- ? "" : "+disconnect");
+-
+- if (!is_vbus_present())
+- stop_activity(dev, dev->driver);
+- else if (dev->gadget.speed != USB_SPEED_UNKNOWN
+- && dev->driver
+- && dev->driver->suspend)
+- dev->driver->suspend(&dev->gadget);
+- ep0_idle (dev);
+- }
+-
+- /* RESume Interrupt Request */
+- if (unlikely(udccr & UDCCR_RESIR)) {
+- udc_ack_int_UDCCR(UDCCR_RESIR);
+- handled = 1;
+- DBG(DBG_VERBOSE, "USB resume\n");
+-
+- if (dev->gadget.speed != USB_SPEED_UNKNOWN
+- && dev->driver
+- && dev->driver->resume
+- && is_vbus_present())
+- dev->driver->resume(&dev->gadget);
+- }
+-
+- /* ReSeT Interrupt Request - USB reset */
+- if (unlikely(udccr & UDCCR_RSTIR)) {
+- udc_ack_int_UDCCR(UDCCR_RSTIR);
+- handled = 1;
+-
+- if ((UDCCR & UDCCR_UDA) == 0) {
+- DBG(DBG_VERBOSE, "USB reset start\n");
+-
+- /* reset driver and endpoints,
+- * in case that's not yet done
+- */
+- stop_activity (dev, dev->driver);
+-
+- } else {
+- DBG(DBG_VERBOSE, "USB reset end\n");
+- dev->gadget.speed = USB_SPEED_FULL;
+- memset(&dev->stats, 0, sizeof dev->stats);
+- /* driver and endpoints are still reset */
+- }
+-
+- } else {
+- u32 usir0 = USIR0 & ~UICR0;
+- u32 usir1 = USIR1 & ~UICR1;
+- int i;
+-
+- if (unlikely (!usir0 && !usir1))
+- continue;
+-
+- DBG(DBG_VERY_NOISY, "irq %02x.%02x\n", usir1, usir0);
+-
+- /* control traffic */
+- if (usir0 & USIR0_IR0) {
+- dev->ep[0].pio_irqs++;
+- handle_ep0(dev);
+- handled = 1;
+- }
+-
+- /* endpoint data transfers */
+- for (i = 0; i < 8; i++) {
+- u32 tmp = 1 << i;
+-
+- if (i && (usir0 & tmp)) {
+- handle_ep(&dev->ep[i]);
+- USIR0 |= tmp;
+- handled = 1;
+- }
+- if (usir1 & tmp) {
+- handle_ep(&dev->ep[i+8]);
+- USIR1 |= tmp;
+- handled = 1;
+- }
+- }
+- }
+-
+- /* we could also ask for 1 msec SOF (SIR) interrupts */
+-
+- } while (handled);
+- return IRQ_HANDLED;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static void nop_release (struct device *dev)
+-{
+- DMSG("%s %s\n", __func__, dev->bus_id);
+-}
+-
+-/* this uses load-time allocation and initialization (instead of
+- * doing it at run-time) to save code, eliminate fault paths, and
+- * be more obviously correct.
+- */
+-static struct pxa2xx_udc memory = {
+- .gadget = {
+- .ops = &pxa2xx_udc_ops,
+- .ep0 = &memory.ep[0].ep,
+- .name = driver_name,
+- .dev = {
+- .bus_id = "gadget",
+- .release = nop_release,
+- },
+- },
+-
+- /* control endpoint */
+- .ep[0] = {
+- .ep = {
+- .name = ep0name,
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = EP0_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .reg_udccs = &UDCCS0,
+- .reg_uddr = &UDDR0,
+- },
+-
+- /* first group of endpoints */
+- .ep[1] = {
+- .ep = {
+- .name = "ep1in-bulk",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = BULK_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = BULK_FIFO_SIZE,
+- .bEndpointAddress = USB_DIR_IN | 1,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .reg_udccs = &UDCCS1,
+- .reg_uddr = &UDDR1,
+- },
+- .ep[2] = {
+- .ep = {
+- .name = "ep2out-bulk",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = BULK_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = BULK_FIFO_SIZE,
+- .bEndpointAddress = 2,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .reg_udccs = &UDCCS2,
+- .reg_ubcr = &UBCR2,
+- .reg_uddr = &UDDR2,
+- },
+-#ifndef CONFIG_USB_PXA2XX_SMALL
+- .ep[3] = {
+- .ep = {
+- .name = "ep3in-iso",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = ISO_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = ISO_FIFO_SIZE,
+- .bEndpointAddress = USB_DIR_IN | 3,
+- .bmAttributes = USB_ENDPOINT_XFER_ISOC,
+- .reg_udccs = &UDCCS3,
+- .reg_uddr = &UDDR3,
+- },
+- .ep[4] = {
+- .ep = {
+- .name = "ep4out-iso",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = ISO_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = ISO_FIFO_SIZE,
+- .bEndpointAddress = 4,
+- .bmAttributes = USB_ENDPOINT_XFER_ISOC,
+- .reg_udccs = &UDCCS4,
+- .reg_ubcr = &UBCR4,
+- .reg_uddr = &UDDR4,
+- },
+- .ep[5] = {
+- .ep = {
+- .name = "ep5in-int",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = INT_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = INT_FIFO_SIZE,
+- .bEndpointAddress = USB_DIR_IN | 5,
+- .bmAttributes = USB_ENDPOINT_XFER_INT,
+- .reg_udccs = &UDCCS5,
+- .reg_uddr = &UDDR5,
+- },
+-
+- /* second group of endpoints */
+- .ep[6] = {
+- .ep = {
+- .name = "ep6in-bulk",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = BULK_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = BULK_FIFO_SIZE,
+- .bEndpointAddress = USB_DIR_IN | 6,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .reg_udccs = &UDCCS6,
+- .reg_uddr = &UDDR6,
+- },
+- .ep[7] = {
+- .ep = {
+- .name = "ep7out-bulk",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = BULK_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = BULK_FIFO_SIZE,
+- .bEndpointAddress = 7,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .reg_udccs = &UDCCS7,
+- .reg_ubcr = &UBCR7,
+- .reg_uddr = &UDDR7,
+- },
+- .ep[8] = {
+- .ep = {
+- .name = "ep8in-iso",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = ISO_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = ISO_FIFO_SIZE,
+- .bEndpointAddress = USB_DIR_IN | 8,
+- .bmAttributes = USB_ENDPOINT_XFER_ISOC,
+- .reg_udccs = &UDCCS8,
+- .reg_uddr = &UDDR8,
+- },
+- .ep[9] = {
+- .ep = {
+- .name = "ep9out-iso",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = ISO_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = ISO_FIFO_SIZE,
+- .bEndpointAddress = 9,
+- .bmAttributes = USB_ENDPOINT_XFER_ISOC,
+- .reg_udccs = &UDCCS9,
+- .reg_ubcr = &UBCR9,
+- .reg_uddr = &UDDR9,
+- },
+- .ep[10] = {
+- .ep = {
+- .name = "ep10in-int",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = INT_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = INT_FIFO_SIZE,
+- .bEndpointAddress = USB_DIR_IN | 10,
+- .bmAttributes = USB_ENDPOINT_XFER_INT,
+- .reg_udccs = &UDCCS10,
+- .reg_uddr = &UDDR10,
+- },
+-
+- /* third group of endpoints */
+- .ep[11] = {
+- .ep = {
+- .name = "ep11in-bulk",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = BULK_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = BULK_FIFO_SIZE,
+- .bEndpointAddress = USB_DIR_IN | 11,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .reg_udccs = &UDCCS11,
+- .reg_uddr = &UDDR11,
+- },
+- .ep[12] = {
+- .ep = {
+- .name = "ep12out-bulk",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = BULK_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = BULK_FIFO_SIZE,
+- .bEndpointAddress = 12,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .reg_udccs = &UDCCS12,
+- .reg_ubcr = &UBCR12,
+- .reg_uddr = &UDDR12,
+- },
+- .ep[13] = {
+- .ep = {
+- .name = "ep13in-iso",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = ISO_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = ISO_FIFO_SIZE,
+- .bEndpointAddress = USB_DIR_IN | 13,
+- .bmAttributes = USB_ENDPOINT_XFER_ISOC,
+- .reg_udccs = &UDCCS13,
+- .reg_uddr = &UDDR13,
+- },
+- .ep[14] = {
+- .ep = {
+- .name = "ep14out-iso",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = ISO_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = ISO_FIFO_SIZE,
+- .bEndpointAddress = 14,
+- .bmAttributes = USB_ENDPOINT_XFER_ISOC,
+- .reg_udccs = &UDCCS14,
+- .reg_ubcr = &UBCR14,
+- .reg_uddr = &UDDR14,
+- },
+- .ep[15] = {
+- .ep = {
+- .name = "ep15in-int",
+- .ops = &pxa2xx_ep_ops,
+- .maxpacket = INT_FIFO_SIZE,
+- },
+- .dev = &memory,
+- .fifo_size = INT_FIFO_SIZE,
+- .bEndpointAddress = USB_DIR_IN | 15,
+- .bmAttributes = USB_ENDPOINT_XFER_INT,
+- .reg_udccs = &UDCCS15,
+- .reg_uddr = &UDDR15,
+- },
+-#endif /* !CONFIG_USB_PXA2XX_SMALL */
+-};
+-
+-#define CP15R0_VENDOR_MASK 0xffffe000
+-
+-#if defined(CONFIG_ARCH_PXA)
+-#define CP15R0_XSCALE_VALUE 0x69052000 /* intel/arm/xscale */
+-
+-#elif defined(CONFIG_ARCH_IXP4XX)
+-#define CP15R0_XSCALE_VALUE 0x69054000 /* intel/arm/ixp4xx */
+-
+-#endif
+-
+-#define CP15R0_PROD_MASK 0x000003f0
+-#define PXA25x 0x00000100 /* and PXA26x */
+-#define PXA210 0x00000120
+-
+-#define CP15R0_REV_MASK 0x0000000f
+-
+-#define CP15R0_PRODREV_MASK (CP15R0_PROD_MASK | CP15R0_REV_MASK)
+-
+-#define PXA255_A0 0x00000106 /* or PXA260_B1 */
+-#define PXA250_C0 0x00000105 /* or PXA26x_B0 */
+-#define PXA250_B2 0x00000104
+-#define PXA250_B1 0x00000103 /* or PXA260_A0 */
+-#define PXA250_B0 0x00000102
+-#define PXA250_A1 0x00000101
+-#define PXA250_A0 0x00000100
+-
+-#define PXA210_C0 0x00000125
+-#define PXA210_B2 0x00000124
+-#define PXA210_B1 0x00000123
+-#define PXA210_B0 0x00000122
+-#define IXP425_A0 0x000001c1
+-#define IXP425_B0 0x000001f1
+-#define IXP465_AD 0x00000200
+-
+-/*
+- * probe - binds to the platform device
+- */
+-static int __init pxa2xx_udc_probe(struct platform_device *pdev)
+-{
+- struct pxa2xx_udc *dev = &memory;
+- int retval, vbus_irq, irq;
+- u32 chiprev;
+-
+- /* insist on Intel/ARM/XScale */
+- asm("mrc%? p15, 0, %0, c0, c0" : "=r" (chiprev));
+- if ((chiprev & CP15R0_VENDOR_MASK) != CP15R0_XSCALE_VALUE) {
+- pr_err("%s: not XScale!\n", driver_name);
+- return -ENODEV;
+- }
+-
+- /* trigger chiprev-specific logic */
+- switch (chiprev & CP15R0_PRODREV_MASK) {
+-#if defined(CONFIG_ARCH_PXA)
+- case PXA255_A0:
+- dev->has_cfr = 1;
+- break;
+- case PXA250_A0:
+- case PXA250_A1:
+- /* A0/A1 "not released"; ep 13, 15 unusable */
+- /* fall through */
+- case PXA250_B2: case PXA210_B2:
+- case PXA250_B1: case PXA210_B1:
+- case PXA250_B0: case PXA210_B0:
+- /* OUT-DMA is broken ... */
+- /* fall through */
+- case PXA250_C0: case PXA210_C0:
+- break;
+-#elif defined(CONFIG_ARCH_IXP4XX)
+- case IXP425_A0:
+- case IXP425_B0:
+- case IXP465_AD:
+- dev->has_cfr = 1;
+- break;
+-#endif
+- default:
+- pr_err("%s: unrecognized processor: %08x\n",
+- driver_name, chiprev);
+- /* iop3xx, ixp4xx, ... */
+- return -ENODEV;
+- }
+-
+- irq = platform_get_irq(pdev, 0);
+- if (irq < 0)
+- return -ENODEV;
+-
+- dev->clk = clk_get(&pdev->dev, "UDCCLK");
+- if (IS_ERR(dev->clk)) {
+- retval = PTR_ERR(dev->clk);
+- goto err_clk;
+- }
+-
+- pr_debug("%s: IRQ %d%s%s\n", driver_name, irq,
+- dev->has_cfr ? "" : " (!cfr)",
+- SIZE_STR "(pio)"
+- );
+-
+- /* other non-static parts of init */
+- dev->dev = &pdev->dev;
+- dev->mach = pdev->dev.platform_data;
+-
+- if (dev->mach->gpio_vbus) {
+- if ((retval = gpio_request(dev->mach->gpio_vbus,
+- "pxa2xx_udc GPIO VBUS"))) {
+- dev_dbg(&pdev->dev,
+- "can't get vbus gpio %d, err: %d\n",
+- dev->mach->gpio_vbus, retval);
+- goto err_gpio_vbus;
+- }
+- gpio_direction_input(dev->mach->gpio_vbus);
+- vbus_irq = gpio_to_irq(dev->mach->gpio_vbus);
+- } else
+- vbus_irq = 0;
+-
+- if (dev->mach->gpio_pullup) {
+- if ((retval = gpio_request(dev->mach->gpio_pullup,
+- "pca2xx_udc GPIO PULLUP"))) {
+- dev_dbg(&pdev->dev,
+- "can't get pullup gpio %d, err: %d\n",
+- dev->mach->gpio_pullup, retval);
+- goto err_gpio_pullup;
+- }
+- gpio_direction_output(dev->mach->gpio_pullup, 0);
+- }
+-
+- init_timer(&dev->timer);
+- dev->timer.function = udc_watchdog;
+- dev->timer.data = (unsigned long) dev;
+-
+- device_initialize(&dev->gadget.dev);
+- dev->gadget.dev.parent = &pdev->dev;
+- dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
+-
+- the_controller = dev;
+- platform_set_drvdata(pdev, dev);
+-
+- udc_disable(dev);
+- udc_reinit(dev);
+-
+- dev->vbus = is_vbus_present();
+-
+- /* irq setup after old hardware state is cleaned up */
+- retval = request_irq(irq, pxa2xx_udc_irq,
+- IRQF_DISABLED, driver_name, dev);
+- if (retval != 0) {
+- pr_err("%s: can't get irq %d, err %d\n",
+- driver_name, irq, retval);
+- goto err_irq1;
+- }
+- dev->got_irq = 1;
+-
+-#ifdef CONFIG_ARCH_LUBBOCK
+- if (machine_is_lubbock()) {
+- retval = request_irq(LUBBOCK_USB_DISC_IRQ,
+- lubbock_vbus_irq,
+- IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
+- driver_name, dev);
+- if (retval != 0) {
+- pr_err("%s: can't get irq %i, err %d\n",
+- driver_name, LUBBOCK_USB_DISC_IRQ, retval);
+-lubbock_fail0:
+- goto err_irq_lub;
+- }
+- retval = request_irq(LUBBOCK_USB_IRQ,
+- lubbock_vbus_irq,
+- IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
+- driver_name, dev);
+- if (retval != 0) {
+- pr_err("%s: can't get irq %i, err %d\n",
+- driver_name, LUBBOCK_USB_IRQ, retval);
+- free_irq(LUBBOCK_USB_DISC_IRQ, dev);
+- goto lubbock_fail0;
+- }
+- } else
+-#endif
+- if (vbus_irq) {
+- retval = request_irq(vbus_irq, udc_vbus_irq,
+- IRQF_DISABLED | IRQF_SAMPLE_RANDOM |
+- IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+- driver_name, dev);
+- if (retval != 0) {
+- pr_err("%s: can't get irq %i, err %d\n",
+- driver_name, vbus_irq, retval);
+- goto err_vbus_irq;
+- }
+- }
+- create_debug_files(dev);
+-
+- return 0;
+-
+- err_vbus_irq:
+-#ifdef CONFIG_ARCH_LUBBOCK
+- free_irq(LUBBOCK_USB_DISC_IRQ, dev);
+- err_irq_lub:
+-#endif
+- free_irq(irq, dev);
+- err_irq1:
+- if (dev->mach->gpio_pullup)
+- gpio_free(dev->mach->gpio_pullup);
+- err_gpio_pullup:
+- if (dev->mach->gpio_vbus)
+- gpio_free(dev->mach->gpio_vbus);
+- err_gpio_vbus:
+- clk_put(dev->clk);
+- err_clk:
+- return retval;
+-}
+-
+-static void pxa2xx_udc_shutdown(struct platform_device *_dev)
+-{
+- pullup_off();
+-}
+-
+-static int __exit pxa2xx_udc_remove(struct platform_device *pdev)
+-{
+- struct pxa2xx_udc *dev = platform_get_drvdata(pdev);
+-
+- if (dev->driver)
+- return -EBUSY;
+-
+- dev->pullup = 0;
+- pullup(dev);
+-
+- remove_debug_files(dev);
+-
+- if (dev->got_irq) {
+- free_irq(platform_get_irq(pdev, 0), dev);
+- dev->got_irq = 0;
+- }
+-#ifdef CONFIG_ARCH_LUBBOCK
+- if (machine_is_lubbock()) {
+- free_irq(LUBBOCK_USB_DISC_IRQ, dev);
+- free_irq(LUBBOCK_USB_IRQ, dev);
+- }
+-#endif
+- if (dev->mach->gpio_vbus) {
+- free_irq(gpio_to_irq(dev->mach->gpio_vbus), dev);
+- gpio_free(dev->mach->gpio_vbus);
+- }
+- if (dev->mach->gpio_pullup)
+- gpio_free(dev->mach->gpio_pullup);
+-
+- clk_put(dev->clk);
+-
+- platform_set_drvdata(pdev, NULL);
+- the_controller = NULL;
+- return 0;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-#ifdef CONFIG_PM
+-
+-/* USB suspend (controlled by the host) and system suspend (controlled
+- * by the PXA) don't necessarily work well together. If USB is active,
+- * the 48 MHz clock is required; so the system can't enter 33 MHz idle
+- * mode, or any deeper PM saving state.
+- *
+- * For now, we punt and forcibly disconnect from the USB host when PXA
+- * enters any suspend state. While we're disconnected, we always disable
+- * the 48MHz USB clock ... allowing PXA sleep and/or 33 MHz idle states.
+- * Boards without software pullup control shouldn't use those states.
+- * VBUS IRQs should probably be ignored so that the PXA device just acts
+- * "dead" to USB hosts until system resume.
+- */
+-static int pxa2xx_udc_suspend(struct platform_device *dev, pm_message_t state)
+-{
+- struct pxa2xx_udc *udc = platform_get_drvdata(dev);
+- unsigned long flags;
+-
+- if (!udc->mach->gpio_pullup && !udc->mach->udc_command)
+- WARN("USB host won't detect disconnect!\n");
+- udc->suspended = 1;
+-
+- local_irq_save(flags);
+- pullup(udc);
+- local_irq_restore(flags);
+-
+- return 0;
+-}
+-
+-static int pxa2xx_udc_resume(struct platform_device *dev)
+-{
+- struct pxa2xx_udc *udc = platform_get_drvdata(dev);
+- unsigned long flags;
+-
+- udc->suspended = 0;
+- local_irq_save(flags);
+- pullup(udc);
+- local_irq_restore(flags);
+-
+- return 0;
+-}
+-
+-#else
+-#define pxa2xx_udc_suspend NULL
+-#define pxa2xx_udc_resume NULL
+-#endif
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static struct platform_driver udc_driver = {
+- .shutdown = pxa2xx_udc_shutdown,
+- .remove = __exit_p(pxa2xx_udc_remove),
+- .suspend = pxa2xx_udc_suspend,
+- .resume = pxa2xx_udc_resume,
+- .driver = {
+- .owner = THIS_MODULE,
+- .name = "pxa2xx-udc",
+- },
+-};
+-
+-static int __init udc_init(void)
+-{
+- pr_info("%s: version %s\n", driver_name, DRIVER_VERSION);
+- return platform_driver_probe(&udc_driver, pxa2xx_udc_probe);
+-}
+-module_init(udc_init);
+-
+-static void __exit udc_exit(void)
+-{
+- platform_driver_unregister(&udc_driver);
+-}
+-module_exit(udc_exit);
+-
+-MODULE_DESCRIPTION(DRIVER_DESC);
+-MODULE_AUTHOR("Frank Becker, Robert Schwebel, David Brownell");
+-MODULE_LICENSE("GPL");
+-MODULE_ALIAS("platform:pxa2xx-udc");
+diff --git a/drivers/usb/gadget/pxa2xx_udc.h b/drivers/usb/gadget/pxa2xx_udc.h
+deleted file mode 100644
+index e2c19e8..0000000
+--- a/drivers/usb/gadget/pxa2xx_udc.h
++++ /dev/null
+@@ -1,267 +0,0 @@
+-/*
+- * linux/drivers/usb/gadget/pxa2xx_udc.h
+- * Intel PXA2xx on-chip full speed USB device controller
+- *
+- * Copyright (C) 2003 Robert Schwebel <r.schwebel@pengutronix.de>, Pengutronix
+- * Copyright (C) 2003 David Brownell
+- *
+- *
+- * 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.
+- *
+- * This program is distributed in the hope that it will be useful,
+- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+- * GNU General Public License for more details.
+- *
+- * You should have received a copy of the GNU General Public License
+- * along with this program; if not, write to the Free Software
+- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+- */
+-
+-#ifndef __LINUX_USB_GADGET_PXA2XX_H
+-#define __LINUX_USB_GADGET_PXA2XX_H
+-
+-#include <linux/types.h>
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/* pxa2xx has this (move to include/asm-arm/arch-pxa/pxa-regs.h) */
+-#define UFNRH_SIR (1 << 7) /* SOF interrupt request */
+-#define UFNRH_SIM (1 << 6) /* SOF interrupt mask */
+-#define UFNRH_IPE14 (1 << 5) /* ISO packet error, ep14 */
+-#define UFNRH_IPE9 (1 << 4) /* ISO packet error, ep9 */
+-#define UFNRH_IPE4 (1 << 3) /* ISO packet error, ep4 */
+-
+-/* pxa255 has this (move to include/asm-arm/arch-pxa/pxa-regs.h) */
+-#define UDCCFR UDC_RES2 /* UDC Control Function Register */
+-#define UDCCFR_AREN (1 << 7) /* ACK response enable (now) */
+-#define UDCCFR_ACM (1 << 2) /* ACK control mode (wait for AREN) */
+-
+-/* latest pxa255 errata define new "must be one" bits in UDCCFR */
+-#define UDCCFR_MB1 (0xff & ~(UDCCFR_AREN|UDCCFR_ACM))
+-
+-/*-------------------------------------------------------------------------*/
+-
+-struct pxa2xx_udc;
+-
+-struct pxa2xx_ep {
+- struct usb_ep ep;
+- struct pxa2xx_udc *dev;
+-
+- const struct usb_endpoint_descriptor *desc;
+- struct list_head queue;
+- unsigned long pio_irqs;
+-
+- unsigned short fifo_size;
+- u8 bEndpointAddress;
+- u8 bmAttributes;
+-
+- unsigned stopped : 1;
+- unsigned dma_fixup : 1;
+-
+- /* UDCCS = UDC Control/Status for this EP
+- * UBCR = UDC Byte Count Remaining (contents of OUT fifo)
+- * UDDR = UDC Endpoint Data Register (the fifo)
+- * DRCM = DMA Request Channel Map
+- */
+- volatile u32 *reg_udccs;
+- volatile u32 *reg_ubcr;
+- volatile u32 *reg_uddr;
+-};
+-
+-struct pxa2xx_request {
+- struct usb_request req;
+- struct list_head queue;
+-};
+-
+-enum ep0_state {
+- EP0_IDLE,
+- EP0_IN_DATA_PHASE,
+- EP0_OUT_DATA_PHASE,
+- EP0_END_XFER,
+- EP0_STALL,
+-};
+-
+-#define EP0_FIFO_SIZE ((unsigned)16)
+-#define BULK_FIFO_SIZE ((unsigned)64)
+-#define ISO_FIFO_SIZE ((unsigned)256)
+-#define INT_FIFO_SIZE ((unsigned)8)
+-
+-struct udc_stats {
+- struct ep0stats {
+- unsigned long ops;
+- unsigned long bytes;
+- } read, write;
+- unsigned long irqs;
+-};
+-
+-#ifdef CONFIG_USB_PXA2XX_SMALL
+-/* when memory's tight, SMALL config saves code+data. */
+-#define PXA_UDC_NUM_ENDPOINTS 3
+-#endif
+-
+-#ifndef PXA_UDC_NUM_ENDPOINTS
+-#define PXA_UDC_NUM_ENDPOINTS 16
+-#endif
+-
+-struct pxa2xx_udc {
+- struct usb_gadget gadget;
+- struct usb_gadget_driver *driver;
+-
+- enum ep0_state ep0state;
+- struct udc_stats stats;
+- unsigned got_irq : 1,
+- vbus : 1,
+- pullup : 1,
+- has_cfr : 1,
+- req_pending : 1,
+- req_std : 1,
+- req_config : 1,
+- suspended : 1,
+- active : 1;
+-
+-#define start_watchdog(dev) mod_timer(&dev->timer, jiffies + (HZ/200))
+- struct timer_list timer;
+-
+- struct device *dev;
+- struct clk *clk;
+- struct pxa2xx_udc_mach_info *mach;
+- u64 dma_mask;
+- struct pxa2xx_ep ep [PXA_UDC_NUM_ENDPOINTS];
+-
+-#ifdef CONFIG_USB_GADGET_DEBUG_FS
+- struct dentry *debugfs_udc;
+-#endif
+-};
+-
+-/*-------------------------------------------------------------------------*/
+-
+-#ifdef CONFIG_ARCH_LUBBOCK
+-#include <asm/arch/lubbock.h>
+-/* lubbock can also report usb connect/disconnect irqs */
+-#endif
+-
+-static struct pxa2xx_udc *the_controller;
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/*
+- * Debugging support vanishes in non-debug builds. DBG_NORMAL should be
+- * mostly silent during normal use/testing, with no timing side-effects.
+- */
+-#define DBG_NORMAL 1 /* error paths, device state transitions */
+-#define DBG_VERBOSE 2 /* add some success path trace info */
+-#define DBG_NOISY 3 /* ... even more: request level */
+-#define DBG_VERY_NOISY 4 /* ... even more: packet level */
+-
+-#define DMSG(stuff...) pr_debug("udc: " stuff)
+-
+-#ifdef DEBUG
+-
+-static int is_vbus_present(void);
+-
+-static const char *state_name[] = {
+- "EP0_IDLE",
+- "EP0_IN_DATA_PHASE", "EP0_OUT_DATA_PHASE",
+- "EP0_END_XFER", "EP0_STALL"
+-};
+-
+-#ifdef VERBOSE_DEBUG
+-# define UDC_DEBUG DBG_VERBOSE
+-#else
+-# define UDC_DEBUG DBG_NORMAL
+-#endif
+-
+-static void __maybe_unused
+-dump_udccr(const char *label)
+-{
+- u32 udccr = UDCCR;
+- DMSG("%s %02X =%s%s%s%s%s%s%s%s\n",
+- label, udccr,
+- (udccr & UDCCR_REM) ? " rem" : "",
+- (udccr & UDCCR_RSTIR) ? " rstir" : "",
+- (udccr & UDCCR_SRM) ? " srm" : "",
+- (udccr & UDCCR_SUSIR) ? " susir" : "",
+- (udccr & UDCCR_RESIR) ? " resir" : "",
+- (udccr & UDCCR_RSM) ? " rsm" : "",
+- (udccr & UDCCR_UDA) ? " uda" : "",
+- (udccr & UDCCR_UDE) ? " ude" : "");
+-}
+-
+-static void __maybe_unused
+-dump_udccs0(const char *label)
+-{
+- u32 udccs0 = UDCCS0;
+-
+- DMSG("%s %s %02X =%s%s%s%s%s%s%s%s\n",
+- label, state_name[the_controller->ep0state], udccs0,
+- (udccs0 & UDCCS0_SA) ? " sa" : "",
+- (udccs0 & UDCCS0_RNE) ? " rne" : "",
+- (udccs0 & UDCCS0_FST) ? " fst" : "",
+- (udccs0 & UDCCS0_SST) ? " sst" : "",
+- (udccs0 & UDCCS0_DRWF) ? " dwrf" : "",
+- (udccs0 & UDCCS0_FTF) ? " ftf" : "",
+- (udccs0 & UDCCS0_IPR) ? " ipr" : "",
+- (udccs0 & UDCCS0_OPR) ? " opr" : "");
+-}
+-
+-static void __maybe_unused
+-dump_state(struct pxa2xx_udc *dev)
+-{
+- u32 tmp;
+- unsigned i;
+-
+- DMSG("%s %s, uicr %02X.%02X, usir %02X.%02x, ufnr %02X.%02X\n",
+- is_vbus_present() ? "host " : "disconnected",
+- state_name[dev->ep0state],
+- UICR1, UICR0, USIR1, USIR0, UFNRH, UFNRL);
+- dump_udccr("udccr");
+- if (dev->has_cfr) {
+- tmp = UDCCFR;
+- DMSG("udccfr %02X =%s%s\n", tmp,
+- (tmp & UDCCFR_AREN) ? " aren" : "",
+- (tmp & UDCCFR_ACM) ? " acm" : "");
+- }
+-
+- if (!dev->driver) {
+- DMSG("no gadget driver bound\n");
+- return;
+- } else
+- DMSG("ep0 driver '%s'\n", dev->driver->driver.name);
+-
+- if (!is_vbus_present())
+- return;
+-
+- dump_udccs0 ("udccs0");
+- DMSG("ep0 IN %lu/%lu, OUT %lu/%lu\n",
+- dev->stats.write.bytes, dev->stats.write.ops,
+- dev->stats.read.bytes, dev->stats.read.ops);
+-
+- for (i = 1; i < PXA_UDC_NUM_ENDPOINTS; i++) {
+- if (dev->ep [i].desc == NULL)
+- continue;
+- DMSG ("udccs%d = %02x\n", i, *dev->ep->reg_udccs);
+- }
+-}
+-
+-#else
+-
+-#define dump_udccr(x) do{}while(0)
+-#define dump_udccs0(x) do{}while(0)
+-#define dump_state(x) do{}while(0)
+-
+-#define UDC_DEBUG ((unsigned)0)
+-
+-#endif
+-
+-#define DBG(lvl, stuff...) do{if ((lvl) <= UDC_DEBUG) DMSG(stuff);}while(0)
+-
+-#define ERR(stuff...) pr_err("udc: " stuff)
+-#define WARN(stuff...) pr_warning("udc: " stuff)
+-#define INFO(stuff...) pr_info("udc: " stuff)
+-
+-
+-#endif /* __LINUX_USB_GADGET_PXA2XX_H */
+diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
+index d0677f5..7228e85 100644
+--- a/drivers/usb/gadget/rndis.c
++++ b/drivers/usb/gadget/rndis.c
+@@ -1,8 +1,6 @@
+ /*
+ * RNDIS MSG parser
+ *
+- * Version: $Id: rndis.c,v 1.19 2004/03/25 21:33:46 robert Exp $
+- *
+ * Authors: Benedikt Spranger, Pengutronix
+ * Robert Schwebel, Pengutronix
+ *
+@@ -30,6 +28,7 @@
+ #include <linux/init.h>
+ #include <linux/list.h>
+ #include <linux/proc_fs.h>
++#include <linux/seq_file.h>
+ #include <linux/netdevice.h>
+
+ #include <asm/io.h>
+@@ -38,9 +37,7 @@
+ #include <asm/unaligned.h>
+
+
+-#undef RNDIS_PM
+-#undef RNDIS_WAKEUP
+-#undef VERBOSE
++#undef VERBOSE_DEBUG
+
+ #include "rndis.h"
+
+@@ -96,9 +93,6 @@ static const u32 oid_supported_list [] =
+ OID_GEN_MAXIMUM_TOTAL_SIZE,
+ OID_GEN_MEDIA_CONNECT_STATUS,
+ OID_GEN_PHYSICAL_MEDIUM,
+-#if 0
+- OID_GEN_RNDIS_CONFIG_PARAMETER,
+-#endif
+
+ /* the statistical stuff */
+ OID_GEN_XMIT_OK,
+@@ -146,7 +140,14 @@ static const u32 oid_supported_list [] =
+ #endif /* RNDIS_OPTIONAL_STATS */
+
+ #ifdef RNDIS_PM
+- /* PM and wakeup are mandatory for USB: */
++ /* PM and wakeup are "mandatory" for USB, but the RNDIS specs
++ * don't say what they mean ... and the NDIS specs are often
++ * confusing and/or ambiguous in this context. (That is, more
++ * so than their specs for the other OIDs.)
++ *
++ * FIXME someone who knows what these should do, please
++ * implement them!
++ */
+
+ /* power management */
+ OID_PNP_CAPABILITIES,
+@@ -173,6 +174,8 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
+ __le32 *outbuf;
+ int i, count;
+ rndis_query_cmplt_type *resp;
++ struct net_device *net;
++ struct net_device_stats *stats;
+
+ if (!r) return -ENOMEM;
+ resp = (rndis_query_cmplt_type *) r->buf;
+@@ -194,6 +197,12 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
+ outbuf = (__le32 *) &resp[1];
+ resp->InformationBufferOffset = __constant_cpu_to_le32 (16);
+
++ net = rndis_per_dev_params[configNr].dev;
++ if (net->get_stats)
++ stats = net->get_stats(net);
++ else
++ stats = NULL;
++
+ switch (OID) {
+
+ /* general oids (table 4-1) */
+@@ -350,11 +359,9 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
+ case OID_GEN_XMIT_OK:
+ if (rndis_debug > 1)
+ DBG("%s: OID_GEN_XMIT_OK\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (
+- rndis_per_dev_params [configNr].stats->tx_packets -
+- rndis_per_dev_params [configNr].stats->tx_errors -
+- rndis_per_dev_params [configNr].stats->tx_dropped);
++ if (stats) {
++ *outbuf = cpu_to_le32(stats->tx_packets
++ - stats->tx_errors - stats->tx_dropped);
+ retval = 0;
+ }
+ break;
+@@ -363,11 +370,9 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
+ case OID_GEN_RCV_OK:
+ if (rndis_debug > 1)
+ DBG("%s: OID_GEN_RCV_OK\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (
+- rndis_per_dev_params [configNr].stats->rx_packets -
+- rndis_per_dev_params [configNr].stats->rx_errors -
+- rndis_per_dev_params [configNr].stats->rx_dropped);
++ if (stats) {
++ *outbuf = cpu_to_le32(stats->rx_packets
++ - stats->rx_errors - stats->rx_dropped);
+ retval = 0;
+ }
+ break;
+@@ -376,9 +381,8 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
+ case OID_GEN_XMIT_ERROR:
+ if (rndis_debug > 1)
+ DBG("%s: OID_GEN_XMIT_ERROR\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->tx_errors);
++ if (stats) {
++ *outbuf = cpu_to_le32(stats->tx_errors);
+ retval = 0;
+ }
+ break;
+@@ -387,9 +391,8 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
+ case OID_GEN_RCV_ERROR:
+ if (rndis_debug > 1)
+ DBG("%s: OID_GEN_RCV_ERROR\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->rx_errors);
++ if (stats) {
++ *outbuf = cpu_to_le32(stats->rx_errors);
+ retval = 0;
+ }
+ break;
+@@ -397,150 +400,12 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
+ /* mandatory */
+ case OID_GEN_RCV_NO_BUFFER:
+ DBG("%s: OID_GEN_RCV_NO_BUFFER\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->rx_dropped);
+- retval = 0;
+- }
+- break;
+-
+-#ifdef RNDIS_OPTIONAL_STATS
+- case OID_GEN_DIRECTED_BYTES_XMIT:
+- DBG("%s: OID_GEN_DIRECTED_BYTES_XMIT\n", __func__);
+- /*
+- * Aunt Tilly's size of shoes
+- * minus antarctica count of penguins
+- * divided by weight of Alpha Centauri
+- */
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (
+- (rndis_per_dev_params [configNr]
+- .stats->tx_packets -
+- rndis_per_dev_params [configNr]
+- .stats->tx_errors -
+- rndis_per_dev_params [configNr]
+- .stats->tx_dropped)
+- * 123);
+- retval = 0;
+- }
+- break;
+-
+- case OID_GEN_DIRECTED_FRAMES_XMIT:
+- DBG("%s: OID_GEN_DIRECTED_FRAMES_XMIT\n", __func__);
+- /* dito */
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (
+- (rndis_per_dev_params [configNr]
+- .stats->tx_packets -
+- rndis_per_dev_params [configNr]
+- .stats->tx_errors -
+- rndis_per_dev_params [configNr]
+- .stats->tx_dropped)
+- / 123);
+- retval = 0;
+- }
+- break;
+-
+- case OID_GEN_MULTICAST_BYTES_XMIT:
+- DBG("%s: OID_GEN_MULTICAST_BYTES_XMIT\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->multicast*1234);
+- retval = 0;
+- }
+- break;
+-
+- case OID_GEN_MULTICAST_FRAMES_XMIT:
+- DBG("%s: OID_GEN_MULTICAST_FRAMES_XMIT\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->multicast);
+- retval = 0;
+- }
+- break;
+-
+- case OID_GEN_BROADCAST_BYTES_XMIT:
+- DBG("%s: OID_GEN_BROADCAST_BYTES_XMIT\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->tx_packets/42*255);
+- retval = 0;
+- }
+- break;
+-
+- case OID_GEN_BROADCAST_FRAMES_XMIT:
+- DBG("%s: OID_GEN_BROADCAST_FRAMES_XMIT\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->tx_packets/42);
+- retval = 0;
+- }
+- break;
+-
+- case OID_GEN_DIRECTED_BYTES_RCV:
+- DBG("%s: OID_GEN_DIRECTED_BYTES_RCV\n", __func__);
+- *outbuf = __constant_cpu_to_le32 (0);
+- retval = 0;
+- break;
+-
+- case OID_GEN_DIRECTED_FRAMES_RCV:
+- DBG("%s: OID_GEN_DIRECTED_FRAMES_RCV\n", __func__);
+- *outbuf = __constant_cpu_to_le32 (0);
+- retval = 0;
+- break;
+-
+- case OID_GEN_MULTICAST_BYTES_RCV:
+- DBG("%s: OID_GEN_MULTICAST_BYTES_RCV\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->multicast * 1111);
+- retval = 0;
+- }
+- break;
+-
+- case OID_GEN_MULTICAST_FRAMES_RCV:
+- DBG("%s: OID_GEN_MULTICAST_FRAMES_RCV\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->multicast);
+- retval = 0;
+- }
+- break;
+-
+- case OID_GEN_BROADCAST_BYTES_RCV:
+- DBG("%s: OID_GEN_BROADCAST_BYTES_RCV\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->rx_packets/42*255);
+- retval = 0;
+- }
+- break;
+-
+- case OID_GEN_BROADCAST_FRAMES_RCV:
+- DBG("%s: OID_GEN_BROADCAST_FRAMES_RCV\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->rx_packets/42);
++ if (stats) {
++ *outbuf = cpu_to_le32(stats->rx_dropped);
+ retval = 0;
+ }
+ break;
+
+- case OID_GEN_RCV_CRC_ERROR:
+- DBG("%s: OID_GEN_RCV_CRC_ERROR\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->rx_crc_errors);
+- retval = 0;
+- }
+- break;
+-
+- case OID_GEN_TRANSMIT_QUEUE_LENGTH:
+- DBG("%s: OID_GEN_TRANSMIT_QUEUE_LENGTH\n", __func__);
+- *outbuf = __constant_cpu_to_le32 (0);
+- retval = 0;
+- break;
+-#endif /* RNDIS_OPTIONAL_STATS */
+-
+ /* ieee802.3 OIDs (table 4-3) */
+
+ /* mandatory */
+@@ -592,9 +457,8 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
+ /* mandatory */
+ case OID_802_3_RCV_ERROR_ALIGNMENT:
+ DBG("%s: OID_802_3_RCV_ERROR_ALIGNMENT\n", __func__);
+- if (rndis_per_dev_params [configNr].stats) {
+- *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
+- .stats->rx_frame_errors);
++ if (stats) {
++ *outbuf = cpu_to_le32(stats->rx_frame_errors);
+ retval = 0;
+ }
+ break;
+@@ -613,64 +477,6 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
+ retval = 0;
+ break;
+
+-#ifdef RNDIS_OPTIONAL_STATS
+- case OID_802_3_XMIT_DEFERRED:
+- DBG("%s: OID_802_3_XMIT_DEFERRED\n", __func__);
+- /* TODO */
+- break;
+-
+- case OID_802_3_XMIT_MAX_COLLISIONS:
+- DBG("%s: OID_802_3_XMIT_MAX_COLLISIONS\n", __func__);
+- /* TODO */
+- break;
+-
+- case OID_802_3_RCV_OVERRUN:
+- DBG("%s: OID_802_3_RCV_OVERRUN\n", __func__);
+- /* TODO */
+- break;
+-
+- case OID_802_3_XMIT_UNDERRUN:
+- DBG("%s: OID_802_3_XMIT_UNDERRUN\n", __func__);
+- /* TODO */
+- break;
+-
+- case OID_802_3_XMIT_HEARTBEAT_FAILURE:
+- DBG("%s: OID_802_3_XMIT_HEARTBEAT_FAILURE\n", __func__);
+- /* TODO */
+- break;
+-
+- case OID_802_3_XMIT_TIMES_CRS_LOST:
+- DBG("%s: OID_802_3_XMIT_TIMES_CRS_LOST\n", __func__);
+- /* TODO */
+- break;
+-
+- case OID_802_3_XMIT_LATE_COLLISIONS:
+- DBG("%s: OID_802_3_XMIT_LATE_COLLISIONS\n", __func__);
+- /* TODO */
+- break;
+-#endif /* RNDIS_OPTIONAL_STATS */
+-
+-#ifdef RNDIS_PM
+- /* power management OIDs (table 4-5) */
+- case OID_PNP_CAPABILITIES:
+- DBG("%s: OID_PNP_CAPABILITIES\n", __func__);
+-
+- /* for now, no wakeup capabilities */
+- length = sizeof (struct NDIS_PNP_CAPABILITIES);
+- memset(outbuf, 0, length);
+- retval = 0;
+- break;
+- case OID_PNP_QUERY_POWER:
+- DBG("%s: OID_PNP_QUERY_POWER D%d\n", __func__,
+- get_unaligned_le32(buf) - 1);
+- /* only suspend is a real power state, and
+- * it can't be entered by OID_PNP_SET_POWER...
+- */
+- length = 0;
+- retval = 0;
+- break;
+-#endif
+-
+ default:
+ pr_warning("%s: query unknown OID 0x%08X\n",
+ __func__, OID);
+@@ -726,9 +532,6 @@ static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,
+ * what makes the packet flow start and stop, like
+ * activating the CDC Ethernet altsetting.
+ */
+-#ifdef RNDIS_PM
+-update_linkstate:
+-#endif
+ retval = 0;
+ if (*params->filter) {
+ params->state = RNDIS_DATA_INITIALIZED;
+@@ -747,49 +550,6 @@ update_linkstate:
+ DBG("%s: OID_802_3_MULTICAST_LIST\n", __func__);
+ retval = 0;
+ break;
+-#if 0
+- case OID_GEN_RNDIS_CONFIG_PARAMETER:
+- {
+- struct rndis_config_parameter *param;
+- param = (struct rndis_config_parameter *) buf;
+- DBG("%s: OID_GEN_RNDIS_CONFIG_PARAMETER '%*s'\n",
+- __func__,
+- min(cpu_to_le32(param->ParameterNameLength),80),
+- buf + param->ParameterNameOffset);
+- retval = 0;
+- }
+- break;
+-#endif
+-
+-#ifdef RNDIS_PM
+- case OID_PNP_SET_POWER:
+- /* The only real power state is USB suspend, and RNDIS requests
+- * can't enter it; this one isn't really about power. After
+- * resuming, Windows forces a reset, and then SET_POWER D0.
+- * FIXME ... then things go batty; Windows wedges itself.
+- */
+- i = get_unaligned_le32(buf);
+- DBG("%s: OID_PNP_SET_POWER D%d\n", __func__, i - 1);
+- switch (i) {
+- case NdisDeviceStateD0:
+- *params->filter = params->saved_filter;
+- goto update_linkstate;
+- case NdisDeviceStateD3:
+- case NdisDeviceStateD2:
+- case NdisDeviceStateD1:
+- params->saved_filter = *params->filter;
+- retval = 0;
+- break;
+- }
+- break;
+-
+-#ifdef RNDIS_WAKEUP
+- // no wakeup support advertised, so wakeup OIDs always fail:
+- // - OID_PNP_ENABLE_WAKE_UP
+- // - OID_PNP_{ADD,REMOVE}_WAKE_UP_PATTERN
+-#endif
+-
+-#endif /* RNDIS_PM */
+
+ default:
+ pr_warning("%s: set unknown OID 0x%08X, size %d\n",
+@@ -807,8 +567,10 @@ static int rndis_init_response (int configNr, rndis_init_msg_type *buf)
+ {
+ rndis_init_cmplt_type *resp;
+ rndis_resp_t *r;
++ struct rndis_params *params = rndis_per_dev_params + configNr;
+
+- if (!rndis_per_dev_params [configNr].dev) return -ENOTSUPP;
++ if (!params->dev)
++ return -ENOTSUPP;
+
+ r = rndis_add_response (configNr, sizeof (rndis_init_cmplt_type));
+ if (!r)
+@@ -826,7 +588,7 @@ static int rndis_init_response (int configNr, rndis_init_msg_type *buf)
+ resp->Medium = __constant_cpu_to_le32 (RNDIS_MEDIUM_802_3);
+ resp->MaxPacketsPerTransfer = __constant_cpu_to_le32 (1);
+ resp->MaxTransferSize = cpu_to_le32 (
+- rndis_per_dev_params [configNr].dev->mtu
++ params->dev->mtu
+ + sizeof (struct ethhdr)
+ + sizeof (struct rndis_packet_msg_type)
+ + 22);
+@@ -834,10 +596,7 @@ static int rndis_init_response (int configNr, rndis_init_msg_type *buf)
+ resp->AFListOffset = __constant_cpu_to_le32 (0);
+ resp->AFListSize = __constant_cpu_to_le32 (0);
+
+- if (rndis_per_dev_params [configNr].ack)
+- rndis_per_dev_params [configNr].ack (
+- rndis_per_dev_params [configNr].dev);
+-
++ params->resp_avail(params->v);
+ return 0;
+ }
+
+@@ -845,9 +604,11 @@ static int rndis_query_response (int configNr, rndis_query_msg_type *buf)
+ {
+ rndis_query_cmplt_type *resp;
+ rndis_resp_t *r;
++ struct rndis_params *params = rndis_per_dev_params + configNr;
+
+ // DBG("%s: OID = %08X\n", __func__, cpu_to_le32(buf->OID));
+- if (!rndis_per_dev_params [configNr].dev) return -ENOTSUPP;
++ if (!params->dev)
++ return -ENOTSUPP;
+
+ /*
+ * we need more memory:
+@@ -878,9 +639,7 @@ static int rndis_query_response (int configNr, rndis_query_msg_type *buf)
+ } else
+ resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
+
+- if (rndis_per_dev_params [configNr].ack)
+- rndis_per_dev_params [configNr].ack (
+- rndis_per_dev_params [configNr].dev);
++ params->resp_avail(params->v);
+ return 0;
+ }
+
+@@ -889,6 +648,7 @@ static int rndis_set_response (int configNr, rndis_set_msg_type *buf)
+ u32 BufLength, BufOffset;
+ rndis_set_cmplt_type *resp;
+ rndis_resp_t *r;
++ struct rndis_params *params = rndis_per_dev_params + configNr;
+
+ r = rndis_add_response (configNr, sizeof (rndis_set_cmplt_type));
+ if (!r)
+@@ -898,7 +658,7 @@ static int rndis_set_response (int configNr, rndis_set_msg_type *buf)
+ BufLength = le32_to_cpu (buf->InformationBufferLength);
+ BufOffset = le32_to_cpu (buf->InformationBufferOffset);
+
+-#ifdef VERBOSE
++#ifdef VERBOSE_DEBUG
+ DBG("%s: Length: %d\n", __func__, BufLength);
+ DBG("%s: Offset: %d\n", __func__, BufOffset);
+ DBG("%s: InfoBuffer: ", __func__);
+@@ -919,10 +679,7 @@ static int rndis_set_response (int configNr, rndis_set_msg_type *buf)
+ else
+ resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
+
+- if (rndis_per_dev_params [configNr].ack)
+- rndis_per_dev_params [configNr].ack (
+- rndis_per_dev_params [configNr].dev);
+-
++ params->resp_avail(params->v);
+ return 0;
+ }
+
+@@ -930,6 +687,7 @@ static int rndis_reset_response (int configNr, rndis_reset_msg_type *buf)
+ {
+ rndis_reset_cmplt_type *resp;
+ rndis_resp_t *r;
++ struct rndis_params *params = rndis_per_dev_params + configNr;
+
+ r = rndis_add_response (configNr, sizeof (rndis_reset_cmplt_type));
+ if (!r)
+@@ -942,10 +700,7 @@ static int rndis_reset_response (int configNr, rndis_reset_msg_type *buf)
+ /* resent information */
+ resp->AddressingReset = __constant_cpu_to_le32 (1);
+
+- if (rndis_per_dev_params [configNr].ack)
+- rndis_per_dev_params [configNr].ack (
+- rndis_per_dev_params [configNr].dev);
+-
++ params->resp_avail(params->v);
+ return 0;
+ }
+
+@@ -954,6 +709,7 @@ static int rndis_keepalive_response (int configNr,
+ {
+ rndis_keepalive_cmplt_type *resp;
+ rndis_resp_t *r;
++ struct rndis_params *params = rndis_per_dev_params + configNr;
+
+ /* host "should" check only in RNDIS_DATA_INITIALIZED state */
+
+@@ -968,10 +724,7 @@ static int rndis_keepalive_response (int configNr,
+ resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
+ resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
+
+- if (rndis_per_dev_params [configNr].ack)
+- rndis_per_dev_params [configNr].ack (
+- rndis_per_dev_params [configNr].dev);
+-
++ params->resp_avail(params->v);
+ return 0;
+ }
+
+@@ -983,8 +736,9 @@ static int rndis_indicate_status_msg (int configNr, u32 status)
+ {
+ rndis_indicate_status_msg_type *resp;
+ rndis_resp_t *r;
++ struct rndis_params *params = rndis_per_dev_params + configNr;
+
+- if (rndis_per_dev_params [configNr].state == RNDIS_UNINITIALIZED)
++ if (params->state == RNDIS_UNINITIALIZED)
+ return -ENOTSUPP;
+
+ r = rndis_add_response (configNr,
+@@ -1000,9 +754,7 @@ static int rndis_indicate_status_msg (int configNr, u32 status)
+ resp->StatusBufferLength = __constant_cpu_to_le32 (0);
+ resp->StatusBufferOffset = __constant_cpu_to_le32 (0);
+
+- if (rndis_per_dev_params [configNr].ack)
+- rndis_per_dev_params [configNr].ack (
+- rndis_per_dev_params [configNr].dev);
++ params->resp_avail(params->v);
+ return 0;
+ }
+
+@@ -1029,7 +781,6 @@ void rndis_uninit (int configNr)
+
+ if (configNr >= RNDIS_MAX_CONFIGS)
+ return;
+- rndis_per_dev_params [configNr].used = 0;
+ rndis_per_dev_params [configNr].state = RNDIS_UNINITIALIZED;
+
+ /* drain the response queue */
+@@ -1142,21 +893,25 @@ int rndis_msg_parser (u8 configNr, u8 *buf)
+ return -ENOTSUPP;
+ }
+
+-int rndis_register (int (* rndis_control_ack) (struct net_device *))
++int rndis_register(void (*resp_avail)(void *v), void *v)
+ {
+ u8 i;
+
++ if (!resp_avail)
++ return -EINVAL;
++
+ for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
+ if (!rndis_per_dev_params [i].used) {
+ rndis_per_dev_params [i].used = 1;
+- rndis_per_dev_params [i].ack = rndis_control_ack;
++ rndis_per_dev_params [i].resp_avail = resp_avail;
++ rndis_per_dev_params [i].v = v;
+ DBG("%s: configNr = %d\n", __func__, i);
+ return i;
+ }
+ }
+ DBG("failed\n");
+
+- return -1;
++ return -ENODEV;
+ }
+
+ void rndis_deregister (int configNr)
+@@ -1169,16 +924,14 @@ void rndis_deregister (int configNr)
+ return;
+ }
+
+-int rndis_set_param_dev (u8 configNr, struct net_device *dev,
+- struct net_device_stats *stats,
+- u16 *cdc_filter)
++int rndis_set_param_dev(u8 configNr, struct net_device *dev, u16 *cdc_filter)
+ {
+ DBG("%s:\n", __func__ );
+- if (!dev || !stats) return -1;
++ if (!dev)
++ return -EINVAL;
+ if (configNr >= RNDIS_MAX_CONFIGS) return -1;
+
+ rndis_per_dev_params [configNr].dev = dev;
+- rndis_per_dev_params [configNr].stats = stats;
+ rndis_per_dev_params [configNr].filter = cdc_filter;
+
+ return 0;
+@@ -1296,14 +1049,11 @@ int rndis_rm_hdr(struct sk_buff *skb)
+
+ #ifdef CONFIG_USB_GADGET_DEBUG_FILES
+
+-static int rndis_proc_read (char *page, char **start, off_t off, int count, int *eof,
+- void *data)
++static int rndis_proc_show(struct seq_file *m, void *v)
+ {
+- char *out = page;
+- int len;
+- rndis_params *param = (rndis_params *) data;
++ rndis_params *param = m->private;
+
+- out += snprintf (out, count,
++ seq_printf(m,
+ "Config Nr. %d\n"
+ "used : %s\n"
+ "state : %s\n"
+@@ -1326,25 +1076,13 @@ static int rndis_proc_read (char *page, char **start, off_t off, int count, int
+ (param->media_state) ? 0 : param->speed*100,
+ (param->media_state) ? "disconnected" : "connected",
+ param->vendorID, param->vendorDescr);
+-
+- len = out - page;
+- len -= off;
+-
+- if (len < count) {
+- *eof = 1;
+- if (len <= 0)
+- return 0;
+- } else
+- len = count;
+-
+- *start = page + off;
+- return len;
++ return 0;
+ }
+
+-static int rndis_proc_write (struct file *file, const char __user *buffer,
+- unsigned long count, void *data)
++static ssize_t rndis_proc_write(struct file *file, const char __user *buffer,
++ size_t count, loff_t *ppos)
+ {
+- rndis_params *p = data;
++ rndis_params *p = PDE(file->f_path.dentry->d_inode)->data;
+ u32 speed = 0;
+ int i, fl_speed = 0;
+
+@@ -1386,6 +1124,20 @@ static int rndis_proc_write (struct file *file, const char __user *buffer,
+ return count;
+ }
+
++static int rndis_proc_open(struct inode *inode, struct file *file)
++{
++ return single_open(file, rndis_proc_show, PDE(inode)->data);
++}
++
++static const struct file_operations rndis_proc_fops = {
++ .owner = THIS_MODULE,
++ .open = rndis_proc_open,
++ .read = seq_read,
++ .llseek = seq_lseek,
++ .release = single_release,
++ .write = rndis_proc_write,
++};
++
+ #define NAME_TEMPLATE "driver/rndis-%03d"
+
+ static struct proc_dir_entry *rndis_connect_state [RNDIS_MAX_CONFIGS];
+@@ -1403,7 +1155,9 @@ int __init rndis_init (void)
+
+ sprintf (name, NAME_TEMPLATE, i);
+ if (!(rndis_connect_state [i]
+- = create_proc_entry (name, 0660, NULL)))
++ = proc_create_data(name, 0660, NULL,
++ &rndis_proc_fops,
++ (void *)(rndis_per_dev_params + i))))
+ {
+ DBG("%s :remove entries", __func__);
+ while (i) {
+@@ -1413,11 +1167,6 @@ int __init rndis_init (void)
+ DBG("\n");
+ return -EIO;
+ }
+-
+- rndis_connect_state [i]->write_proc = rndis_proc_write;
+- rndis_connect_state [i]->read_proc = rndis_proc_read;
+- rndis_connect_state [i]->data = (void *)
+- (rndis_per_dev_params + i);
+ #endif
+ rndis_per_dev_params [i].confignr = i;
+ rndis_per_dev_params [i].used = 0;
+diff --git a/drivers/usb/gadget/rndis.h b/drivers/usb/gadget/rndis.h
+index 397b149..aac61df 100644
+--- a/drivers/usb/gadget/rndis.h
++++ b/drivers/usb/gadget/rndis.h
+@@ -1,8 +1,6 @@
+ /*
+ * RNDIS Definitions for Remote NDIS
+ *
+- * Version: $Id: rndis.h,v 1.15 2004/03/25 21:33:46 robert Exp $
+- *
+ * Authors: Benedikt Spranger, Pengutronix
+ * Robert Schwebel, Pengutronix
+ *
+@@ -235,20 +233,19 @@ typedef struct rndis_params
+ const u8 *host_mac;
+ u16 *filter;
+ struct net_device *dev;
+- struct net_device_stats *stats;
+
+ u32 vendorID;
+ const char *vendorDescr;
+- int (*ack) (struct net_device *);
++ void (*resp_avail)(void *v);
++ void *v;
+ struct list_head resp_queue;
+ } rndis_params;
+
+ /* RNDIS Message parser and other useless functions */
+ int rndis_msg_parser (u8 configNr, u8 *buf);
+-int rndis_register (int (*rndis_control_ack) (struct net_device *));
++int rndis_register(void (*resp_avail)(void *v), void *v);
+ void rndis_deregister (int configNr);
+ int rndis_set_param_dev (u8 configNr, struct net_device *dev,
+- struct net_device_stats *stats,
+ u16 *cdc_filter);
+ int rndis_set_param_vendor (u8 configNr, u32 vendorID,
+ const char *vendorDescr);
+diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
+index 6b1ef48..29d13eb 100644
+--- a/drivers/usb/gadget/s3c2410_udc.c
++++ b/drivers/usb/gadget/s3c2410_udc.c
+@@ -35,7 +35,6 @@
+ #include <linux/list.h>
+ #include <linux/interrupt.h>
+ #include <linux/platform_device.h>
+-#include <linux/version.h>
+ #include <linux/clk.h>
+
+ #include <linux/debugfs.h>
+@@ -49,15 +48,14 @@
+ #include <asm/irq.h>
+ #include <asm/system.h>
+ #include <asm/unaligned.h>
+-#include <asm/arch/irqs.h>
++#include <mach/irqs.h>
+
+-#include <asm/arch/hardware.h>
+-#include <asm/arch/regs-gpio.h>
++#include <mach/hardware.h>
++#include <mach/regs-gpio.h>
+
+ #include <asm/plat-s3c24xx/regs-udc.h>
+ #include <asm/plat-s3c24xx/udc.h>
+
+-#include <asm/mach-types.h>
+
+ #include "s3c2410_udc.h"
+
+@@ -888,7 +886,7 @@ static void s3c2410_udc_handle_ep(struct s3c2410_ep *ep)
+ }
+ }
+
+-#include <asm/arch/regs-irq.h>
++#include <mach/regs-irq.h>
+
+ /*
+ * s3c2410_udc_irq - interrupt handler
+diff --git a/drivers/usb/gadget/sa1100_udc.c b/drivers/usb/gadget/sa1100_udc.c
+new file mode 100644
+index 0000000..3a9f24f
+--- /dev/null
++++ b/drivers/usb/gadget/sa1100_udc.c
+@@ -0,0 +1,2421 @@
++/*
++ * SA1100 USB Device Controller (UDC) driver.
++ *
++ * Copyright (C) Compaq Computer Corporation, 1998, 1999
++ * Copyright (C) Extenex Corporation, 2001
++ * Copyright (C) David Brownell, 2003
++ * Copyright (C) Nick Bane, 2005, 2006, 2007
++ * Many fragments from pxa2xx_udc.c and mach-sa1100 driver with various
++ * GPL Copyright authors incl Russel king and Nicolas Pitre
++ * Working port to 2.6.32-1 by N C Bane
++ *
++ * This file provides interrupt routing and overall coordination for the
++ * sa1100 USB endpoints: ep0, ep1out-bulk, ep2in-bulk, as well as device
++ * initialization and some parts of USB "Chapter 9" device behavior.
++ *
++ * It implements the "USB gadget controller" API, abstracting most hardware
++ * details so that drivers running on top of this API are mostly independent
++ * of hardware. A key exception is that ep0 logic needs to understand which
++ * endpoints a given controller has, and their capabilities. Also, hardware
++ * that doesn't fully support USB (like sa1100) may need workarounds in the
++ * protocols implemented by device functions.
++ *
++ * See linux/Documentation/arm/SA1100/SA1100_USB for more info, or the
++ * kerneldoc for the API exposed to gadget drivers.
++ *
++ */
++//#define DEBUG 1
++//#define VERBOSE 1
++
++//#define SA1100_USB_DEBUG
++#ifdef SA1100_USB_DEBUG
++static int sa1100_usb_debug=0;
++#endif
++
++#define NCB_DMA_FIX
++#ifdef NCB_DMA_FIX
++// This is a clunky fix for dma alignemnt issues
++// It should probably be done better by someone more
++// steeped in DMA lore
++#include <linux/slab.h>
++#define SEND_BUFFER_SIZE 4096 /* this is probably a bit big */
++#define RECEIVE_BUFFER_SIZE 256 /* 64 may be all that is necessary */
++static char *send_buffer=NULL;
++static char *receive_buffer=NULL;
++#endif
++
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/delay.h>
++#include <linux/ioport.h>
++#include <linux/sched.h>
++#include <linux/slab.h>
++#include <linux/smp_lock.h>
++#include <linux/errno.h>
++#include <linux/init.h>
++#include <linux/timer.h>
++#include <linux/list.h>
++#include <linux/interrupt.h>
++#include <linux/version.h>
++#include <linux/device.h>
++#include <linux/platform_device.h>
++
++#include <asm/byteorder.h>
++#include <asm/io.h>
++#include <asm/irq.h>
++#include <asm/dma.h>
++#include <asm/system.h>
++#include <asm/mach-types.h>
++#include <asm/unaligned.h>
++
++#include <linux/usb.h>
++#include <linux/usb/ch9.h>
++#include <linux/usb/gadget.h>
++
++#if CONFIG_PROC_FS
++#include <linux/proc_fs.h>
++#endif
++
++#if defined(CONFIG_SA1100_BALLOON)
++#include <asm/arch/balloon2.h>
++#endif
++
++#if defined(CONFIG_SA1100_COLLIE)
++#include <asm/hardware/scoop.h>
++#include <asm/arch/collie.h>
++#endif
++
++#define DRIVER_VERSION __DATE__
++
++#define DMA_ADDR_INVALID (~(dma_addr_t)0)
++
++
++static const char driver_name [] = "sa1100_udc";
++static const char driver_desc [] = "SA-1110 USB Device Controller";
++
++static const char ep0name [] = "ep0";
++
++#ifdef DEBUG
++static char *type_string (u8 bmAttributes)
++{
++ switch ( (bmAttributes) & USB_ENDPOINT_XFERTYPE_MASK) {
++ case USB_ENDPOINT_XFER_BULK: return "bulk";
++ //case USB_ENDPOINT_XFER_ISOC: return "iso";
++ case USB_ENDPOINT_XFER_INT: return "intr";
++ };
++ return "control";
++}
++#endif
++
++#include <linux/dma-mapping.h>
++struct usb_stats_t {
++ unsigned long ep0_fifo_write_failures;
++ unsigned long ep0_bytes_written;
++ unsigned long ep0_fifo_read_failures;
++ unsigned long ep0_bytes_read;
++};
++
++struct usb_info_t {
++ dma_regs_t *dmaregs_tx, *dmaregs_rx;
++ int state;
++ unsigned char address;
++ struct usb_stats_t stats;
++};
++
++enum { kError=-1, kEvSuspend=0, kEvReset=1,
++ kEvResume=2, kEvAddress=3, kEvConfig=4, kEvDeConfig=5 };
++int usbctl_next_state_on_event( int event ) {
++ return 0;
++}
++static struct usb_info_t usbd_info;
++
++/* receiver */
++void ep1_reset(void);
++void ep1_stall(void);
++int sa1100_usb_recv (struct usb_request *req, void (*callback) (int,int));
++
++/* xmitter */
++void ep2_reset(void);
++void ep2_stall(void);
++int sa1100_usb_send (struct usb_request *req, void (*callback) (int,int));
++
++/* UDC register utility functions */
++#define UDC_write(reg, val) { \
++ int i = 10000; \
++ do { \
++ (reg) = (val); \
++ if (i-- <= 0) { \
++ printk( "%s [%d]: write %#x to %p (%#lx) failed\n", \
++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \
++ break; \
++ } \
++ } while((reg) != (val)); \
++}
++
++#define UDC_set(reg, val) { \
++ int i = 10000; \
++ do { \
++ (reg) |= (val); \
++ if (i-- <= 0) { \
++ printk( "%s [%d]: set %#x of %p (%#lx) failed\n", \
++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \
++ break; \
++ } \
++ } while(!((reg) & (val))); \
++}
++
++#define UDC_clear(reg, val) { \
++ int i = 10000; \
++ do { \
++ (reg) &= ~(val); \
++ if (i-- <= 0) { \
++ printk( "%s [%d]: clear %#x of %p (%#lx) failed\n", \
++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \
++ break; \
++ } \
++ } while((reg) & (val)); \
++}
++
++#define UDC_flip(reg, val) { \
++ int i = 10000; \
++ (reg) = (val); \
++ do { \
++ (reg) = (val); \
++ if (i-- <= 0) { \
++ printk( "%s [%d]: flip %#x of %p (%#lx) failed\n", \
++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \
++ break; \
++ } \
++ } while(((reg) & (val))); \
++}
++
++#include "sa1100_udc.h"
++
++static struct sa1100_udc *the_controller;
++static void nuke (struct sa1100_ep *, int status);
++static void done (struct sa1100_ep *ep, struct sa1100_request *req, int status);
++static inline void ep0_idle (struct sa1100_udc *dev)
++{
++ dev->ep0state = EP0_IDLE;
++}
++
++// ep0 handlers
++
++// 1 == lots of trace noise, 0 = only "important' stuff
++#define VERBOSITY 0
++
++#if 1 && !defined( ASSERT )
++# define ASSERT(expr) \
++ if(!(expr)) { \
++ printk( "Assertion failed! %s,%s,%s,line=%d\n",\
++ #expr,__FILE__,__FUNCTION__,__LINE__); \
++ }
++#else
++# define ASSERT(expr)
++#endif
++
++#if VERBOSITY
++#define PRINTKD(fmt, args...) printk( fmt , ## args)
++#else
++#define PRINTKD(fmt, args...)
++#endif
++
++/* other subroutines */
++unsigned int (*wrint)(void);
++void ep0_int_hndlr( void );
++static void ep0_queue(void *buf, unsigned int req, unsigned int act);
++static void write_fifo( void );
++static int read_fifo( struct usb_ctrlrequest * p );
++
++/* some voodo helpers 01Mar01ww */
++static void set_cs_bits( __u32 set_bits );
++static void set_de( void );
++static void set_ipr( void );
++static void set_ipr_and_de( void );
++static bool clear_opr( void );
++
++/***************************************************************************
++Inline Helpers
++***************************************************************************/
++
++/* Data extraction from usb_request_t fields */
++enum { kTargetDevice=0, kTargetInterface=1, kTargetEndpoint=2 };
++static inline int request_target( __u8 b ) { return (int) ( b & 0x0F); }
++
++static inline int windex_to_ep_num( __u16 w ) { return (int) ( w & 0x000F); }
++inline int type_code_from_request( __u8 by ) { return (( by >> 4 ) & 3); }
++
++/* following is hook for self-powered flag in GET_STATUS. Some devices
++ .. might like to override and return real info */
++static inline bool self_powered_hook( void ) { return true; }
++
++#if VERBOSITY
++/* "pcs" == "print control status" */
++static inline void pcs( void )
++{
++ __u32 foo = Ser0UDCCS0;
++ printk( "%8.8X: %s %s %s %s\n",
++ foo,
++ foo & UDCCS0_SE ? "SE" : "",
++ foo & UDCCS0_OPR ? "OPR" : "",
++ foo & UDCCS0_IPR ? "IPR" : "",
++ foo & UDCCS0_SST ? "SST" : ""
++ );
++}
++static inline void preq( struct usb_ctrlrequest * pReq )
++{
++ static char * tnames[] = { "dev", "intf", "ep", "oth" };
++ static char * rnames[] = { "std", "class", "vendor", "???" };
++ char * psz;
++ switch( pReq->bRequest ) {
++ case USB_REQ_GET_STATUS: psz = "get stat"; break;
++ case USB_REQ_CLEAR_FEATURE: psz = "clr feat"; break;
++ case USB_REQ_SET_FEATURE: psz = "set feat"; break;
++ case USB_REQ_SET_ADDRESS: psz = "set addr"; break;
++ case USB_REQ_GET_DESCRIPTOR: psz = "get desc"; break;
++ case USB_REQ_SET_DESCRIPTOR: psz = "set desc"; break;
++ case USB_REQ_GET_CONFIGURATION: psz = "get cfg"; break;
++ case USB_REQ_SET_CONFIGURATION: psz = "set cfg"; break;
++ case USB_REQ_GET_INTERFACE: psz = "get intf"; break;
++ case USB_REQ_SET_INTERFACE: psz = "set intf"; break;
++ default: psz = "unknown"; break;
++ }
++ printk( "- [%s: %s req to %s. dir=%s]\n", psz,
++ rnames[ (pReq->bRequestType >> 5) & 3 ],
++ tnames[ pReq->bRequestType & 3 ],
++ ( pReq->bRequestType & 0x80 ) ? "in" : "out" );
++}
++
++static inline void usbctl_dump_request(const char *prefix, const struct usb_ctrlrequest *req)
++{
++ printk("%s: bRequestType=0x%02x bRequest=0x%02x "
++ "wValue=0x%04x wIndex=0x%04x wLength=0x%04x\n",
++ prefix, req->bRequestType, req->bRequest,
++ le16_to_cpu(req->wValue), le16_to_cpu(req->wIndex),
++ le16_to_cpu(req->wLength));
++}
++#else
++static inline void pcs( void ){}
++//static inline void preq( void ){}
++static inline void preq( void *x ){}
++static inline void usbctl_dump_request(const char *prefix, const struct usb_ctrlrequest *req) {}
++#endif
++
++/***************************************************************************
++Globals
++***************************************************************************/
++static const char pszMe[] = "usbep0: ";
++
++
++/* global write struct to keep write
++ ..state around across interrupts */
++static struct {
++ unsigned char *p;
++ int bytes_left;
++} wr;
++
++/***************************************************************************
++Public Interface
++***************************************************************************/
++
++/* reset received from HUB (or controller just went nuts and reset by itself!)
++ so udc core has been reset, track this state here */
++void ep0_reset(void)
++{
++ /* reset state machine */
++ wr.p = NULL;
++ wr.bytes_left = 0;
++ usbd_info.address=0;
++// needed?
++ Ser0UDCAR = 0;
++}
++
++
++/* handle interrupt for endpoint zero */
++
++inline void ep0_clear_write(void) {
++ wr.p = NULL;
++ wr.bytes_left = 0;
++}
++
++/* this is a config packet parser based on that from the updated HH 2.6 udc */
++static void ep0_read_packet(void)
++{
++ unsigned char status_buf[2]; /* returned in GET_STATUS */
++ struct usb_ctrlrequest req;
++ int request_type;
++ int n;
++ __u32 address;
++ __u32 in, out;
++
++ /* reset previous count */
++ the_controller->ep0_req_len=-1;
++
++ /* read the setup request */
++ n = read_fifo( &req );
++ usbctl_dump_request("ep0_read_packet",&req);
++
++ if ( n != sizeof( req ) ) {
++ printk( "%ssetup begin: fifo READ ERROR wanted %d bytes got %d. "
++ " Stalling out...\n",
++ pszMe, sizeof( req ), n );
++ /* force stall, serviced out */
++ set_cs_bits( UDCCS0_FST | UDCCS0_SO );
++ goto sh_sb_end;
++ }
++
++ /* Is it a standard request? (not vendor or class request) */
++ request_type = type_code_from_request( req.bRequestType );
++ if ( request_type != 0 ) {
++ printk( "%ssetup begin: unsupported bRequestType: %d ignored\n",
++ pszMe, request_type );
++ set_cs_bits( UDCCS0_DE | UDCCS0_SO );
++ goto sh_sb_end;
++ }
++
++ /* save requested reply size */
++ the_controller->ep0_req_len=le16_to_cpu(req.wLength);
++ PRINTKD("%s: request length is %d\n",__FUNCTION__,the_controller->ep0_req_len);
++
++#if VERBOSITY
++ {
++ unsigned char * pdb = (unsigned char *) &req;
++ PRINTKD( "%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X ",
++ pdb[0], pdb[1], pdb[2], pdb[3], pdb[4], pdb[5], pdb[6], pdb[7]
++ );
++ preq( &req );
++ }
++#endif
++
++ /* Handle it */
++ switch( req.bRequest ) {
++
++ /* This first bunch have no data phase */
++
++ case USB_REQ_SET_ADDRESS:
++ address = (__u32) (req.wValue & 0x7F);
++ /* when SO and DE sent, UDC will enter status phase and ack,
++ ..propagating new address to udc core. Next control transfer
++ ..will be on the new address. You can't see the change in a
++ ..read back of CAR until then. (about 250us later, on my box).
++ ..The original Intel driver sets S0 and DE and code to check
++ ..that address has propagated here. I tried this, but it
++ ..would only work sometimes! The rest of the time it would
++ ..never propagate and we'd spin forever. So now I just set
++ ..it and pray...
++ */
++ Ser0UDCAR = address;
++ usbd_info.address = address;
++ usbctl_next_state_on_event( kEvAddress );
++ set_cs_bits( UDCCS0_SO | UDCCS0_DE ); /* no data phase */
++ printk( "%sI have been assigned address: %d\n", pszMe, address );
++ break;
++
++
++ case USB_REQ_SET_CONFIGURATION:
++ if ( req.wValue == 1 ) {
++ /* configured */
++ if (usbctl_next_state_on_event( kEvConfig ) != kError) {
++ /* (re)set the out and in max packet sizes */
++ PRINTKD( "%s: calling the_controller.driver->setup with SET_CONFIGURATION\n", __FUNCTION__ );
++ the_controller->driver->setup(&the_controller->gadget, &req);
++ in = __le16_to_cpu( the_controller->ep[1].ep.maxpacket );
++ out = __le16_to_cpu( the_controller->ep[2].ep.maxpacket );
++ Ser0UDCOMP = ( out - 1 );
++ Ser0UDCIMP = ( in - 1 );
++ // we are configured
++ usbd_info.state = USB_STATE_CONFIGURED;
++ // enable rx and tx interrupts
++ Ser0UDCCR &= ~(UDCCR_RIM | UDCCR_TIM);
++
++ printk( "%sConfigured (OMP=%8.8X IMP=%8.8X)\n", pszMe, out, in );
++ break;
++ }
++ } else if ( req.wValue == 0 ) {
++ /* de-configured */
++ if (usbctl_next_state_on_event( kEvDeConfig ) != kError )
++ printk( "%sDe-Configured\n", pszMe );
++ usbd_info.state = 0;
++ Ser0UDCCR |= UDCCR_RIM | UDCCR_TIM;
++ ep1_reset ();
++ ep2_reset ();
++ printk("%s: de-configured. Tx and Rx interrupts disabled. ep1 and ep2 reset\n",__FUNCTION__);
++ } else {
++ printk( "%ssetup phase: Unknown "
++ "\"set configuration\" data %d\n",
++ pszMe, req.wValue );
++ }
++ set_cs_bits( UDCCS0_SO | UDCCS0_DE ); /* no data phase */
++ break;
++
++ case USB_REQ_CLEAR_FEATURE:
++ /* could check data length, direction...26Jan01ww */
++ if ( req.wValue == 0 ) { /* clearing ENDPOINT_HALT/STALL */
++ int ep = windex_to_ep_num( req.wIndex );
++ if ( ep == 1 ) {
++ printk( "%sclear feature \"endpoint halt\" "
++ " on receiver\n", pszMe );
++ ep1_reset();
++ }
++ else if ( ep == 2 ) {
++ printk( "%sclear feature \"endpoint halt\" "
++ "on xmitter\n", pszMe );
++ ep2_reset();
++ } else {
++ printk( "%sclear feature \"endpoint halt\" "
++ "on unsupported ep # %d\n",
++ pszMe, ep );
++ }
++ } else {
++ printk( "%sUnsupported feature selector (%d) "
++ "in clear feature. Ignored.\n" ,
++ pszMe, req.wValue );
++ }
++ set_cs_bits( UDCCS0_SO | UDCCS0_DE ); /* no data phase */
++ break;
++
++ case USB_REQ_SET_FEATURE:
++ if ( req.wValue == 0 ) { /* setting ENDPOINT_HALT/STALL */
++ int ep = windex_to_ep_num( req.wValue );
++ if ( ep == 1 ) {
++ printk( "%set feature \"endpoint halt\" "
++ "on receiver\n", pszMe );
++ ep1_stall();
++ }
++ else if ( ep == 2 ) {
++ printk( "%sset feature \"endpoint halt\" "
++ " on xmitter\n", pszMe );
++ ep2_stall();
++ } else {
++ printk( "%sset feature \"endpoint halt\" "
++ "on unsupported ep # %d\n",
++ pszMe, ep );
++ }
++ }
++ else {
++ printk( "%sUnsupported feature selector "
++ "(%d) in set feature\n",
++ pszMe, req.wValue );
++ }
++ set_cs_bits( UDCCS0_SO | UDCCS0_DE ); /* no data phase */
++ break;
++
++ /* The rest have a data phase that writes back to the host */
++ case USB_REQ_GET_STATUS:
++ /* return status bit flags */
++ status_buf[0] = status_buf[1] = 0;
++ n = request_target(req.bRequestType);
++ switch( n ) {
++ case kTargetDevice:
++ if ( self_powered_hook() )
++ status_buf[0] |= 1;
++ break;
++ case kTargetInterface:
++ break;
++ case kTargetEndpoint:
++ /* return stalled bit */
++ n = windex_to_ep_num( req.wIndex );
++ if ( n == 1 )
++ status_buf[0] |= (Ser0UDCCS1 & UDCCS1_FST) >> 4;
++ else if ( n == 2 )
++ status_buf[0] |= (Ser0UDCCS2 & UDCCS2_FST) >> 5;
++ else {
++ printk( "%sUnknown endpoint (%d) "
++ "in GET_STATUS\n", pszMe, n );
++ }
++ break;
++ default:
++ printk( "%sUnknown target (%d) in GET_STATUS\n",
++ pszMe, n );
++ /* fall thru */
++ break;
++ }
++ PRINTKD("%s: GET_STATUS writing %d\n",__FUNCTION__,req.wLength);
++ ep0_queue( status_buf, req.wLength, sizeof( status_buf ));
++ break;
++ case USB_REQ_GET_DESCRIPTOR:
++ PRINTKD( "%s: calling the_controller.driver->setup with GET_DESCRIPTOR\n", __FUNCTION__ );
++ the_controller->driver->setup(&the_controller->gadget, &req);
++ break;
++ case USB_REQ_GET_CONFIGURATION:
++ PRINTKD( "%s: calling the_controller.driver->setup with GET_CONFIGURATION\n", __FUNCTION__ );
++ the_controller->driver->setup(&the_controller->gadget, &req);
++ break;
++ case USB_REQ_GET_INTERFACE:
++ PRINTKD( "%s: calling the_controller->driver->setup with GET_INTERFACE\n", __FUNCTION__ );
++ the_controller->driver->setup(&the_controller->gadget, &req);
++ break;
++ case USB_REQ_SET_INTERFACE:
++ PRINTKD( "%s: calling the_controller->driver->setup with SET_INTERFACE\n", __FUNCTION__ );
++ the_controller->driver->setup(&the_controller->gadget, &req);
++ break;
++ default :
++ printk("%sunknown request 0x%x\n", pszMe, req.bRequest);
++ break;
++ } /* switch( bRequest ) */
++
++sh_sb_end:
++ return;
++
++}
++
++void ep0_int_hndlr(void)
++{
++ u32 cs_reg_in;
++
++ pcs();
++
++ cs_reg_in = Ser0UDCCS0;
++
++ /*
++ * If "setup end" has been set, the usb controller has terminated
++ * a setup transaction before we set DE. This happens during
++ * enumeration with some hosts. For example, the host will ask for
++ * our device descriptor and specify a return of 64 bytes. When we
++ * hand back the first 8, the host will know our max packet size
++ * and turn around and issue a new setup immediately. This causes
++ * the UDC to auto-ack the new setup and set SE. We must then
++ * "unload" (process) the new setup, which is what will happen
++ * after this preamble is finished executing.
++ */
++ if (cs_reg_in & UDCCS0_SE) {
++ PRINTKD("UDC: early termination of setup\n");
++
++ /*
++ * Clear setup end
++ */
++ set_cs_bits(UDCCS0_SSE);
++
++ /*
++ * Clear any pending write.
++ */
++ ep0_clear_write();
++ }
++
++ /*
++ * UDC sent a stall due to a protocol violation.
++ */
++ if (cs_reg_in & UDCCS0_SST) {
++ PRINTKD("UDC: write_preamble: UDC sent stall\n");
++
++ /*
++ * Clear sent stall
++ */
++ set_cs_bits(UDCCS0_SST);
++
++ /*
++ * Clear any pending write.
++ */
++ ep0_clear_write();
++ }
++
++ switch (cs_reg_in & (UDCCS0_OPR | UDCCS0_IPR)) {
++ case UDCCS0_OPR | UDCCS0_IPR:
++ PRINTKD("UDC: write_preamble: see OPR. Stopping write to "
++ "handle new SETUP\n");
++
++ /*
++ * very rarely, you can get OPR and
++ * leftover IPR. Try to clear
++ */
++ UDC_clear(Ser0UDCCS0, UDCCS0_IPR);
++
++ /*
++ * Clear any pending write.
++ */
++ ep0_clear_write();
++
++ /*FALLTHROUGH*/
++ case UDCCS0_OPR:
++ /*
++ * A new setup request is pending. Handle
++ * it. Note that we don't try to read a
++ * packet if SE was set and OPR is clear.
++ */
++ ep0_read_packet();
++ break;
++
++ case 0:
++ // if data pending ...
++ if (wr.p) {
++ unsigned int cs_bits = 0;
++ if (wr.bytes_left != 0) {
++ /*
++ * More data to go
++ */
++ write_fifo();
++ // packet ready
++ cs_bits |= UDCCS0_IPR;
++ }
++
++ if (wr.bytes_left == 0) {
++ /*
++ * All data sent.
++ */
++ cs_bits |= wrint();
++ // a null packet may be following
++ if (!wrint)
++ ep0_clear_write();
++ }
++ set_cs_bits(cs_bits);
++ }
++ else
++ PRINTKD("%s: No data - probably an ACK\n",__FUNCTION__);
++ break;
++
++ case UDCCS0_IPR:
++ PRINTKD("UDC: IPR set, not writing\n");
++ break;
++ }
++
++ pcs();
++ PRINTKD( "-end-\n" );
++}
++
++static unsigned int ep0_sh_write_data(void)
++{
++ /*
++ * If bytes left is zero, we are coming in on the
++ * interrupt after the last packet went out. And
++ * we know we don't have to empty packet this
++ * transfer so just set DE and we are done
++ */
++ PRINTKD("UDC: normal packet ended\n");
++ wrint=NULL;
++ return UDCCS0_DE;
++}
++
++static unsigned int ep0_sh_write_with_empty_packet(void)
++{
++ /*
++ * If bytes left is zero, we are coming in on the
++ * interrupt after the last packet went out.
++ * We must do short packet suff, so set DE and IPR
++ */
++ PRINTKD("UDC: short packet sent\n");
++ wrint=NULL;
++ return UDCCS0_IPR | UDCCS0_DE;
++}
++
++static unsigned int ep0_sh_write_data_then_empty_packet(void)
++{
++ PRINTKD("UDC: last packet full. Send empty packet next\n");
++ wrint=ep0_sh_write_with_empty_packet;
++ return 0;
++}
++
++static void ep0_queue(void *buf, unsigned int len, unsigned int req_len)
++{
++ __u32 cs_reg_bits = UDCCS0_IPR;
++
++ PRINTKD("a=%d r=%d\n", len, req_len);
++
++ if (len == 0) {
++ // no output packet to wait for
++ PRINTKD("%s: zero byte packet being queued. Setting DE and OPR end exiting\n",__FUNCTION__);
++ set_cs_bits(UDCCS0_DE | UDCCS0_SO);
++ return;
++ }
++
++ /*
++ * thou shalt not enter data phase until
++ * Out Packet Ready is clear
++ */
++ if (!clear_opr()) {
++ printk("UDC: SO did not clear OPR\n");
++ set_cs_bits(UDCCS0_DE | UDCCS0_SO);
++ return;
++ }
++
++ // note data to xmit stored
++ wr.p=buf;
++ wr.bytes_left=min(len, req_len);
++
++ // write the first block
++ write_fifo();
++
++ // done already?
++ if (wr.bytes_left == 0) {
++ /*
++ * out in one, so data end
++ */
++ cs_reg_bits |= UDCCS0_DE;
++ ep0_clear_write();
++ // rest is a shorter than expected reply?
++ } else if (len < req_len) {
++ /*
++ * we are going to short-change host
++ * so need nul to not stall
++ */
++ if (len % 8) {
++ PRINTKD("%s: %d more to go ending in a short packet.\n",__FUNCTION__,wr.bytes_left);
++ wrint=ep0_sh_write_with_empty_packet;
++ }
++ // unless we are on a packet boundary. Then send full packet plus null packet.
++ else {
++ PRINTKD("%s: %d more to go then add empty packet.\n",__FUNCTION__,wr.bytes_left);
++ wrint=ep0_sh_write_data_then_empty_packet;
++ }
++ } else {
++ /*
++ * we have as much or more than requested
++ */
++ PRINTKD("%s: %d more to go.\n",__FUNCTION__,wr.bytes_left);
++ wrint=ep0_sh_write_data;
++ }
++
++ /*
++ * note: IPR was set uncondtionally at start of routine
++ */
++ set_cs_bits(cs_reg_bits);
++}
++
++/*
++ * write_fifo()
++ * Stick bytes in the 8 bytes endpoint zero FIFO.
++ * This version uses a variety of tricks to make sure the bytes
++ * are written correctly. 1. The count register is checked to
++ * see if the byte went in, and the write is attempted again
++ * if not. 2. An overall counter is used to break out so we
++ * don't hang in those (rare) cases where the UDC reverses
++ * direction of the FIFO underneath us without notification
++ * (in response to host aborting a setup transaction early).
++ *
++ */
++static void write_fifo( void )
++{
++ int bytes_this_time = min(wr.bytes_left, 8);
++ int bytes_written = 0;
++
++ PRINTKD( "WF=%d: ", bytes_this_time );
++
++ while( bytes_this_time-- ) {
++ unsigned int cwc;
++ int i;
++ PRINTKD( "%2.2X ", *wr.p );
++ cwc = Ser0UDCWC & 15;
++ i = 10;
++ do {
++ Ser0UDCD0 = *wr.p;
++ udelay( 20 ); /* voodo 28Feb01ww */
++ } while( (Ser0UDCWC &15) == cwc && --i );
++
++ if ( i == 0 ) {
++ printk( "%swrite_fifo: write failure\n", pszMe );
++ usbd_info.stats.ep0_fifo_write_failures++;
++ }
++
++ wr.p++;
++ bytes_written++;
++ }
++ wr.bytes_left -= bytes_written;
++
++ /* following propagation voodo so maybe caller writing IPR in
++ ..a moment might actually get it to stick 28Feb01ww */
++ udelay( 300 );
++
++ usbd_info.stats.ep0_bytes_written += bytes_written;
++ PRINTKD( "L=%d WCR=%8.8lX\n", wr.bytes_left, Ser0UDCWC );
++}
++/*
++ * read_fifo()
++ * Read 1-8 bytes out of FIFO and put in request.
++ * Called to do the initial read of setup requests
++ * from the host. Return number of bytes read.
++ *
++ * Like write fifo above, this driver uses multiple
++ * reads checked agains the count register with an
++ * overall timeout.
++ *
++ */
++static int
++read_fifo( struct usb_ctrlrequest * request )
++{
++ int bytes_read = 0;
++ int fifo_count;
++
++ unsigned char * pOut = (unsigned char*) request;
++
++ fifo_count = ( Ser0UDCWC & 0xFF );
++
++ ASSERT( fifo_count <= 8 );
++ PRINTKD( "RF=%d ", fifo_count );
++
++ while( fifo_count-- ) {
++ unsigned int cwc;
++ int i;
++
++ cwc = Ser0UDCWC & 15;
++
++ i = 10;
++ do {
++ *pOut = (unsigned char) Ser0UDCD0;
++ udelay( 20 );
++ } while( ( Ser0UDCWC & 15 ) == cwc && --i );
++
++ if ( i == 0 ) {
++ printk( "%sread_fifo(): read failure\n", pszMe );
++ usbd_info.stats.ep0_fifo_read_failures++;
++ }
++ pOut++;
++ bytes_read++;
++ }
++
++ PRINTKD( "fc=%d\n", bytes_read );
++ usbd_info.stats.ep0_bytes_read++;
++ return bytes_read;
++}
++
++/* some voodo I am adding, since the vanilla macros just aren't doing it 1Mar01ww */
++
++#define ABORT_BITS ( UDCCS0_SST | UDCCS0_SE )
++#define OK_TO_WRITE (!( Ser0UDCCS0 & ABORT_BITS ))
++#define BOTH_BITS (UDCCS0_IPR | UDCCS0_DE)
++
++static void set_cs_bits( __u32 bits )
++{
++ if ( bits & ( UDCCS0_SO | UDCCS0_SSE | UDCCS0_FST | UDCCS0_SST) )
++ Ser0UDCCS0 = bits;
++ else if ( (bits & BOTH_BITS) == BOTH_BITS )
++ set_ipr_and_de();
++ else if ( bits & UDCCS0_IPR )
++ set_ipr();
++ else if ( bits & UDCCS0_DE )
++ set_de();
++}
++
++static void set_de( void )
++{
++ int i = 1;
++ while( 1 ) {
++ if ( OK_TO_WRITE ) {
++ Ser0UDCCS0 |= UDCCS0_DE;
++ } else {
++ PRINTKD( "%sQuitting set DE because SST or SE set\n", pszMe );
++ break;
++ }
++ if ( Ser0UDCCS0 & UDCCS0_DE )
++ break;
++ udelay( i );
++ if ( ++i == 50 ) {
++ printk( "%sDangnabbbit! Cannot set DE! (DE=%8.8X CCS0=%8.8lX)\n",
++ pszMe, UDCCS0_DE, Ser0UDCCS0 );
++ break;
++ }
++ }
++}
++
++static void set_ipr( void )
++{
++ int i = 1;
++ while( 1 ) {
++ if ( OK_TO_WRITE ) {
++ Ser0UDCCS0 |= UDCCS0_IPR;
++ } else {
++ PRINTKD( "%sQuitting set IPR because SST or SE set\n", pszMe );
++ break;
++ }
++ if ( Ser0UDCCS0 & UDCCS0_IPR )
++ break;
++ udelay( i );
++ if ( ++i == 50 ) {
++ printk( "%sDangnabbbit! Cannot set IPR! (IPR=%8.8X CCS0=%8.8lX)\n",
++ pszMe, UDCCS0_IPR, Ser0UDCCS0 );
++ break;
++ }
++ }
++}
++
++static void set_ipr_and_de( void )
++{
++ int i = 1;
++ while( 1 ) {
++ if ( OK_TO_WRITE ) {
++ Ser0UDCCS0 |= BOTH_BITS;
++ } else {
++ PRINTKD( "%sQuitting set IPR/DE because SST or SE set\n", pszMe );
++ break;
++ }
++ if ( (Ser0UDCCS0 & BOTH_BITS) == BOTH_BITS)
++ break;
++ udelay( i );
++ if ( ++i == 50 ) {
++ printk( "%sDangnabbbit! Cannot set DE/IPR! (DE=%8.8X IPR=%8.8X CCS0=%8.8lX)\n",
++ pszMe, UDCCS0_DE, UDCCS0_IPR, Ser0UDCCS0 );
++ break;
++ }
++ }
++}
++
++static bool clear_opr( void )
++{
++ int i = 10000;
++ bool is_clear;
++ do {
++ Ser0UDCCS0 = UDCCS0_SO;
++ is_clear = ! ( Ser0UDCCS0 & UDCCS0_OPR );
++ if ( i-- <= 0 ) {
++ printk( "%sclear_opr(): failed\n", pszMe );
++ break;
++ }
++ } while( ! is_clear );
++ return is_clear;
++}
++
++
++
++// ep1 handlers
++
++static char *ep1_buf;
++static int ep1_len;
++static void (*ep1_callback)(int flag, int size);
++static char *ep1_curdmabuf;
++static dma_addr_t ep1_curdmapos;
++static int ep1_curdmalen;
++static int ep1_remain;
++static int ep1_used;
++
++static dma_regs_t *dmaregs_rx = NULL;
++static int rx_pktsize;
++
++static int naking;
++
++static void
++ep1_start(void)
++{
++ sa1100_reset_dma(dmaregs_rx);
++ if (!ep1_curdmalen) {
++ ep1_curdmalen = rx_pktsize;
++ if (ep1_curdmalen > ep1_remain)
++ ep1_curdmalen = ep1_remain;
++ ep1_curdmapos = dma_map_single(NULL, ep1_curdmabuf, ep1_curdmalen,
++ DMA_FROM_DEVICE);
++ }
++
++ UDC_write( Ser0UDCOMP, ep1_curdmalen-1 );
++
++ sa1100_start_dma(dmaregs_rx, ep1_curdmapos, ep1_curdmalen);
++
++ if ( naking ) {
++ /* turn off NAK of OUT packets, if set */
++ UDC_flip( Ser0UDCCS1, UDCCS1_RPC );
++ naking = 0;
++ }
++}
++
++static void
++ep1_done(int flag)
++{
++ int size = ep1_len - ep1_remain;
++
++ if (!ep1_len)
++ return;
++ if (ep1_curdmalen)
++ dma_unmap_single(NULL, ep1_curdmapos, ep1_curdmalen,
++ DMA_FROM_DEVICE);
++ ep1_len = ep1_curdmalen = 0;
++ if (ep1_callback)
++ ep1_callback(flag, size);
++}
++
++void
++ep1_state_change_notify( int new_state )
++{
++
++}
++
++void
++ep1_stall( void )
++{
++ /* SET_FEATURE force stall at UDC */
++ UDC_set( Ser0UDCCS1, UDCCS1_FST );
++}
++
++int
++ep1_init(dma_regs_t *dmaregs)
++{
++ dmaregs_rx = dmaregs;
++ sa1100_reset_dma(dmaregs_rx);
++ ep1_done(-EAGAIN);
++ return 0;
++}
++
++void
++ep1_reset(void)
++{
++ if (dmaregs_rx)
++ sa1100_reset_dma(dmaregs_rx);
++ UDC_clear(Ser0UDCCS1, UDCCS1_FST);
++ ep1_done(-EINTR);
++}
++
++void ep1_int_hndlr(int udcsr)
++{
++ dma_addr_t dma_addr;
++ unsigned int len;
++ int status = Ser0UDCCS1;
++
++ if ( naking ) printk( "%sEh? in ISR but naking = %d\n", "usbrx: ", naking );
++
++ if (status & UDCCS1_RPC) {
++
++ if (!ep1_curdmalen) {
++ printk("usb_recv: RPC for non-existent buffer\n");
++ naking=1;
++ return;
++ }
++
++ sa1100_stop_dma(dmaregs_rx);
++
++ if (status & UDCCS1_SST) {
++ printk("usb_recv: stall sent OMP=%ld\n", Ser0UDCOMP);
++ UDC_flip(Ser0UDCCS1, UDCCS1_SST);
++ ep1_done(-EIO); // UDC aborted current transfer, so we do
++ return;
++ }
++
++ if (status & UDCCS1_RPE) {
++ printk("usb_recv: RPError %x\n", status);
++ UDC_flip(Ser0UDCCS1, UDCCS1_RPC);
++ ep1_done(-EIO);
++ return;
++ }
++
++ dma_addr=sa1100_get_dma_pos(dmaregs_rx);
++ dma_unmap_single(NULL, ep1_curdmapos, ep1_curdmalen,
++ DMA_FROM_DEVICE);
++ len = dma_addr - ep1_curdmapos;
++#ifdef SA1100_USB_DEBUG
++ if (sa1100_usb_debug) {
++ int i;
++ printk("usb rx %d :\n ",len);
++ if (sa1100_usb_debug>1) {
++ for (i=0; i<len; i++) {
++ if ((i % 32)==31)
++ printk("\n ");
++ printk("%2.2x ",((char *)ep1_curdmapos)[i]);
++ }
++ }
++ printk("\n");
++ }
++#endif
++ if (len < ep1_curdmalen) {
++ char *buf = ep1_curdmabuf + len;
++ while (Ser0UDCCS1 & UDCCS1_RNE) {
++ if (len >= ep1_curdmalen) {
++ printk("usb_recv: too much data in fifo\n");
++ break;
++ }
++ *buf++ = Ser0UDCDR;
++ len++;
++ }
++ } else if (Ser0UDCCS1 & UDCCS1_RNE) {
++ printk("usb_recv: fifo screwed, shouldn't contain data\n");
++ len = 0;
++ }
++
++#if defined(NCB_DMA_FIX)
++// if (len && (ep1_buf != ep1_curdmabuf))
++// memcpy(ep1_buf,ep1_curdmabuf,len);
++ if (len)
++ memcpy(&(((unsigned char *)ep1_buf)[ep1_used]),ep1_curdmabuf,len);
++#endif
++
++ ep1_curdmalen = 0; /* dma unmap already done */
++ ep1_remain -= len;
++ ep1_used += len;
++// ep1_curdmabuf += len; // use same buffer again
++ naking = 1;
++//printk("%s: received %d, %d remaining\n",__FUNCTION__,len,ep1_remain);
++ if (len && (len == rx_pktsize))
++ ep1_start();
++ else
++ ep1_done((len) ? 0 : -EPIPE);
++ }
++ /* else, you can get here if we are holding NAK */
++}
++
++int
++sa1100_usb_recv(struct usb_request *req, void (*callback)(int flag, int size))
++{
++ unsigned long flags;
++ char *buf=req->buf;
++ int len=req->length;
++
++ if (ep1_len)
++ return -EBUSY;
++
++ local_irq_save(flags);
++ ep1_buf = buf;
++ ep1_len = len;
++ ep1_callback = callback;
++ ep1_remain = len;
++ ep1_used = 0;
++#ifdef NCB_DMA_FIX
++// if (((size_t)buf)&3)
++ if (1)
++ ep1_curdmabuf = receive_buffer;
++ else
++#else
++ ep1_curdmabuf = buf;
++#endif
++ ep1_curdmalen = 0;
++ ep1_start();
++ local_irq_restore(flags);
++
++ return 0;
++}
++
++// ep2 handlers
++
++static char *ep2_buf;
++static int ep2_len;
++static void (*ep2_callback)(int status, int size);
++static dma_addr_t ep2_dma;
++static dma_addr_t ep2_curdmapos;
++static int ep2_curdmalen;
++static int ep2_remain;
++static dma_regs_t *dmaregs_tx = NULL;
++static int tx_pktsize;
++
++/* device state is changing, async */
++void
++ep2_state_change_notify( int new_state )
++{
++}
++
++/* set feature stall executing, async */
++void
++ep2_stall( void )
++{
++ UDC_set( Ser0UDCCS2, UDCCS2_FST ); /* force stall at UDC */
++}
++
++static void
++ep2_start(void)
++{
++ if (!ep2_len)
++ return;
++
++ ep2_curdmalen = tx_pktsize;
++ if (ep2_curdmalen > ep2_remain)
++ ep2_curdmalen = ep2_remain;
++
++ /* must do this _before_ queue buffer.. */
++ UDC_flip( Ser0UDCCS2,UDCCS2_TPC ); /* stop NAKing IN tokens */
++ UDC_write( Ser0UDCIMP, ep2_curdmalen-1 );
++
++ Ser0UDCAR = usbd_info.address; // fighting stupid silicon bug
++ sa1100_start_dma(dmaregs_tx, ep2_curdmapos, ep2_curdmalen);
++}
++
++static void
++ep2_done(int flag)
++{
++ int size = ep2_len - ep2_remain;
++ if (ep2_len) {
++ dma_unmap_single(NULL, ep2_dma, ep2_len, DMA_TO_DEVICE);
++ ep2_len = 0;
++ if (ep2_callback)
++ ep2_callback(flag, size);
++ }
++}
++
++int ep2_init(dma_regs_t *dmaregs)
++{
++ dmaregs_tx = dmaregs;
++ sa1100_reset_dma(dmaregs_tx);
++ ep2_done(-EAGAIN);
++ return 0;
++}
++
++void ep2_reset(void)
++{
++ UDC_clear(Ser0UDCCS2, UDCCS2_FST);
++ if (dmaregs_tx)
++ sa1100_reset_dma(dmaregs_tx);
++ ep2_done(-EINTR);
++}
++
++void ep2_int_hndlr(int udcsr)
++{
++ int status = Ser0UDCCS2;
++
++ if (Ser0UDCAR != usbd_info.address) // check for stupid silicon bug.
++ Ser0UDCAR = usbd_info.address;
++
++ if (status & UDCCS2_TPC) {
++
++ UDC_flip(Ser0UDCCS2, UDCCS2_SST);
++
++ sa1100_reset_dma(dmaregs_tx);
++
++ if (status & (UDCCS2_TPE | UDCCS2_TUR)) {
++ printk("usb_send: transmit error %x\n", status);
++ ep2_done(-EIO);
++ } else {
++ ep2_curdmapos += ep2_curdmalen;
++ ep2_remain -= ep2_curdmalen;
++
++ if (ep2_remain != 0)
++ ep2_start();
++ else
++ ep2_done(0);
++ }
++ } else {
++ printk("usb_send: Not TPC: UDCCS2 = %x\n", status);
++ }
++}
++
++int
++sa1100_usb_send(struct usb_request *req, void (*callback)(int status, int size))
++{
++ char *buf=req->buf;
++ int len=req->length;
++ unsigned long flags;
++
++ if (usbd_info.state != USB_STATE_CONFIGURED) {
++ PRINTKD("%s: return -ENODEV\n",__FUNCTION__);
++ return -ENODEV;
++ }
++
++ if (ep2_len) {
++ PRINTKD("%s: return -EBUSY\n",__FUNCTION__);
++ return -EBUSY;
++ }
++
++ local_irq_save(flags);
++#ifdef NCB_DMA_FIX
++ // if misaligned, copy to aligned buffer
++// if (((size_t)buf)&3) {
++ if (1) {
++ PRINTKD("%s: copying %d bytes to send_buffer\n",__FUNCTION__,len);
++ memcpy(send_buffer,buf,len);
++ ep2_buf = send_buffer;
++ }
++ else
++#endif
++ ep2_buf = buf;
++
++ ep2_len = len;
++ ep2_dma = dma_map_single(NULL, ep2_buf, len,DMA_TO_DEVICE);
++ PRINTKD("%s: mapped dma to buffer(%p0\n",__FUNCTION__,buf);
++
++ ep2_callback = callback;
++ ep2_remain = len;
++ ep2_curdmapos = ep2_dma;
++
++ PRINTKD("%s: calling ep2_start\n",__FUNCTION__);
++ ep2_start();
++ local_irq_restore(flags);
++
++ return 0;
++}
++/*-------------------------------------------------------------------------*/
++
++static int
++sa1100_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
++{
++ struct sa1100_udc *dev;
++ struct sa1100_ep *ep;
++ u32 max;
++ int type;
++
++ ep = container_of (_ep, struct sa1100_ep, ep);
++ if (!_ep || !desc || ep->desc || _ep->name == ep0name
++ || desc->bDescriptorType != USB_DT_ENDPOINT) {
++ PRINTKD("%s: _ep = %p, desc = %p\n",__FUNCTION__,_ep,desc);
++ if (_ep && desc)
++ PRINTKD("%s: ep->desc = %p, _ep->name = %s desc->bDescriptorType = %s\n",__FUNCTION__,ep->desc,_ep->name,
++ (desc->bDescriptorType == USB_DT_ENDPOINT) ? "USB_DT_ENDPOINT":"bad!!");
++ return -EINVAL;
++ }
++
++ dev = ep->dev;
++ if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
++ return -ESHUTDOWN;
++
++ type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
++ max = le16_to_cpu (desc->wMaxPacketSize);
++ switch (max) {
++ case 64: case 32:
++ /* note: maxpacket > 16 means DMA might overrun/underrun */
++ case 16: case 8:
++ break;
++ default:
++ if (type == USB_ENDPOINT_XFER_INT && max < 64)
++ break;
++ return -EDOM;
++ }
++
++ switch (type) {
++ case USB_ENDPOINT_XFER_BULK:
++ case USB_ENDPOINT_XFER_INT:
++ if (ep == &dev->ep[2]) {
++ if (desc->bEndpointAddress != (USB_DIR_IN|2)) {
++ PRINTKD("%s: ep[2] has invalid endpoint\n",__FUNCTION__);
++ return -EINVAL;
++ }
++ tx_pktsize = max;
++ Ser0UDCOMP = max - 1;
++ PRINTKD("%s: ep2 max packet size is %d\n",__FUNCTION__,max);
++ break;
++ } else if (ep == &dev->ep[1]) {
++ if (desc->bEndpointAddress != (USB_DIR_OUT|1)) {
++ PRINTKD("%s: ep[1] has invalid endpoint\n",__FUNCTION__);
++ return -EINVAL;
++ }
++ rx_pktsize = max;
++ Ser0UDCIMP = max - 1;
++ PRINTKD("%s: ep1 max packet size is %d\n",__FUNCTION__,max);
++ break;
++ }
++ // FALLTHROUGH
++ default:
++ PRINTKD("%s: Invalid endpoint\n",__FUNCTION__);
++ return -EINVAL;
++ }
++
++ _ep->maxpacket = max;
++ ep->desc = desc;
++ ep->stopped = 0;
++
++ DEBUG (dev, "enabled %s %s max %04x\n", _ep->name,
++ type_string (desc->bmAttributes), max);
++
++ return 0;
++}
++
++static int sa1100_disable (struct usb_ep *_ep)
++{
++ struct sa1100_ep *ep;
++
++ ep = container_of (_ep, struct sa1100_ep, ep);
++ if (!_ep || !ep->desc || _ep->name == ep0name)
++ return -EINVAL;
++
++ nuke (ep, -ESHUTDOWN);
++
++ DEBUG (ep->dev, "disabled %s\n", _ep->name);
++
++ ep->desc = NULL;
++ ep->stopped = 1;
++ return 0;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static struct usb_request *
++sa1100_alloc_request (struct usb_ep *_ep, gfp_t gfp_flags)
++{
++ struct sa1100_request *req;
++
++ if (!_ep)
++ return 0;
++
++ req = kzalloc(sizeof *req, gfp_flags);
++ if (!req)
++ return 0;
++
++ memset (req, 0, sizeof *req);
++ req->req.dma = DMA_ADDR_INVALID;
++ INIT_LIST_HEAD (&req->queue);
++ return &req->req;
++}
++
++static void sa1100_free_request(struct usb_ep *_ep, struct usb_request *_req)
++{
++ struct sa1100_request *req;
++
++ req = container_of (_req, struct sa1100_request, req);
++ WARN_ON (!list_empty (&req->queue));
++ kfree(req); //NCB - see pxa2xx_udc
++}
++
++/*-------------------------------------------------------------------------*/
++
++static void done(struct sa1100_ep *ep, struct sa1100_request *req, int status)
++{
++ unsigned stopped = ep->stopped;
++
++ list_del_init (&req->queue);
++
++ if (likely(req->req.status == -EINPROGRESS))
++ req->req.status = status;
++ else
++ status = req->req.status;
++
++ if (status && status != -ESHUTDOWN)
++ VDEBUG (ep->dev, "complete %s req %p stat %d len %u/%u\n",
++ ep->ep.name, &req->req, status,
++ req->req.actual, req->req.length);
++
++ /* don't modify queue heads during completion callback */
++ ep->stopped = 1;
++ req->req.complete (&ep->ep, &req->req);
++ ep->stopped = stopped;
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* FIXME move away from the old non-queued api.
++ * - forces extra work on us
++ * - stores request state twice
++ * - doesn't let gadget driver handle dma mapping
++ * - status codes need mapping
++ */
++
++static int map_status(int status)
++{
++ switch (status) {
++ case 0:
++ case -EIO: /* ep[12]_int_handler */
++ return status;
++ case -EPIPE: /* ep1_int_handler */
++ return 0;
++ // case -EAGAIN: /* ep[12]_init */
++ // case -EINTR: /* ep[12]_reset */
++ default:
++ return -ESHUTDOWN;
++ }
++}
++
++static void tx_callback(int status, int size)
++{
++ struct sa1100_ep *ep = &the_controller->ep[2];
++ struct sa1100_request *req;
++
++ if (list_empty (&ep->queue)) {
++ if (status != -EAGAIN)
++ DEBUG (ep->dev, "%s, bogus tx callback %d/%d\n",
++ ep->ep.name, status, size);
++ return;
++ }
++ req = list_entry (ep->queue.next, struct sa1100_request, queue);
++ req->req.actual = size;
++ done (ep, req, map_status (status));
++
++ if (ep->stopped || list_empty (&ep->queue))
++ return;
++ req = list_entry (ep->queue.next, struct sa1100_request, queue);
++ sa1100_usb_send (&req->req, tx_callback);
++}
++
++static void rx_callback (int status, int size)
++{
++ struct sa1100_ep *ep = &the_controller->ep[1];
++ struct sa1100_request *req;
++
++ if (list_empty (&ep->queue)) {
++ if (status != -EAGAIN)
++ DEBUG (ep->dev, "%s, bogus tx callback %d/%d\n",
++ ep->ep.name, status, size);
++ return;
++ }
++ req = list_entry (ep->queue.next, struct sa1100_request, queue);
++ req->req.actual = size;
++ done (ep, req, map_status (status));
++
++ if (ep->stopped || list_empty (&ep->queue))
++ return;
++ req = list_entry (ep->queue.next, struct sa1100_request, queue);
++ sa1100_usb_recv (&req->req, rx_callback);
++}
++
++
++static int
++sa1100_queue (struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
++{
++ struct sa1100_request *req;
++ struct sa1100_ep *ep;
++ struct sa1100_udc *dev;
++ unsigned long flags;
++
++ req = container_of (_req, struct sa1100_request, req);
++ if (!_req || !_req->complete || !_req->buf
++ || !list_empty (&req->queue))
++ return -EINVAL;
++
++ ep = container_of (_ep, struct sa1100_ep, ep);
++ if (unlikely(!_ep || (!ep->desc && _ep->name != ep0name)))
++ return -EINVAL;
++
++ dev = ep->dev;
++ if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN))
++ return -ESHUTDOWN;
++
++ // handle ep0
++ if (_ep->name == ep0name) {
++ ep0_queue( _req->buf, _req->length, dev->ep0_req_len >=0 ? dev->ep0_req_len: _req->length );
++ return 0;
++ }
++
++ /* sa1100 udc can't write zlps */
++ if (ep == &dev->ep[2] && _req->length == 0)
++ return -ERANGE;
++
++ /* the old sa1100 api doesn't use 'unsigned' for lengths */
++ if (_req->length > INT_MAX)
++ return -ERANGE;
++
++ VDEBUG (dev, "%s queue req %p, len %d buf %p\n",
++ _ep->name, _req, _req->length, _req->buf);
++
++ local_irq_save (flags);
++
++ _req->status = -EINPROGRESS;
++ _req->actual = 0;
++
++ if (list_empty (&ep->queue) && !ep->stopped) {
++ /* FIXME this does DMA mapping wrong. caller is allowed
++ * to provide buffers that don't need mapping, but this
++ * doesn't use them.
++ */
++ if (ep == &ep->dev->ep[2]) {
++ PRINTKD("%s: sa1100_usb_send buf %p length %d\n",__FUNCTION__,_req->buf,_req->length);
++ sa1100_usb_send (_req, tx_callback);
++ }
++ else if (ep == &ep->dev->ep[1]) {
++ PRINTKD("%s: sa1100_usb_recv buf %p length %d\n",__FUNCTION__,_req->buf,_req->length);
++ sa1100_usb_recv (_req, rx_callback);
++ }
++ /* ep0 rx/tx is handled separately */
++ }
++ list_add_tail (&req->queue, &ep->queue);
++
++ local_irq_restore (flags);
++
++ return 0;
++}
++
++/* dequeue ALL requests */
++static void nuke (struct sa1100_ep *ep, int status)
++{
++ struct sa1100_request *req;
++
++ /* called with irqs blocked */
++ while (!list_empty (&ep->queue)) {
++ req = list_entry (ep->queue.next,
++ struct sa1100_request,
++ queue);
++ done (ep, req, status);
++ }
++ if (ep == &ep->dev->ep[1])
++ ep1_reset ();
++ else if (ep == &ep->dev->ep[2])
++ ep2_reset ();
++}
++
++/* dequeue JUST ONE request */
++static int sa1100_dequeue (struct usb_ep *_ep, struct usb_request *_req)
++{
++ struct sa1100_ep *ep;
++ struct sa1100_request *req;
++ unsigned long flags;
++
++ ep = container_of (_ep, struct sa1100_ep, ep);
++ if (!_ep || (!ep->desc && _ep->name != ep0name) || !_req)
++ return -EINVAL;
++
++ local_irq_save (flags);
++
++ /* make sure it's actually queued on this endpoint */
++ list_for_each_entry (req, &ep->queue, queue) {
++ if (&req->req == _req)
++ break;
++ }
++ if (&req->req != _req) {
++ local_irq_restore(flags);
++ return -EINVAL;
++ }
++
++ done(ep, req, -ECONNRESET);
++
++ local_irq_restore(flags);
++
++ return 0;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static int
++sa1100_set_halt (struct usb_ep *_ep, int value)
++{
++ struct sa1100_ep *ep;
++
++ ep = container_of (_ep, struct sa1100_ep, ep);
++ if (unlikely(!_ep
++ || (!ep->desc && _ep->name != ep0name))
++ || (ep->desc->bmAttributes & 0x03) == USB_ENDPOINT_XFER_ISOC)
++ return -EINVAL;
++ if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
++ return -ESHUTDOWN;
++
++ VDEBUG (ep->dev, "%s %s halt\n", _ep->name, value ? "set" : "clear");
++
++ /* set/clear, then synch memory views with the device */
++ if (value) {
++ if (ep == &ep->dev->ep[1])
++ ep1_stall ();
++ else
++ ep2_stall ();
++ } else {
++ if (ep == &ep->dev->ep[1])
++ ep1_reset ();
++ else
++ ep2_reset ();
++ }
++
++ return 0;
++}
++
++static struct usb_ep_ops sa1100_ep_ops = {
++ .enable = sa1100_enable,
++ .disable = sa1100_disable,
++
++ .alloc_request = sa1100_alloc_request,
++ .free_request = sa1100_free_request,
++
++ .queue = sa1100_queue,
++ .dequeue = sa1100_dequeue,
++
++ .set_halt = sa1100_set_halt,
++ // .fifo_status = sa1100_fifo_status,
++ // .fifo_flush = sa1100_fifo_flush,
++};
++
++/*-------------------------------------------------------------------------*/
++
++static int sa1100_get_frame (struct usb_gadget *_gadget)
++{
++ return -EOPNOTSUPP;
++}
++
++static int sa1100_wakeup (struct usb_gadget *_gadget)
++{
++ struct sa1100_udc *dev;
++
++ if (!_gadget)
++ return 0;
++ dev = container_of (_gadget, struct sa1100_udc, gadget);
++
++ // FIXME
++
++ return 0;
++}
++
++static const struct usb_gadget_ops sa1100_ops = {
++ .get_frame = sa1100_get_frame,
++ .wakeup = sa1100_wakeup,
++
++ // .set_selfpowered = sa1100_set_selfpowered,
++};
++
++/*-------------------------------------------------------------------------*/
++
++static inline void enable_resume_mask_suspend (void)
++{
++ int i = 0;
++
++ while (1) {
++ Ser0UDCCR |= UDCCR_SUSIM; // mask future suspend events
++ udelay (i);
++ if ( (Ser0UDCCR & UDCCR_SUSIM) || (Ser0UDCSR & UDCSR_RSTIR))
++ break;
++ if (++i == 50) {
++ WARN (&the_controller, "%s Could not set SUSIM %8.8lX\n",
++ __FUNCTION__, Ser0UDCCR);
++ break;
++ }
++ }
++
++ i = 0;
++ while (1) {
++ Ser0UDCCR &= ~UDCCR_RESIM;
++ udelay (i);
++ if ( (Ser0UDCCR & UDCCR_RESIM) == 0
++ || (Ser0UDCSR & UDCSR_RSTIR))
++ break;
++ if (++i == 50) {
++ WARN (&the_controller, "%s Could not clear RESIM %8.8lX\n",
++ __FUNCTION__, Ser0UDCCR);
++ break;
++ }
++ }
++}
++
++static inline void enable_suspend_mask_resume (void)
++{
++ int i = 0;
++ while (1) {
++ Ser0UDCCR |= UDCCR_RESIM; // mask future resume events
++ udelay (i);
++ if (Ser0UDCCR & UDCCR_RESIM || (Ser0UDCSR & UDCSR_RSTIR))
++ break;
++ if (++i == 50) {
++ WARN (&the_controller, "%s could not set RESIM %8.8lX\n",
++ __FUNCTION__, Ser0UDCCR);
++ break;
++ }
++ }
++ i = 0;
++ while (1) {
++ Ser0UDCCR &= ~UDCCR_SUSIM;
++ udelay (i);
++ if ( (Ser0UDCCR & UDCCR_SUSIM) == 0
++ || (Ser0UDCSR & UDCSR_RSTIR))
++ break;
++ if (++i == 50) {
++ WARN (&the_controller, "%s Could not clear SUSIM %8.8lX\n",
++ __FUNCTION__, Ser0UDCCR);
++ break;
++ }
++ }
++}
++
++// HACK DEBUG 3Mar01ww
++// Well, maybe not, it really seems to help! 08Mar01ww
++static void core_kicker (void)
++{
++ u32 car = Ser0UDCAR;
++ u32 imp = Ser0UDCIMP;
++ u32 omp = Ser0UDCOMP;
++
++ UDC_set (Ser0UDCCR, UDCCR_UDD);
++ udelay (300);
++ UDC_clear (Ser0UDCCR, UDCCR_UDD);
++
++ Ser0UDCAR = car;
++ Ser0UDCIMP = imp;
++ Ser0UDCOMP = omp;
++}
++
++static irqreturn_t udc_int_hndlr(int irq, void *_dev)
++{
++ struct sa1100_udc *dev = _dev;
++ u32 status = Ser0UDCSR;
++
++ PRINTKD("%s: status = 0x%x and control = 0x%lx\n", __FUNCTION__,
++ status, Ser0UDCCR);
++ /* ReSeT Interrupt Request - UDC has been reset */
++ if (status & UDCSR_RSTIR) {
++ PRINTKD("%s: processing UDCSR_RSTIR\n", __FUNCTION__);
++ if (usbctl_next_state_on_event(kEvReset) != kError) {
++ /* starting 20ms or so reset sequence now... */
++ INFO (dev, "Resetting\n");
++ ep0_reset(); // just set state to idle
++ ep1_reset(); // flush dma, clear false stall
++ ep2_reset(); // flush dma, clear false stall
++ }
++ // mask reset ints, they flood during sequence, enable
++ // suspend and resume
++ UDC_set(Ser0UDCCR, UDCCR_REM); // mask reset
++ UDC_clear(Ser0UDCCR, (UDCCR_SUSIM | UDCCR_RESIM)); // enable suspend and resume
++ UDC_flip(Ser0UDCSR, status); // clear all pending sources
++ PRINTKD("%s: setting USB_FULL_SPEED\n",__FUNCTION__);
++ dev->gadget.speed = USB_SPEED_FULL;
++ return IRQ_HANDLED; // NCB
++ }
++
++ /* else we have done something other than reset,
++ * so be sure reset enabled
++ */
++ UDC_clear(Ser0UDCCR, UDCCR_REM);
++
++ /* RESume Interrupt Request */
++ if (status & UDCSR_RESIR) {
++ struct usb_gadget_driver *driver = dev->driver;
++
++ PRINTKD("%s: processing UDCSR_RESIR\n",__FUNCTION__);
++ if (driver->resume)
++ driver->resume (&dev->gadget);
++ core_kicker ();
++ enable_suspend_mask_resume ();
++ }
++
++ /* SUSpend Interrupt Request */
++ if (status & UDCSR_SUSIR) {
++ struct usb_gadget_driver *driver = dev->driver;
++
++ PRINTKD("%s: processing UDCSR_SUSIR\n",__FUNCTION__);
++ if (driver->suspend)
++ driver->suspend (&dev->gadget);
++ enable_resume_mask_suspend ();
++ }
++
++ UDC_flip(Ser0UDCSR, status); // clear all pending sources
++
++ if (status & UDCSR_EIR)
++ PRINTKD("%s: processing ep0_int_hndlr\n",__FUNCTION__);
++ ep0_int_hndlr();
++
++ if (status & UDCSR_RIR) {
++ PRINTKD("%s: processing ep1_int_hndlr\n",__FUNCTION__);
++ ep1_int_hndlr(status);
++ }
++ if (status & UDCSR_TIR) {
++ PRINTKD("%s: processing ep2_int_hndlr\n",__FUNCTION__);
++ ep2_int_hndlr(status);
++ }
++
++ return IRQ_HANDLED; // NCB
++}
++
++/* soft_connect_hook ()
++ * Some devices have platform-specific circuitry to make USB
++ * not seem to be plugged in, even when it is. This allows
++ * software to control when a device 'appears' on the USB bus
++ * (after Linux has booted and this driver has loaded, for
++ * example). If you have such a circuit, control it here.
++ */
++#ifdef CONFIG_SA1100_EXTENEX1
++static void soft_connect_hook(int enable)
++{
++ if (machine_is_extenex1 ()) {
++ if (enable) {
++ PPDR |= PPC_USB_SOFT_CON;
++ PPSR |= PPC_USB_SOFT_CON;
++ } else {
++ PPSR &= ~PPC_USB_SOFT_CON;
++ PPDR &= ~PPC_USB_SOFT_CON;
++ }
++ }
++}
++#elif defined(CONFIG_SA1100_BALLOON)
++static void soft_connect_hook(int enable)
++{
++ if (machine_is_balloon()) {
++ if (enable)
++ balloon_cpld_control(BALLOON_UDC_DISCONNECT, 0);
++ else
++ balloon_cpld_control(BALLOON_UDC_DISCONNECT, 1);
++ }
++}
++#elif defined(CONFIG_SA1100_COLLIE)
++extern struct platform_device colliescoop_device;
++
++static void soft_connect_hook(int enable)
++{
++ if(enable)
++ set_scoop_gpio(&colliescoop_device.dev, COLLIE_SCP_LB_VOL_CHG);
++ else
++ reset_scoop_gpio(&colliescoop_device.dev, COLLIE_SCP_LB_VOL_CHG);
++}
++#else
++#define soft_connect_hook(x) do { } while (0);
++#endif
++
++/* "function" sysfs attribute */
++static ssize_t
++show_function(struct device *_dev, struct device_attribute *attr, char *buf)
++{
++ struct sa1100_udc *dev = dev_get_drvdata (_dev);
++
++ if (!dev->driver
++ || !dev->driver->function
++ || strlen(dev->driver->function) > PAGE_SIZE)
++ return 0;
++ return scnprintf (buf, PAGE_SIZE, "%s\n", dev->driver->function);
++}
++static DEVICE_ATTR(function, S_IRUGO, show_function, NULL);
++
++/* disable the UDC at the source */
++static void udc_disable(struct sa1100_udc *dev)
++{
++ soft_connect_hook(0);
++ UDC_set(Ser0UDCCR, UDCCR_UDD);
++ dev->gadget.speed = USB_SPEED_UNKNOWN;
++ ep0_idle(dev);
++}
++
++static void udc_reinit(struct sa1100_udc *dev)
++{
++ u32 i;
++
++ /* Initialize the gadget controller data structure */
++ INIT_LIST_HEAD(&dev->gadget.ep_list);
++ INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
++ ep0_idle(dev);
++ for ( i = 0 ; i < 3 ; i++) {
++ struct sa1100_ep *ep = &dev->ep[i];
++ if (i != 0)
++ list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
++ ep->desc = NULL;
++ ep->stopped = 0;
++ INIT_LIST_HEAD(&ep->queue);
++ }
++}
++
++/* enable the udc at the source */
++static void udc_enable(struct sa1100_udc *dev)
++{
++ UDC_clear (Ser0UDCCR, UDCCR_UDD);
++ ep0_idle(dev);
++}
++
++static void ep0_start(struct sa1100_udc *dev)
++{
++ udc_enable(dev);
++ udelay(100);
++
++ /* clear stall - receiver seems to start stalled? 19Jan01ww */
++ /* also clear other stuff just to be thurough 22Feb01ww */
++ UDC_clear(Ser0UDCCS1, UDCCS1_FST | UDCCS1_RPE | UDCCS1_RPC );
++ UDC_clear(Ser0UDCCS2, UDCCS2_FST | UDCCS2_TPE | UDCCS2_TPC );
++
++ /* mask everything */
++ Ser0UDCCR = 0xFC;
++
++ /* flush DMA and fire through some -EAGAINs */
++ ep1_init(dev->ep[1].dmaregs);
++ ep2_init(dev->ep[2].dmaregs);
++
++ /* enable any platform specific hardware */
++ soft_connect_hook(1);
++
++ /* clear all top-level sources */
++ Ser0UDCSR = UDCSR_RSTIR | UDCSR_RESIR | UDCSR_EIR |
++ UDCSR_RIR | UDCSR_TIR | UDCSR_SUSIR ;
++
++ /* EXERIMENT - a short line in the spec says toggling this
++ * bit diddles the internal state machine in the udc to
++ * expect a suspend
++ */
++ Ser0UDCCR |= UDCCR_RESIM;
++ /* END EXPERIMENT 10Feb01ww */
++
++ /* enable any platform specific hardware */
++ soft_connect_hook(1);
++
++ /* Enable interrupts. If you are unplugged you will immediately
++ * get a suspend interrupt. If you are plugged and have a soft
++ * connect-circuit, you will get a reset. If you are plugged
++ * without a soft-connect, I think you also get suspend. In short,
++ * start with suspend masked and everything else enabled
++ */
++ UDC_write(Ser0UDCCR, UDCCR_SUSIM);
++}
++
++
++/* when a driver is successfully registered, it will receive
++ * control requests including set_configuration(), which enables
++ * non-control requests. then usb traffic follows until a
++ * disconnect is reported. then a host may connect again, or
++ * the driver might get unbound.
++ */
++int usb_gadget_register_driver(struct usb_gadget_driver *driver)
++{
++ struct sa1100_udc *dev = the_controller;
++ int retval;
++
++ if (!driver || !driver->bind || !driver->setup)
++ return -EINVAL;
++ if (!dev)
++ return -ENODEV;
++ if (dev->driver)
++ return -EBUSY;
++
++ /* hook up the driver ... */
++ dev->driver = driver;
++ dev->gadget.dev.driver = &driver->driver;
++
++ retval = device_add(&dev->gadget.dev);
++ if (retval != 0) {
++ printk(KERN_ERR "Error in device_add() : %d\n",retval);
++ goto register_error;
++ }
++
++ retval = driver->bind (&dev->gadget);
++ if (retval != 0) {
++ DEBUG(dev, "bind to driver %s --> %d\n",
++ driver->driver.name, retval);
++ device_del(&dev->gadget.dev);
++ goto register_error;
++ }
++
++ retval = device_create_file(dev->dev, &dev_attr_function);
++
++ /* ... then enable host detection and ep0; and we're ready
++ * for set_configuration as well as eventual disconnect.
++ */
++ ep0_start(dev);
++
++ DEBUG(dev, "%s ready\n", driver->driver.name);
++
++ return 0;
++
++register_error:
++ dev->driver = NULL;
++ dev->gadget.dev.driver = NULL;
++ return retval;
++}
++EXPORT_SYMBOL (usb_gadget_register_driver);
++
++static void
++stop_activity(struct sa1100_udc *dev, struct usb_gadget_driver *driver)
++{
++ int i;
++
++ /* don't disconnect if it's not connected */
++ if (dev->gadget.speed == USB_SPEED_UNKNOWN)
++ driver = NULL;
++ dev->gadget.speed = USB_SPEED_UNKNOWN;
++
++ /* mask everything */
++ Ser0UDCCR = 0xFC;
++
++ /* stop hardware; prevent new request submissions;
++ * and kill any outstanding requests.
++ */
++ for (i = 0; i < 3; i++) {
++ struct sa1100_ep *ep = &dev->ep[i];
++ ep->stopped = 1;
++ nuke(ep, -ESHUTDOWN);
++ }
++ udc_disable (dev);
++
++ /* report disconnect; the driver is already quiesced */
++ if (driver)
++ driver->disconnect(&dev->gadget);
++
++ /* re-init driver-visible data structures */
++ udc_reinit(dev);
++}
++
++int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
++{
++ struct sa1100_udc *dev = the_controller;
++
++ if (!dev)
++ return -ENODEV;
++ if (!driver || driver != dev->driver)
++ return -EINVAL;
++
++ local_irq_disable();
++ stop_activity (dev, driver);
++ local_irq_enable();
++ if (driver->unbind)
++ driver->unbind(&dev->gadget);
++ dev->driver = 0;
++
++ device_del(&dev->gadget.dev);
++ device_remove_file(dev->dev, &dev_attr_function);
++
++ DEBUG (dev, "unregistered driver '%s'\n", driver->driver.name);
++ return 0;
++}
++EXPORT_SYMBOL (usb_gadget_unregister_driver);
++
++
++/*-------------------------------------------------------------------------*/
++
++/*-------------------------------------------------------------------------*/
++
++//////////////////////////////////////////////////////////////////////////////
++// Proc Filesystem Support
++//////////////////////////////////////////////////////////////////////////////
++
++#if CONFIG_PROC_FS
++
++#define SAY(fmt,args...) p += sprintf (p, fmt, ## args)
++#define SAYV(num) p += sprintf (p, num_fmt, "Value", num)
++#define SAYC(label,yn) p += sprintf (p, yn_fmt, label, yn)
++#define SAYS(label,v) p += sprintf (p, cnt_fmt, label, v)
++
++static int usbctl_read_proc (char *page, char **start, off_t off,
++ int count, int *eof, void *data)
++{
++ const char * num_fmt = "%25.25s: %8.8lX\n";
++ const char * cnt_fmt = "%25.25s: %lu\n";
++ const char * yn_fmt = "%25.25s: %s\n";
++ const char * yes = "YES";
++ const char * no = "NO";
++ unsigned long v;
++ char * p = page;
++ int len;
++
++ SAY ("SA1100 USB Controller Core\n");
++
++ SAYS ("ep0 bytes read", usbd_info.stats.ep0_bytes_read);
++ SAYS ("ep0 bytes written", usbd_info.stats.ep0_bytes_written);
++ SAYS ("ep0 FIFO read failures", usbd_info.stats.ep0_fifo_read_failures);
++ SAYS ("ep0 FIFO write failures", usbd_info.stats.ep0_fifo_write_failures);
++
++ SAY ("\n");
++
++ v = Ser0UDCAR;
++ SAY ("%25.25s: 0x%8.8lX - %ld\n", "Address Register", v, v);
++ v = Ser0UDCIMP;
++ SAY ("%25.25s: %ld (%8.8lX)\n", "IN max packet size", v+1, v);
++ v = Ser0UDCOMP;
++ SAY ("%25.25s: %ld (%8.8lX)\n", "OUT max packet size", v+1, v);
++
++ v = Ser0UDCCR;
++ SAY ("\nUDC Mask Register\n");
++ SAYV (v);
++ SAYC ("UDC Active", (v & UDCCR_UDA) ? yes : no);
++ SAYC ("Suspend interrupts masked", (v & UDCCR_SUSIM) ? yes : no);
++ SAYC ("Resume interrupts masked", (v & UDCCR_RESIM) ? yes : no);
++ SAYC ("Reset interrupts masked", (v & UDCCR_REM) ? yes : no);
++
++ v = Ser0UDCSR;
++ SAY ("\nUDC Interrupt Request Register\n");
++ SAYV (v);
++ SAYC ("Reset pending", (v & UDCSR_RSTIR) ? yes : no);
++ SAYC ("Suspend pending", (v & UDCSR_SUSIR) ? yes : no);
++ SAYC ("Resume pending", (v & UDCSR_RESIR) ? yes : no);
++ SAYC ("ep0 pending", (v & UDCSR_EIR) ? yes : no);
++ SAYC ("receiver pending", (v & UDCSR_RIR) ? yes : no);
++ SAYC ("tramsitter pending", (v & UDCSR_TIR) ? yes : no);
++
++#ifdef CONFIG_SA1100_EXTENEX1
++ SAYC ("\nSoft connect", (PPSR & PPC_USB_SOFT_CON) ? "Visible" : "Hidden");
++#endif
++
++#if 1
++ SAY ("\nDMA Tx registers\n");
++ {
++ dma_regs_t *r=the_controller->ep[2].dmaregs;
++ SAY (" DDAR");
++ SAYV(r->DDAR);
++ SAY (" DCSR");
++ SAYV(r->RdDCSR);
++ SAY (" DBSA (address buf A) ");
++ SAYV(r->DBSA);
++ SAY (" DBTA (transfer count A) ");
++ SAYV(r->DBTA);
++ SAY (" DBSB (address buf B) ");
++ SAYV(r->DBSB);
++ SAY (" DBTB (transfer count B) ");
++ SAYV(r->DBTB);
++
++ }
++ SAY ("\nDMA Rx registers\n");
++ {
++ dma_regs_t *r=the_controller->ep[1].dmaregs;
++ SAY (" DDAR");
++ SAYV(r->DDAR);
++ SAY (" DCSR");
++ SAYV(r->RdDCSR);
++ SAY (" DBSA (address buf A) ");
++ SAYV(r->DBSA);
++ SAY (" DBTA (transfer count A) ");
++ SAYV(r->DBTA);
++ SAY (" DBSB (address buf B) ");
++ SAYV(r->DBSB);
++ SAY (" DBTB (transfer count B) ");
++ SAYV(r->DBTB);
++
++ }
++#endif
++#if 1
++ v = Ser0UDCCS0;
++ SAY ("\nUDC Endpoint Zero Status Register\n");
++ SAYV (v);
++ SAYC ("Out Packet Ready", (v & UDCCS0_OPR) ? yes : no);
++ SAYC ("In Packet Ready", (v & UDCCS0_IPR) ? yes : no);
++ SAYC ("Sent Stall", (v & UDCCS0_SST) ? yes : no);
++ SAYC ("Force Stall", (v & UDCCS0_FST) ? yes : no);
++ SAYC ("Data End", (v & UDCCS0_DE) ? yes : no);
++ SAYC ("Data Setup End", (v & UDCCS0_SE) ? yes : no);
++ SAYC ("Serviced (SO)", (v & UDCCS0_SO) ? yes : no);
++
++ v = Ser0UDCCS1;
++ SAY ("\nUDC Receiver Status Register\n");
++ SAYV (v);
++ SAYC ("Receive Packet Complete", (v & UDCCS1_RPC) ? yes : no);
++ SAYC ("Sent Stall", (v & UDCCS1_SST) ? yes : no);
++ SAYC ("Force Stall", (v & UDCCS1_FST) ? yes : no);
++ SAYC ("Receive Packet Error", (v & UDCCS1_RPE) ? yes : no);
++ SAYC ("Receive FIFO not empty", (v & UDCCS1_RNE) ? yes : no);
++
++ v = Ser0UDCCS2;
++ SAY ("\nUDC Transmitter Status Register\n");
++ SAYV (v);
++ SAYC ("FIFO has < 8 of 16 chars", (v & UDCCS2_TFS) ? yes : no);
++ SAYC ("Transmit Packet Complete", (v & UDCCS2_TPC) ? yes : no);
++ SAYC ("Transmit FIFO underrun", (v & UDCCS2_TUR) ? yes : no);
++ SAYC ("Transmit Packet Error", (v & UDCCS2_TPE) ? yes : no);
++ SAYC ("Sent Stall", (v & UDCCS2_SST) ? yes : no);
++ SAYC ("Force Stall", (v & UDCCS2_FST) ? yes : no);
++#endif
++
++ len = (p - page) - off;
++ if (len < 0)
++ len = 0;
++ *eof = (len <=count) ? 1 : 0;
++ *start = page + off;
++ return len;
++}
++
++static inline void register_proc_entry (void)
++{
++ create_proc_read_entry (driver_name, 0, NULL,
++ usbctl_read_proc, NULL);
++}
++
++static inline void unregister_proc_entry (void)
++{
++ remove_proc_entry (driver_name, NULL);
++}
++
++#else
++
++#define register_proc_entry() do {} while (0)
++#define unregister_proc_entry() do {} while (0)
++
++#endif /* CONFIG_PROC_FS */
++
++/*-------------------------------------------------------------------------*/
++
++MODULE_DESCRIPTION ("sa1100_udc");
++MODULE_AUTHOR ("Various");
++MODULE_LICENSE ("GPL");
++
++static struct sa1100_udc memory = {
++ .gadget = {
++ .ops = &sa1100_ops,
++ .ep0 = &memory.ep[0].ep,
++ .name = driver_name,
++ .dev = {
++ .bus_id = "gadget",
++ },
++ },
++
++ /* control endpoint */
++ .ep[0] = {
++ .ep = {
++ .name = ep0name,
++ .ops = &sa1100_ep_ops,
++ .maxpacket = EP0_FIFO_SIZE,
++ },
++ .dev = &memory,
++ },
++
++ /* first group of endpoints */
++ .ep[1] = {
++ .ep = {
++ .name = "ep1out-bulk",
++ .ops = &sa1100_ep_ops,
++ .maxpacket = BULK_FIFO_SIZE,
++ },
++ .dev = &memory,
++ },
++ .ep[2] = {
++ .ep = {
++ .name = "ep2in-bulk",
++ .ops = &sa1100_ep_ops,
++ .maxpacket = BULK_FIFO_SIZE,
++ },
++ .dev = &memory,
++ }
++};
++
++static int __init sa1100_udc_probe(struct device *_dev)
++{
++ struct sa1100_udc *dev = &memory;
++ int retval = 0;
++
++ /* setup dev */
++ dev->dev = _dev;
++// dev->mach = _dev->platform_data;
++
++ device_initialize(&dev->gadget.dev);
++ dev->gadget.dev.parent = _dev;
++ dev->gadget.dev.dma_mask = _dev->dma_mask;
++
++ the_controller = dev;
++ dev_set_drvdata(_dev, dev);
++
++ /* controller stays disabled until gadget driver is bound */
++ udc_disable(dev);
++ udc_reinit(dev);
++
++// spin_lock_init(&the_udc.lock);
++ register_proc_entry();
++
++ /* setup dma channels and IRQ */
++ retval = sa1100_request_dma(DMA_Ser0UDCRd, "USB receive",
++ NULL, NULL, &dev->ep[1].dmaregs);
++ if (retval) {
++ ERROR(dev, "couldn't get rx dma, err %d\n", retval);
++ goto err_rx_dma;
++ }
++ retval = sa1100_request_dma(DMA_Ser0UDCWr, "USB transmit",
++ NULL, NULL, &dev->ep[2].dmaregs);
++ if (retval) {
++ ERROR(dev, "couldn't get tx dma, err %d\n", retval);
++ goto err_tx_dma;
++ }
++ retval = request_irq(IRQ_Ser0UDC, udc_int_hndlr, IRQF_DISABLED,
++ driver_name, dev);
++ if (retval) {
++ ERROR(dev, "couldn't get irq, err %d\n", retval);
++ goto err_irq;
++ }
++
++ INFO(dev, "initialized, rx %p tx %p irq %d\n",
++ dev->ep[1].dmaregs, dev->ep[2].dmaregs, IRQ_Ser0UDC);
++ return 0;
++
++err_irq:
++ sa1100_free_dma(dev->ep[2].dmaregs);
++ usbd_info.dmaregs_rx = 0;
++err_tx_dma:
++ sa1100_free_dma(dev->ep[1].dmaregs);
++ usbd_info.dmaregs_tx = 0;
++err_rx_dma:
++ return retval;
++}
++
++static int __exit sa1100_udc_remove(struct device *_dev)
++{
++ struct sa1100_udc *dev = dev_get_drvdata(_dev);
++
++ udc_disable(dev);
++ unregister_proc_entry();
++ usb_gadget_unregister_driver(dev->driver);
++ sa1100_free_dma(dev->ep[1].dmaregs);
++ sa1100_free_dma(dev->ep[2].dmaregs);
++ free_irq(IRQ_Ser0UDC, dev);
++ dev_set_drvdata(_dev,NULL);
++ the_controller = NULL;
++ return 0;
++}
++
++static struct device_driver udc_driver = {
++ .name = "sa11x0-udc",
++ .bus = &platform_bus_type,
++ .probe = sa1100_udc_probe,
++ .remove = __exit_p(sa1100_udc_remove),
++// .suspend = sa1100_udc_suspend,
++// .resume = sa1100_udc_resume,
++ .owner = THIS_MODULE,
++};
++
++static int __init udc_init(void)
++{
++ printk(KERN_INFO "%s: version %s\n", driver_name, DRIVER_VERSION);
++#ifdef NCB_DMA_FIX
++ send_buffer = (char*) kzalloc(SEND_BUFFER_SIZE, GFP_KERNEL | GFP_DMA );
++ receive_buffer = (char*) kzalloc(RECEIVE_BUFFER_SIZE, GFP_KERNEL | GFP_DMA );
++#endif
++ return driver_register(&udc_driver);
++}
++module_init(udc_init);
++
++static void __exit udc_exit(void)
++{
++#ifdef NCB_DMA_FIX
++ if (send_buffer) {
++ kfree(send_buffer);
++ send_buffer = NULL;
++ }
++ if (receive_buffer) {
++ kfree(receive_buffer);
++ receive_buffer = NULL;
++ }
++#endif
++ driver_unregister(&udc_driver);
++}
++module_exit(udc_exit);
+diff --git a/drivers/usb/gadget/sa1100_udc.h b/drivers/usb/gadget/sa1100_udc.h
+new file mode 100644
+index 0000000..acb665a
+--- /dev/null
++++ b/drivers/usb/gadget/sa1100_udc.h
+@@ -0,0 +1,94 @@
++/*
++ * internals of "new style" UDC controller
++ * <linux/usb_gadget.h> replaces ARM-specific "sa1100_usb.h".
++ */
++
++struct sa1100_ep {
++ struct usb_ep ep;
++ struct sa1100_udc *dev;
++ //unsigned long irqs;
++
++ const struct usb_endpoint_descriptor *desc;
++ struct list_head queue;
++ dma_regs_t *dmaregs;
++ unsigned stopped : 1;
++};
++
++struct sa1100_request {
++ struct usb_request req;
++ struct list_head queue;
++// NCB unsigned mapped : 1;
++};
++
++enum ep0_state {
++ EP0_IDLE,
++ EP0_IN_DATA_PHASE,
++ EP0_OUT_DATA_PHASE,
++ EP0_END_XFER,
++ EP0_STALL,
++};
++
++#define EP0_FIFO_SIZE ((unsigned)8)
++#define BULK_FIFO_SIZE ((unsigned)64)
++//#define ISO_FIFO_SIZE ((unsigned)256)
++//#define INT_FIFO_SIZE ((unsigned)8)
++
++struct udc_stats {
++ struct ep0stats {
++ unsigned long ops;
++ unsigned long bytes;
++ } read, write;
++ unsigned long irqs;
++};
++
++struct sa1100_udc {
++ struct usb_gadget gadget;
++ struct usb_gadget_driver *driver;
++ struct device *dev;
++ enum ep0_state ep0state;
++ struct udc_stats stats;
++// NCB spinlock_t lock;
++// NCB dma_regs_t *dmaregs_tx, *dmaregs_rx;
++ unsigned got_irq : 1,
++ vbus : 1,
++ pullup : 1,
++ has_cfr : 1,
++ req_pending : 1,
++ req_std : 1,
++ req_config : 1;
++ struct timer_list timer;
++ u64 dma_mask;
++ unsigned char address;
++ struct sa1100_ep ep[3];
++ int ep0_req_len;
++};
++
++/*-------------------------------------------------------------------------*/
++
++#define xprintk(dev,level,fmt,args...) \
++ printk(level "%s: " fmt , driver_name , ## args)
++
++#ifdef DEBUG
++#undef DEBUG
++#define DEBUG(dev,fmt,args...) \
++ xprintk(dev , KERN_DEBUG , fmt , ## args)
++#else
++#define DEBUG(dev,fmt,args...) \
++ do { } while (0)
++#endif /* DEBUG */
++
++#ifdef VERBOSE
++#define VDEBUG DEBUG
++#else
++#define VDEBUG(dev,fmt,args...) \
++ do { } while (0)
++#endif /* VERBOSE */
++
++#define ERROR(dev,fmt,args...) \
++ xprintk(dev , KERN_ERR , fmt , ## args)
++#define WARN(dev,fmt,args...) \
++ xprintk(dev , KERN_WARNING , fmt , ## args)
++#define INFO(dev,fmt,args...) \
++ xprintk(dev , KERN_INFO , fmt , ## args)\r
++
++/*-------------------------------------------------------------------------*/
+diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
+index fa019fa..b3699af 100644
+--- a/drivers/usb/gadget/serial.c
++++ b/drivers/usb/gadget/serial.c
+@@ -1,15 +1,9 @@
+ /*
+- * g_serial.c -- USB gadget serial driver
++ * serial.c -- USB gadget serial driver
+ *
+- * Copyright 2003 (C) Al Borchers (alborchers@steinerpoint.com)
+- *
+- * This code is based in part on the Gadget Zero driver, which
+- * is Copyright (C) 2003 by David Brownell, all rights reserved.
+- *
+- * This code also borrows from usbserial.c, which is
+- * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
+- * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
+- * Copyright (C) 2000 Al Borchers (alborchers@steinerpoint.com)
++ * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
++ * Copyright (C) 2008 by David Brownell
++ * Copyright (C) 2008 by Nokia Corporation
+ *
+ * This software is distributed under the terms of the GNU General
+ * Public License ("GPL") as published by the Free Software Foundation,
+@@ -22,2254 +16,237 @@
+ #include <linux/tty.h>
+ #include <linux/tty_flip.h>
+
+-#include <linux/usb/ch9.h>
+-#include <linux/usb/cdc.h>
+-#include <linux/usb/gadget.h>
+-
++#include "u_serial.h"
+ #include "gadget_chips.h"
+
+
+ /* Defines */
+
+-#define GS_VERSION_STR "v2.2"
+-#define GS_VERSION_NUM 0x2200
++#define GS_VERSION_STR "v2.4"
++#define GS_VERSION_NUM 0x2400
+
+ #define GS_LONG_NAME "Gadget Serial"
+-#define GS_SHORT_NAME "g_serial"
+-
+-#define GS_MAJOR 127
+-#define GS_MINOR_START 0
+-
+-/* REVISIT only one port is supported for now;
+- * see gs_{send,recv}_packet() ... no multiplexing,
+- * and no support for multiple ACM devices.
+- */
+-#define GS_NUM_PORTS 1
+-
+-#define GS_NUM_CONFIGS 1
+-#define GS_NO_CONFIG_ID 0
+-#define GS_BULK_CONFIG_ID 1
+-#define GS_ACM_CONFIG_ID 2
+-
+-#define GS_MAX_NUM_INTERFACES 2
+-#define GS_BULK_INTERFACE_ID 0
+-#define GS_CONTROL_INTERFACE_ID 0
+-#define GS_DATA_INTERFACE_ID 1
+-
+-#define GS_MAX_DESC_LEN 256
+-
+-#define GS_DEFAULT_READ_Q_SIZE 32
+-#define GS_DEFAULT_WRITE_Q_SIZE 32
+-
+-#define GS_DEFAULT_WRITE_BUF_SIZE 8192
+-#define GS_TMP_BUF_SIZE 8192
+-
+-#define GS_CLOSE_TIMEOUT 15
+-
+-#define GS_DEFAULT_USE_ACM 0
+-
+-/* 9600-8-N-1 ... matches init_termios.c_cflag and defaults
+- * expected by "usbser.sys" on MS-Windows.
+- */
+-#define GS_DEFAULT_DTE_RATE 9600
+-#define GS_DEFAULT_DATA_BITS 8
+-#define GS_DEFAULT_PARITY USB_CDC_NO_PARITY
+-#define GS_DEFAULT_CHAR_FORMAT USB_CDC_1_STOP_BITS
+-
+-/* maxpacket and other transfer characteristics vary by speed. */
+-static inline struct usb_endpoint_descriptor *
+-choose_ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
+- struct usb_endpoint_descriptor *fs)
+-{
+- if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+- return hs;
+- return fs;
+-}
+-
+-
+-/* debug settings */
+-#ifdef DEBUG
+-static int debug = 1;
+-#else
+-#define debug 0
+-#endif
+-
+-#define gs_debug(format, arg...) \
+- do { if (debug) pr_debug(format, ## arg); } while (0)
+-#define gs_debug_level(level, format, arg...) \
+- do { if (debug >= level) pr_debug(format, ## arg); } while (0)
++#define GS_VERSION_NAME GS_LONG_NAME " " GS_VERSION_STR
+
++/*-------------------------------------------------------------------------*/
+
+ /* Thanks to NetChip Technologies for donating this product ID.
+- *
+- * DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
+- * Instead: allocate your own, using normal USB-IF procedures.
+- */
++*
++* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
++* Instead: allocate your own, using normal USB-IF procedures.
++*/
+ #define GS_VENDOR_ID 0x0525 /* NetChip */
+ #define GS_PRODUCT_ID 0xa4a6 /* Linux-USB Serial Gadget */
+ #define GS_CDC_PRODUCT_ID 0xa4a7 /* ... as CDC-ACM */
+
+-#define GS_LOG2_NOTIFY_INTERVAL 5 /* 1 << 5 == 32 msec */
+-#define GS_NOTIFY_MAXPACKET 8
++/* string IDs are assigned dynamically */
+
++#define STRING_MANUFACTURER_IDX 0
++#define STRING_PRODUCT_IDX 1
++#define STRING_DESCRIPTION_IDX 2
+
+-/* circular buffer */
+-struct gs_buf {
+- unsigned int buf_size;
+- char *buf_buf;
+- char *buf_get;
+- char *buf_put;
+-};
++static char manufacturer[50];
+
+-/* the port structure holds info for each port, one for each minor number */
+-struct gs_port {
+- struct gs_dev *port_dev; /* pointer to device struct */
+- struct tty_struct *port_tty; /* pointer to tty struct */
+- spinlock_t port_lock;
+- int port_num;
+- int port_open_count;
+- int port_in_use; /* open/close in progress */
+- wait_queue_head_t port_write_wait;/* waiting to write */
+- struct gs_buf *port_write_buf;
+- struct usb_cdc_line_coding port_line_coding; /* 8-N-1 etc */
+- u16 port_handshake_bits;
+-#define RS232_RTS (1 << 1)
+-#define RS232_DTE (1 << 0)
++static struct usb_string strings_dev[] = {
++ [STRING_MANUFACTURER_IDX].s = manufacturer,
++ [STRING_PRODUCT_IDX].s = GS_VERSION_NAME,
++ [STRING_DESCRIPTION_IDX].s = NULL /* updated; f(use_acm) */,
++ { } /* end of list */
+ };
+
+-/* the device structure holds info for the USB device */
+-struct gs_dev {
+- struct usb_gadget *dev_gadget; /* gadget device pointer */
+- spinlock_t dev_lock; /* lock for set/reset config */
+- int dev_config; /* configuration number */
+- struct usb_ep *dev_notify_ep; /* address of notify endpoint */
+- struct usb_ep *dev_in_ep; /* address of in endpoint */
+- struct usb_ep *dev_out_ep; /* address of out endpoint */
+- struct usb_endpoint_descriptor /* descriptor of notify ep */
+- *dev_notify_ep_desc;
+- struct usb_endpoint_descriptor /* descriptor of in endpoint */
+- *dev_in_ep_desc;
+- struct usb_endpoint_descriptor /* descriptor of out endpoint */
+- *dev_out_ep_desc;
+- struct usb_request *dev_ctrl_req; /* control request */
+- struct list_head dev_req_list; /* list of write requests */
+- int dev_sched_port; /* round robin port scheduled */
+- struct gs_port *dev_port[GS_NUM_PORTS]; /* the ports */
++static struct usb_gadget_strings stringtab_dev = {
++ .language = 0x0409, /* en-us */
++ .strings = strings_dev,
+ };
+
+-
+-/* Functions */
+-
+-/* tty driver internals */
+-static int gs_send(struct gs_dev *dev);
+-static int gs_send_packet(struct gs_dev *dev, char *packet,
+- unsigned int size);
+-static int gs_recv_packet(struct gs_dev *dev, char *packet,
+- unsigned int size);
+-static void gs_read_complete(struct usb_ep *ep, struct usb_request *req);
+-static void gs_write_complete(struct usb_ep *ep, struct usb_request *req);
+-
+-/* gadget driver internals */
+-static int gs_set_config(struct gs_dev *dev, unsigned config);
+-static void gs_reset_config(struct gs_dev *dev);
+-static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
+- u8 type, unsigned int index, int is_otg);
+-
+-static struct usb_request *gs_alloc_req(struct usb_ep *ep, unsigned int len,
+- gfp_t kmalloc_flags);
+-static void gs_free_req(struct usb_ep *ep, struct usb_request *req);
+-
+-static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags);
+-static void gs_free_ports(struct gs_dev *dev);
+-
+-/* circular buffer */
+-static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags);
+-static void gs_buf_free(struct gs_buf *gb);
+-static void gs_buf_clear(struct gs_buf *gb);
+-static unsigned int gs_buf_data_avail(struct gs_buf *gb);
+-static unsigned int gs_buf_space_avail(struct gs_buf *gb);
+-static unsigned int gs_buf_put(struct gs_buf *gb, const char *buf,
+- unsigned int count);
+-static unsigned int gs_buf_get(struct gs_buf *gb, char *buf,
+- unsigned int count);
+-
+-
+-/* Globals */
+-
+-static struct gs_dev *gs_device;
+-
+-static struct mutex gs_open_close_lock[GS_NUM_PORTS];
+-
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/* USB descriptors */
+-
+-#define GS_MANUFACTURER_STR_ID 1
+-#define GS_PRODUCT_STR_ID 2
+-#define GS_SERIAL_STR_ID 3
+-#define GS_BULK_CONFIG_STR_ID 4
+-#define GS_ACM_CONFIG_STR_ID 5
+-#define GS_CONTROL_STR_ID 6
+-#define GS_DATA_STR_ID 7
+-
+-/* static strings, in UTF-8 */
+-static char manufacturer[50];
+-static struct usb_string gs_strings[] = {
+- { GS_MANUFACTURER_STR_ID, manufacturer },
+- { GS_PRODUCT_STR_ID, GS_LONG_NAME },
+- { GS_BULK_CONFIG_STR_ID, "Gadget Serial Bulk" },
+- { GS_ACM_CONFIG_STR_ID, "Gadget Serial CDC ACM" },
+- { GS_CONTROL_STR_ID, "Gadget Serial Control" },
+- { GS_DATA_STR_ID, "Gadget Serial Data" },
+- { } /* end of list */
+-};
+-
+-static struct usb_gadget_strings gs_string_table = {
+- .language = 0x0409, /* en-us */
+- .strings = gs_strings,
++static struct usb_gadget_strings *dev_strings[] = {
++ &stringtab_dev,
++ NULL,
+ };
+
+-static struct usb_device_descriptor gs_device_desc = {
++static struct usb_device_descriptor device_desc = {
+ .bLength = USB_DT_DEVICE_SIZE,
+ .bDescriptorType = USB_DT_DEVICE,
+ .bcdUSB = __constant_cpu_to_le16(0x0200),
++ /* .bDeviceClass = f(use_acm) */
+ .bDeviceSubClass = 0,
+ .bDeviceProtocol = 0,
++ /* .bMaxPacketSize0 = f(hardware) */
+ .idVendor = __constant_cpu_to_le16(GS_VENDOR_ID),
+- .idProduct = __constant_cpu_to_le16(GS_PRODUCT_ID),
+- .iManufacturer = GS_MANUFACTURER_STR_ID,
+- .iProduct = GS_PRODUCT_STR_ID,
+- .bNumConfigurations = GS_NUM_CONFIGS,
++ /* .idProduct = f(use_acm) */
++ /* .bcdDevice = f(hardware) */
++ /* .iManufacturer = DYNAMIC */
++ /* .iProduct = DYNAMIC */
++ .bNumConfigurations = 1,
+ };
+
+-static struct usb_otg_descriptor gs_otg_descriptor = {
+- .bLength = sizeof(gs_otg_descriptor),
++static struct usb_otg_descriptor otg_descriptor = {
++ .bLength = sizeof otg_descriptor,
+ .bDescriptorType = USB_DT_OTG,
+- .bmAttributes = USB_OTG_SRP,
+-};
+-
+-static struct usb_config_descriptor gs_bulk_config_desc = {
+- .bLength = USB_DT_CONFIG_SIZE,
+- .bDescriptorType = USB_DT_CONFIG,
+- /* .wTotalLength computed dynamically */
+- .bNumInterfaces = 1,
+- .bConfigurationValue = GS_BULK_CONFIG_ID,
+- .iConfiguration = GS_BULK_CONFIG_STR_ID,
+- .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
+- .bMaxPower = 1,
+-};
+-
+-static struct usb_config_descriptor gs_acm_config_desc = {
+- .bLength = USB_DT_CONFIG_SIZE,
+- .bDescriptorType = USB_DT_CONFIG,
+- /* .wTotalLength computed dynamically */
+- .bNumInterfaces = 2,
+- .bConfigurationValue = GS_ACM_CONFIG_ID,
+- .iConfiguration = GS_ACM_CONFIG_STR_ID,
+- .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
+- .bMaxPower = 1,
+-};
+-
+-static const struct usb_interface_descriptor gs_bulk_interface_desc = {
+- .bLength = USB_DT_INTERFACE_SIZE,
+- .bDescriptorType = USB_DT_INTERFACE,
+- .bInterfaceNumber = GS_BULK_INTERFACE_ID,
+- .bNumEndpoints = 2,
+- .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
+- .bInterfaceSubClass = 0,
+- .bInterfaceProtocol = 0,
+- .iInterface = GS_DATA_STR_ID,
+-};
+-
+-static const struct usb_interface_descriptor gs_control_interface_desc = {
+- .bLength = USB_DT_INTERFACE_SIZE,
+- .bDescriptorType = USB_DT_INTERFACE,
+- .bInterfaceNumber = GS_CONTROL_INTERFACE_ID,
+- .bNumEndpoints = 1,
+- .bInterfaceClass = USB_CLASS_COMM,
+- .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
+- .bInterfaceProtocol = USB_CDC_ACM_PROTO_AT_V25TER,
+- .iInterface = GS_CONTROL_STR_ID,
+-};
+-
+-static const struct usb_interface_descriptor gs_data_interface_desc = {
+- .bLength = USB_DT_INTERFACE_SIZE,
+- .bDescriptorType = USB_DT_INTERFACE,
+- .bInterfaceNumber = GS_DATA_INTERFACE_ID,
+- .bNumEndpoints = 2,
+- .bInterfaceClass = USB_CLASS_CDC_DATA,
+- .bInterfaceSubClass = 0,
+- .bInterfaceProtocol = 0,
+- .iInterface = GS_DATA_STR_ID,
+-};
+-
+-static const struct usb_cdc_header_desc gs_header_desc = {
+- .bLength = sizeof(gs_header_desc),
+- .bDescriptorType = USB_DT_CS_INTERFACE,
+- .bDescriptorSubType = USB_CDC_HEADER_TYPE,
+- .bcdCDC = __constant_cpu_to_le16(0x0110),
+-};
+-
+-static const struct usb_cdc_call_mgmt_descriptor gs_call_mgmt_descriptor = {
+- .bLength = sizeof(gs_call_mgmt_descriptor),
+- .bDescriptorType = USB_DT_CS_INTERFACE,
+- .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,
+- .bmCapabilities = 0,
+- .bDataInterface = 1, /* index of data interface */
+-};
+-
+-static struct usb_cdc_acm_descriptor gs_acm_descriptor = {
+- .bLength = sizeof(gs_acm_descriptor),
+- .bDescriptorType = USB_DT_CS_INTERFACE,
+- .bDescriptorSubType = USB_CDC_ACM_TYPE,
+- .bmCapabilities = (1 << 1),
+-};
+-
+-static const struct usb_cdc_union_desc gs_union_desc = {
+- .bLength = sizeof(gs_union_desc),
+- .bDescriptorType = USB_DT_CS_INTERFACE,
+- .bDescriptorSubType = USB_CDC_UNION_TYPE,
+- .bMasterInterface0 = 0, /* index of control interface */
+- .bSlaveInterface0 = 1, /* index of data interface */
+-};
+-
+-static struct usb_endpoint_descriptor gs_fullspeed_notify_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+- .bEndpointAddress = USB_DIR_IN,
+- .bmAttributes = USB_ENDPOINT_XFER_INT,
+- .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
+- .bInterval = 1 << GS_LOG2_NOTIFY_INTERVAL,
+-};
+-
+-static struct usb_endpoint_descriptor gs_fullspeed_in_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+- .bEndpointAddress = USB_DIR_IN,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+-};
+-
+-static struct usb_endpoint_descriptor gs_fullspeed_out_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+- .bEndpointAddress = USB_DIR_OUT,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+-};
+-
+-static const struct usb_descriptor_header *gs_bulk_fullspeed_function[] = {
+- (struct usb_descriptor_header *) &gs_otg_descriptor,
+- (struct usb_descriptor_header *) &gs_bulk_interface_desc,
+- (struct usb_descriptor_header *) &gs_fullspeed_in_desc,
+- (struct usb_descriptor_header *) &gs_fullspeed_out_desc,
+- NULL,
+-};
+-
+-static const struct usb_descriptor_header *gs_acm_fullspeed_function[] = {
+- (struct usb_descriptor_header *) &gs_otg_descriptor,
+- (struct usb_descriptor_header *) &gs_control_interface_desc,
+- (struct usb_descriptor_header *) &gs_header_desc,
+- (struct usb_descriptor_header *) &gs_call_mgmt_descriptor,
+- (struct usb_descriptor_header *) &gs_acm_descriptor,
+- (struct usb_descriptor_header *) &gs_union_desc,
+- (struct usb_descriptor_header *) &gs_fullspeed_notify_desc,
+- (struct usb_descriptor_header *) &gs_data_interface_desc,
+- (struct usb_descriptor_header *) &gs_fullspeed_in_desc,
+- (struct usb_descriptor_header *) &gs_fullspeed_out_desc,
+- NULL,
+-};
+
+-static struct usb_endpoint_descriptor gs_highspeed_notify_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+- .bEndpointAddress = USB_DIR_IN,
+- .bmAttributes = USB_ENDPOINT_XFER_INT,
+- .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
+- .bInterval = GS_LOG2_NOTIFY_INTERVAL+4,
+-};
+-
+-static struct usb_endpoint_descriptor gs_highspeed_in_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .wMaxPacketSize = __constant_cpu_to_le16(512),
+-};
+-
+-static struct usb_endpoint_descriptor gs_highspeed_out_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .wMaxPacketSize = __constant_cpu_to_le16(512),
+-};
+-
+-static struct usb_qualifier_descriptor gs_qualifier_desc = {
+- .bLength = sizeof(struct usb_qualifier_descriptor),
+- .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
+- .bcdUSB = __constant_cpu_to_le16 (0x0200),
+- /* assumes ep0 uses the same value for both speeds ... */
+- .bNumConfigurations = GS_NUM_CONFIGS,
+-};
+-
+-static const struct usb_descriptor_header *gs_bulk_highspeed_function[] = {
+- (struct usb_descriptor_header *) &gs_otg_descriptor,
+- (struct usb_descriptor_header *) &gs_bulk_interface_desc,
+- (struct usb_descriptor_header *) &gs_highspeed_in_desc,
+- (struct usb_descriptor_header *) &gs_highspeed_out_desc,
+- NULL,
++ /* REVISIT SRP-only hardware is possible, although
++ * it would not be called "OTG" ...
++ */
++ .bmAttributes = USB_OTG_SRP | USB_OTG_HNP,
+ };
+
+-static const struct usb_descriptor_header *gs_acm_highspeed_function[] = {
+- (struct usb_descriptor_header *) &gs_otg_descriptor,
+- (struct usb_descriptor_header *) &gs_control_interface_desc,
+- (struct usb_descriptor_header *) &gs_header_desc,
+- (struct usb_descriptor_header *) &gs_call_mgmt_descriptor,
+- (struct usb_descriptor_header *) &gs_acm_descriptor,
+- (struct usb_descriptor_header *) &gs_union_desc,
+- (struct usb_descriptor_header *) &gs_highspeed_notify_desc,
+- (struct usb_descriptor_header *) &gs_data_interface_desc,
+- (struct usb_descriptor_header *) &gs_highspeed_in_desc,
+- (struct usb_descriptor_header *) &gs_highspeed_out_desc,
++static const struct usb_descriptor_header *otg_desc[] = {
++ (struct usb_descriptor_header *) &otg_descriptor,
+ NULL,
+ };
+
+-
+ /*-------------------------------------------------------------------------*/
+
+ /* Module */
+-MODULE_DESCRIPTION(GS_LONG_NAME);
++MODULE_DESCRIPTION(GS_VERSION_NAME);
+ MODULE_AUTHOR("Al Borchers");
++MODULE_AUTHOR("David Brownell");
+ MODULE_LICENSE("GPL");
+
+-#ifdef DEBUG
+-module_param(debug, int, S_IRUGO|S_IWUSR);
+-MODULE_PARM_DESC(debug, "Enable debugging, 0=off, 1=on");
+-#endif
+-
+-static unsigned int read_q_size = GS_DEFAULT_READ_Q_SIZE;
+-module_param(read_q_size, uint, S_IRUGO);
+-MODULE_PARM_DESC(read_q_size, "Read request queue size, default=32");
+-
+-static unsigned int write_q_size = GS_DEFAULT_WRITE_Q_SIZE;
+-module_param(write_q_size, uint, S_IRUGO);
+-MODULE_PARM_DESC(write_q_size, "Write request queue size, default=32");
++static int use_acm = true;
++module_param(use_acm, bool, 0);
++MODULE_PARM_DESC(use_acm, "Use CDC ACM, default=yes");
+
+-static unsigned int write_buf_size = GS_DEFAULT_WRITE_BUF_SIZE;
+-module_param(write_buf_size, uint, S_IRUGO);
+-MODULE_PARM_DESC(write_buf_size, "Write buffer size, default=8192");
+-
+-static unsigned int use_acm = GS_DEFAULT_USE_ACM;
+-module_param(use_acm, uint, S_IRUGO);
+-MODULE_PARM_DESC(use_acm, "Use CDC ACM, 0=no, 1=yes, default=no");
++static unsigned n_ports = 1;
++module_param(n_ports, uint, 0);
++MODULE_PARM_DESC(n_ports, "number of ports to create, default=1");
+
+ /*-------------------------------------------------------------------------*/
+
+-/* TTY Driver */
+-
+-/*
+- * gs_open
+- */
+-static int gs_open(struct tty_struct *tty, struct file *file)
+-{
+- int port_num;
+- unsigned long flags;
+- struct gs_port *port;
+- struct gs_dev *dev;
+- struct gs_buf *buf;
+- struct mutex *mtx;
+- int ret;
+-
+- port_num = tty->index;
+-
+- gs_debug("gs_open: (%d,%p,%p)\n", port_num, tty, file);
+-
+- if (port_num < 0 || port_num >= GS_NUM_PORTS) {
+- pr_err("gs_open: (%d,%p,%p) invalid port number\n",
+- port_num, tty, file);
+- return -ENODEV;
+- }
+-
+- dev = gs_device;
+-
+- if (dev == NULL) {
+- pr_err("gs_open: (%d,%p,%p) NULL device pointer\n",
+- port_num, tty, file);
+- return -ENODEV;
+- }
+-
+- mtx = &gs_open_close_lock[port_num];
+- if (mutex_lock_interruptible(mtx)) {
+- pr_err("gs_open: (%d,%p,%p) interrupted waiting for mutex\n",
+- port_num, tty, file);
+- return -ERESTARTSYS;
+- }
+-
+- spin_lock_irqsave(&dev->dev_lock, flags);
+-
+- if (dev->dev_config == GS_NO_CONFIG_ID) {
+- pr_err("gs_open: (%d,%p,%p) device is not connected\n",
+- port_num, tty, file);
+- ret = -ENODEV;
+- goto exit_unlock_dev;
+- }
+-
+- port = dev->dev_port[port_num];
+-
+- if (port == NULL) {
+- pr_err("gs_open: (%d,%p,%p) NULL port pointer\n",
+- port_num, tty, file);
+- ret = -ENODEV;
+- goto exit_unlock_dev;
+- }
+-
+- spin_lock(&port->port_lock);
+- spin_unlock(&dev->dev_lock);
+-
+- if (port->port_dev == NULL) {
+- pr_err("gs_open: (%d,%p,%p) port disconnected (1)\n",
+- port_num, tty, file);
+- ret = -EIO;
+- goto exit_unlock_port;
+- }
+-
+- if (port->port_open_count > 0) {
+- ++port->port_open_count;
+- gs_debug("gs_open: (%d,%p,%p) already open\n",
+- port_num, tty, file);
+- ret = 0;
+- goto exit_unlock_port;
+- }
+-
+- tty->driver_data = NULL;
+-
+- /* mark port as in use, we can drop port lock and sleep if necessary */
+- port->port_in_use = 1;
+-
+- /* allocate write buffer on first open */
+- if (port->port_write_buf == NULL) {
+- spin_unlock_irqrestore(&port->port_lock, flags);
+- buf = gs_buf_alloc(write_buf_size, GFP_KERNEL);
+- spin_lock_irqsave(&port->port_lock, flags);
+-
+- /* might have been disconnected while asleep, check */
+- if (port->port_dev == NULL) {
+- pr_err("gs_open: (%d,%p,%p) port disconnected (2)\n",
+- port_num, tty, file);
+- port->port_in_use = 0;
+- ret = -EIO;
+- goto exit_unlock_port;
+- }
+-
+- if ((port->port_write_buf=buf) == NULL) {
+- pr_err("gs_open: (%d,%p,%p) cannot allocate "
+- "port write buffer\n",
+- port_num, tty, file);
+- port->port_in_use = 0;
+- ret = -ENOMEM;
+- goto exit_unlock_port;
+- }
+-
+- }
+-
+- /* wait for carrier detect (not implemented) */
+-
+- /* might have been disconnected while asleep, check */
+- if (port->port_dev == NULL) {
+- pr_err("gs_open: (%d,%p,%p) port disconnected (3)\n",
+- port_num, tty, file);
+- port->port_in_use = 0;
+- ret = -EIO;
+- goto exit_unlock_port;
+- }
+-
+- tty->driver_data = port;
+- port->port_tty = tty;
+- port->port_open_count = 1;
+- port->port_in_use = 0;
+-
+- gs_debug("gs_open: (%d,%p,%p) completed\n", port_num, tty, file);
+-
+- ret = 0;
+-
+-exit_unlock_port:
+- spin_unlock_irqrestore(&port->port_lock, flags);
+- mutex_unlock(mtx);
+- return ret;
+-
+-exit_unlock_dev:
+- spin_unlock_irqrestore(&dev->dev_lock, flags);
+- mutex_unlock(mtx);
+- return ret;
+-
+-}
+-
+-/*
+- * gs_close
+- */
+-
+-static int gs_write_finished_event_safely(struct gs_port *p)
+-{
+- int cond;
+-
+- spin_lock_irq(&(p)->port_lock);
+- cond = !(p)->port_dev || !gs_buf_data_avail((p)->port_write_buf);
+- spin_unlock_irq(&(p)->port_lock);
+- return cond;
+-}
+-
+-static void gs_close(struct tty_struct *tty, struct file *file)
+-{
+- struct gs_port *port = tty->driver_data;
+- struct mutex *mtx;
+-
+- if (port == NULL) {
+- pr_err("gs_close: NULL port pointer\n");
+- return;
+- }
+-
+- gs_debug("gs_close: (%d,%p,%p)\n", port->port_num, tty, file);
+-
+- mtx = &gs_open_close_lock[port->port_num];
+- mutex_lock(mtx);
+-
+- spin_lock_irq(&port->port_lock);
+-
+- if (port->port_open_count == 0) {
+- pr_err("gs_close: (%d,%p,%p) port is already closed\n",
+- port->port_num, tty, file);
+- goto exit;
+- }
+-
+- if (port->port_open_count > 1) {
+- --port->port_open_count;
+- goto exit;
+- }
+-
+- /* free disconnected port on final close */
+- if (port->port_dev == NULL) {
+- kfree(port);
+- goto exit;
+- }
+-
+- /* mark port as closed but in use, we can drop port lock */
+- /* and sleep if necessary */
+- port->port_in_use = 1;
+- port->port_open_count = 0;
+-
+- /* wait for write buffer to drain, or */
+- /* at most GS_CLOSE_TIMEOUT seconds */
+- if (gs_buf_data_avail(port->port_write_buf) > 0) {
+- spin_unlock_irq(&port->port_lock);
+- wait_event_interruptible_timeout(port->port_write_wait,
+- gs_write_finished_event_safely(port),
+- GS_CLOSE_TIMEOUT * HZ);
+- spin_lock_irq(&port->port_lock);
+- }
+-
+- /* free disconnected port on final close */
+- /* (might have happened during the above sleep) */
+- if (port->port_dev == NULL) {
+- kfree(port);
+- goto exit;
+- }
+-
+- gs_buf_clear(port->port_write_buf);
+-
+- tty->driver_data = NULL;
+- port->port_tty = NULL;
+- port->port_in_use = 0;
+-
+- gs_debug("gs_close: (%d,%p,%p) completed\n",
+- port->port_num, tty, file);
+-
+-exit:
+- spin_unlock_irq(&port->port_lock);
+- mutex_unlock(mtx);
+-}
+-
+-/*
+- * gs_write
+- */
+-static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
++static int __init serial_bind_config(struct usb_configuration *c)
+ {
+- unsigned long flags;
+- struct gs_port *port = tty->driver_data;
+- int ret;
+-
+- if (port == NULL) {
+- pr_err("gs_write: NULL port pointer\n");
+- return -EIO;
+- }
+-
+- gs_debug("gs_write: (%d,%p) writing %d bytes\n", port->port_num, tty,
+- count);
+-
+- if (count == 0)
+- return 0;
+-
+- spin_lock_irqsave(&port->port_lock, flags);
+-
+- if (port->port_dev == NULL) {
+- pr_err("gs_write: (%d,%p) port is not connected\n",
+- port->port_num, tty);
+- ret = -EIO;
+- goto exit;
+- }
+-
+- if (port->port_open_count == 0) {
+- pr_err("gs_write: (%d,%p) port is closed\n",
+- port->port_num, tty);
+- ret = -EBADF;
+- goto exit;
+- }
+-
+- count = gs_buf_put(port->port_write_buf, buf, count);
+-
+- spin_unlock_irqrestore(&port->port_lock, flags);
+-
+- gs_send(gs_device);
+-
+- gs_debug("gs_write: (%d,%p) wrote %d bytes\n", port->port_num, tty,
+- count);
++ unsigned i;
++ int status = 0;
+
+- return count;
+-
+-exit:
+- spin_unlock_irqrestore(&port->port_lock, flags);
+- return ret;
+-}
+-
+-/*
+- * gs_put_char
+- */
+-static int gs_put_char(struct tty_struct *tty, unsigned char ch)
+-{
+- unsigned long flags;
+- struct gs_port *port = tty->driver_data;
+- int ret = 0;
+-
+- if (port == NULL) {
+- pr_err("gs_put_char: NULL port pointer\n");
+- return 0;
+- }
+-
+- gs_debug("gs_put_char: (%d,%p) char=0x%x, called from %p\n",
+- port->port_num, tty, ch, __builtin_return_address(0));
+-
+- spin_lock_irqsave(&port->port_lock, flags);
+-
+- if (port->port_dev == NULL) {
+- pr_err("gs_put_char: (%d,%p) port is not connected\n",
+- port->port_num, tty);
+- goto exit;
+- }
+-
+- if (port->port_open_count == 0) {
+- pr_err("gs_put_char: (%d,%p) port is closed\n",
+- port->port_num, tty);
+- goto exit;
+- }
+-
+- ret = gs_buf_put(port->port_write_buf, &ch, 1);
+-
+-exit:
+- spin_unlock_irqrestore(&port->port_lock, flags);
+- return ret;
+-}
+-
+-/*
+- * gs_flush_chars
+- */
+-static void gs_flush_chars(struct tty_struct *tty)
+-{
+- unsigned long flags;
+- struct gs_port *port = tty->driver_data;
+-
+- if (port == NULL) {
+- pr_err("gs_flush_chars: NULL port pointer\n");
+- return;
+- }
+-
+- gs_debug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
+-
+- spin_lock_irqsave(&port->port_lock, flags);
+-
+- if (port->port_dev == NULL) {
+- pr_err("gs_flush_chars: (%d,%p) port is not connected\n",
+- port->port_num, tty);
+- goto exit;
+- }
+-
+- if (port->port_open_count == 0) {
+- pr_err("gs_flush_chars: (%d,%p) port is closed\n",
+- port->port_num, tty);
+- goto exit;
+- }
+-
+- spin_unlock_irqrestore(&port->port_lock, flags);
+-
+- gs_send(gs_device);
+-
+- return;
+-
+-exit:
+- spin_unlock_irqrestore(&port->port_lock, flags);
+-}
+-
+-/*
+- * gs_write_room
+- */
+-static int gs_write_room(struct tty_struct *tty)
+-{
+-
+- int room = 0;
+- unsigned long flags;
+- struct gs_port *port = tty->driver_data;
+-
+-
+- if (port == NULL)
+- return 0;
+-
+- spin_lock_irqsave(&port->port_lock, flags);
+-
+- if (port->port_dev != NULL && port->port_open_count > 0
+- && port->port_write_buf != NULL)
+- room = gs_buf_space_avail(port->port_write_buf);
+-
+- spin_unlock_irqrestore(&port->port_lock, flags);
+-
+- gs_debug("gs_write_room: (%d,%p) room=%d\n",
+- port->port_num, tty, room);
+-
+- return room;
+-}
+-
+-/*
+- * gs_chars_in_buffer
+- */
+-static int gs_chars_in_buffer(struct tty_struct *tty)
+-{
+- int chars = 0;
+- unsigned long flags;
+- struct gs_port *port = tty->driver_data;
+-
+- if (port == NULL)
+- return 0;
+-
+- spin_lock_irqsave(&port->port_lock, flags);
+-
+- if (port->port_dev != NULL && port->port_open_count > 0
+- && port->port_write_buf != NULL)
+- chars = gs_buf_data_avail(port->port_write_buf);
+-
+- spin_unlock_irqrestore(&port->port_lock, flags);
+-
+- gs_debug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
+- port->port_num, tty, chars);
+-
+- return chars;
+-}
+-
+-/*
+- * gs_throttle
+- */
+-static void gs_throttle(struct tty_struct *tty)
+-{
+-}
+-
+-/*
+- * gs_unthrottle
+- */
+-static void gs_unthrottle(struct tty_struct *tty)
+-{
+-}
+-
+-/*
+- * gs_break
+- */
+-static void gs_break(struct tty_struct *tty, int break_state)
+-{
+-}
+-
+-/*
+- * gs_ioctl
+- */
+-static int gs_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
+-{
+- struct gs_port *port = tty->driver_data;
+-
+- if (port == NULL) {
+- pr_err("gs_ioctl: NULL port pointer\n");
+- return -EIO;
++ for (i = 0; i < n_ports && status == 0; i++) {
++ if (use_acm)
++ status = acm_bind_config(c, i);
++ else
++ status = gser_bind_config(c, i);
+ }
+-
+- gs_debug("gs_ioctl: (%d,%p,%p) cmd=0x%4.4x, arg=%lu\n",
+- port->port_num, tty, file, cmd, arg);
+-
+- /* handle ioctls */
+-
+- /* could not handle ioctl */
+- return -ENOIOCTLCMD;
+-}
+-
+-/*
+- * gs_set_termios
+- */
+-static void gs_set_termios(struct tty_struct *tty, struct ktermios *old)
+-{
++ return status;
+ }
+
+-static const struct tty_operations gs_tty_ops = {
+- .open = gs_open,
+- .close = gs_close,
+- .write = gs_write,
+- .put_char = gs_put_char,
+- .flush_chars = gs_flush_chars,
+- .write_room = gs_write_room,
+- .ioctl = gs_ioctl,
+- .set_termios = gs_set_termios,
+- .throttle = gs_throttle,
+- .unthrottle = gs_unthrottle,
+- .break_ctl = gs_break,
+- .chars_in_buffer = gs_chars_in_buffer,
++static struct usb_configuration serial_config_driver = {
++ /* .label = f(use_acm) */
++ .bind = serial_bind_config,
++ /* .bConfigurationValue = f(use_acm) */
++ /* .iConfiguration = DYNAMIC */
++ .bmAttributes = USB_CONFIG_ATT_SELFPOWER,
++ .bMaxPower = 1, /* 2 mA, minimal */
+ };
+
+-/*-------------------------------------------------------------------------*/
+-
+-/*
+-* gs_send
+-*
+-* This function finds available write requests, calls
+-* gs_send_packet to fill these packets with data, and
+-* continues until either there are no more write requests
+-* available or no more data to send. This function is
+-* run whenever data arrives or write requests are available.
+-*/
+-static int gs_send(struct gs_dev *dev)
+-{
+- int ret,len;
+- unsigned long flags;
+- struct usb_ep *ep;
+- struct usb_request *req;
+-
+- if (dev == NULL) {
+- pr_err("gs_send: NULL device pointer\n");
+- return -ENODEV;
+- }
+-
+- spin_lock_irqsave(&dev->dev_lock, flags);
+-
+- ep = dev->dev_in_ep;
+-
+- while(!list_empty(&dev->dev_req_list)) {
+-
+- req = list_entry(dev->dev_req_list.next,
+- struct usb_request, list);
+-
+- len = gs_send_packet(dev, req->buf, ep->maxpacket);
+-
+- if (len > 0) {
+- gs_debug_level(3, "gs_send: len=%d, 0x%2.2x "
+- "0x%2.2x 0x%2.2x ...\n", len,
+- *((unsigned char *)req->buf),
+- *((unsigned char *)req->buf+1),
+- *((unsigned char *)req->buf+2));
+- list_del(&req->list);
+- req->length = len;
+- spin_unlock_irqrestore(&dev->dev_lock, flags);
+- if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
+- pr_err(
+- "gs_send: cannot queue read request, ret=%d\n",
+- ret);
+- spin_lock_irqsave(&dev->dev_lock, flags);
+- break;
+- }
+- spin_lock_irqsave(&dev->dev_lock, flags);
+- } else {
+- break;
+- }
+-
+- }
+-
+- spin_unlock_irqrestore(&dev->dev_lock, flags);
+-
+- return 0;
+-}
+-
+-/*
+- * gs_send_packet
+- *
+- * If there is data to send, a packet is built in the given
+- * buffer and the size is returned. If there is no data to
+- * send, 0 is returned. If there is any error a negative
+- * error number is returned.
+- *
+- * Called during USB completion routine, on interrupt time.
+- *
+- * We assume that disconnect will not happen until all completion
+- * routines have completed, so we can assume that the dev_port
+- * array does not change during the lifetime of this function.
+- */
+-static int gs_send_packet(struct gs_dev *dev, char *packet, unsigned int size)
+-{
+- unsigned int len;
+- struct gs_port *port;
+-
+- /* TEMPORARY -- only port 0 is supported right now */
+- port = dev->dev_port[0];
+-
+- if (port == NULL) {
+- pr_err("gs_send_packet: port=%d, NULL port pointer\n", 0);
+- return -EIO;
+- }
+-
+- spin_lock(&port->port_lock);
+-
+- len = gs_buf_data_avail(port->port_write_buf);
+- if (len < size)
+- size = len;
+-
+- if (size == 0)
+- goto exit;
+-
+- size = gs_buf_get(port->port_write_buf, packet, size);
+-
+- if (port->port_tty)
+- wake_up_interruptible(&port->port_tty->write_wait);
+-
+-exit:
+- spin_unlock(&port->port_lock);
+- return size;
+-}
+-
+-/*
+- * gs_recv_packet
+- *
+- * Called for each USB packet received. Reads the packet
+- * header and stuffs the data in the appropriate tty buffer.
+- * Returns 0 if successful, or a negative error number.
+- *
+- * Called during USB completion routine, on interrupt time.
+- *
+- * We assume that disconnect will not happen until all completion
+- * routines have completed, so we can assume that the dev_port
+- * array does not change during the lifetime of this function.
+- */
+-static int gs_recv_packet(struct gs_dev *dev, char *packet, unsigned int size)
+-{
+- unsigned int len;
+- struct gs_port *port;
+- int ret;
+- struct tty_struct *tty;
+-
+- /* TEMPORARY -- only port 0 is supported right now */
+- port = dev->dev_port[0];
+-
+- if (port == NULL) {
+- pr_err("gs_recv_packet: port=%d, NULL port pointer\n",
+- port->port_num);
+- return -EIO;
+- }
+-
+- spin_lock(&port->port_lock);
+-
+- if (port->port_open_count == 0) {
+- pr_err("gs_recv_packet: port=%d, port is closed\n",
+- port->port_num);
+- ret = -EIO;
+- goto exit;
+- }
+-
+-
+- tty = port->port_tty;
+-
+- if (tty == NULL) {
+- pr_err("gs_recv_packet: port=%d, NULL tty pointer\n",
+- port->port_num);
+- ret = -EIO;
+- goto exit;
+- }
+-
+- if (port->port_tty->magic != TTY_MAGIC) {
+- pr_err("gs_recv_packet: port=%d, bad tty magic\n",
+- port->port_num);
+- ret = -EIO;
+- goto exit;
+- }
+-
+- len = tty_buffer_request_room(tty, size);
+- if (len > 0) {
+- tty_insert_flip_string(tty, packet, len);
+- tty_flip_buffer_push(port->port_tty);
+- wake_up_interruptible(&port->port_tty->read_wait);
+- }
+- ret = 0;
+-exit:
+- spin_unlock(&port->port_lock);
+- return ret;
+-}
+-
+-/*
+-* gs_read_complete
+-*/
+-static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
++static int __init gs_bind(struct usb_composite_dev *cdev)
+ {
+- int ret;
+- struct gs_dev *dev = ep->driver_data;
+-
+- if (dev == NULL) {
+- pr_err("gs_read_complete: NULL device pointer\n");
+- return;
+- }
++ int gcnum;
++ struct usb_gadget *gadget = cdev->gadget;
++ int status;
+
+- switch(req->status) {
+- case 0:
+- /* normal completion */
+- gs_recv_packet(dev, req->buf, req->actual);
+-requeue:
+- req->length = ep->maxpacket;
+- if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
+- pr_err(
+- "gs_read_complete: cannot queue read request, ret=%d\n",
+- ret);
+- }
+- break;
+-
+- case -ESHUTDOWN:
+- /* disconnect */
+- gs_debug("gs_read_complete: shutdown\n");
+- gs_free_req(ep, req);
+- break;
+-
+- default:
+- /* unexpected */
+- pr_err(
+- "gs_read_complete: unexpected status error, status=%d\n",
+- req->status);
+- goto requeue;
+- break;
+- }
+-}
+-
+-/*
+-* gs_write_complete
+-*/
+-static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
+-{
+- struct gs_dev *dev = ep->driver_data;
+-
+- if (dev == NULL) {
+- pr_err("gs_write_complete: NULL device pointer\n");
+- return;
+- }
++ status = gserial_setup(cdev->gadget, n_ports);
++ if (status < 0)
++ return status;
+
+- switch(req->status) {
+- case 0:
+- /* normal completion */
+-requeue:
+- spin_lock(&dev->dev_lock);
+- list_add(&req->list, &dev->dev_req_list);
+- spin_unlock(&dev->dev_lock);
+-
+- gs_send(dev);
+-
+- break;
+-
+- case -ESHUTDOWN:
+- /* disconnect */
+- gs_debug("gs_write_complete: shutdown\n");
+- gs_free_req(ep, req);
+- break;
+-
+- default:
+- pr_err(
+- "gs_write_complete: unexpected status error, status=%d\n",
+- req->status);
+- goto requeue;
+- break;
+- }
+-}
++ /* Allocate string descriptor numbers ... note that string
++ * contents can be overridden by the composite_dev glue.
++ */
+
+-/*-------------------------------------------------------------------------*/
++ /* device description: manufacturer, product */
++ snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
++ init_utsname()->sysname, init_utsname()->release,
++ gadget->name);
++ status = usb_string_id(cdev);
++ if (status < 0)
++ goto fail;
++ strings_dev[STRING_MANUFACTURER_IDX].id = status;
+
+-/* Gadget Driver */
++ device_desc.iManufacturer = status;
+
+-/*
+- * gs_unbind
+- *
+- * Called on module unload. Frees the control request and device
+- * structure.
+- */
+-static void /* __init_or_exit */ gs_unbind(struct usb_gadget *gadget)
+-{
+- struct gs_dev *dev = get_gadget_data(gadget);
++ status = usb_string_id(cdev);
++ if (status < 0)
++ goto fail;
++ strings_dev[STRING_PRODUCT_IDX].id = status;
+
+- gs_device = NULL;
++ device_desc.iProduct = status;
+
+- /* read/write requests already freed, only control request remains */
+- if (dev != NULL) {
+- if (dev->dev_ctrl_req != NULL) {
+- gs_free_req(gadget->ep0, dev->dev_ctrl_req);
+- dev->dev_ctrl_req = NULL;
+- }
+- gs_reset_config(dev);
+- gs_free_ports(dev);
+- kfree(dev);
+- set_gadget_data(gadget, NULL);
+- }
++ /* config description */
++ status = usb_string_id(cdev);
++ if (status < 0)
++ goto fail;
++ strings_dev[STRING_DESCRIPTION_IDX].id = status;
+
+- pr_info("gs_unbind: %s %s unbound\n", GS_LONG_NAME,
+- GS_VERSION_STR);
+-}
+-
+-/*
+- * gs_bind
+- *
+- * Called on module load. Allocates and initializes the device
+- * structure and a control request.
+- */
+-static int __init gs_bind(struct usb_gadget *gadget)
+-{
+- int ret;
+- struct usb_ep *ep;
+- struct gs_dev *dev;
+- int gcnum;
+-
+- /* Some controllers can't support CDC ACM:
+- * - sh doesn't support multiple interfaces or configs;
+- * - sa1100 doesn't have a third interrupt endpoint
+- */
+- if (gadget_is_sh(gadget) || gadget_is_sa1100(gadget))
+- use_acm = 0;
++ serial_config_driver.iConfiguration = status;
+
++ /* set up other descriptors */
+ gcnum = usb_gadget_controller_number(gadget);
+ if (gcnum >= 0)
+- gs_device_desc.bcdDevice =
+- cpu_to_le16(GS_VERSION_NUM | gcnum);
++ device_desc.bcdDevice = cpu_to_le16(GS_VERSION_NUM | gcnum);
+ else {
++ /* this is so simple (for now, no altsettings) that it
++ * SHOULD NOT have problems with bulk-capable hardware.
++ * so warn about unrcognized controllers -- don't panic.
++ *
++ * things like configuration and altsetting numbering
++ * can need hardware-specific attention though.
++ */
+ pr_warning("gs_bind: controller '%s' not recognized\n",
+ gadget->name);
+- /* unrecognized, but safe unless bulk is REALLY quirky */
+- gs_device_desc.bcdDevice =
+- __constant_cpu_to_le16(GS_VERSION_NUM|0x0099);
+- }
+-
+- dev = kzalloc(sizeof(struct gs_dev), GFP_KERNEL);
+- if (dev == NULL)
+- return -ENOMEM;
+-
+- usb_ep_autoconfig_reset(gadget);
+-
+- ep = usb_ep_autoconfig(gadget, &gs_fullspeed_in_desc);
+- if (!ep)
+- goto autoconf_fail;
+- dev->dev_in_ep = ep;
+- ep->driver_data = dev; /* claim the endpoint */
+-
+- ep = usb_ep_autoconfig(gadget, &gs_fullspeed_out_desc);
+- if (!ep)
+- goto autoconf_fail;
+- dev->dev_out_ep = ep;
+- ep->driver_data = dev; /* claim the endpoint */
+-
+- if (use_acm) {
+- ep = usb_ep_autoconfig(gadget, &gs_fullspeed_notify_desc);
+- if (!ep) {
+- pr_err("gs_bind: cannot run ACM on %s\n", gadget->name);
+- goto autoconf_fail;
+- }
+- gs_device_desc.idProduct = __constant_cpu_to_le16(
+- GS_CDC_PRODUCT_ID),
+- dev->dev_notify_ep = ep;
+- ep->driver_data = dev; /* claim the endpoint */
+- }
+-
+- gs_device_desc.bDeviceClass = use_acm
+- ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC;
+- gs_device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
+-
+- if (gadget_is_dualspeed(gadget)) {
+- gs_qualifier_desc.bDeviceClass = use_acm
+- ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC;
+- /* assume ep0 uses the same packet size for both speeds */
+- gs_qualifier_desc.bMaxPacketSize0 =
+- gs_device_desc.bMaxPacketSize0;
+- /* assume endpoints are dual-speed */
+- gs_highspeed_notify_desc.bEndpointAddress =
+- gs_fullspeed_notify_desc.bEndpointAddress;
+- gs_highspeed_in_desc.bEndpointAddress =
+- gs_fullspeed_in_desc.bEndpointAddress;
+- gs_highspeed_out_desc.bEndpointAddress =
+- gs_fullspeed_out_desc.bEndpointAddress;
+- }
+-
+- usb_gadget_set_selfpowered(gadget);
+-
+- if (gadget_is_otg(gadget)) {
+- gs_otg_descriptor.bmAttributes |= USB_OTG_HNP,
+- gs_bulk_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+- gs_acm_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
++ device_desc.bcdDevice =
++ __constant_cpu_to_le16(GS_VERSION_NUM | 0x0099);
+ }
+
+- gs_device = dev;
+-
+- snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
+- init_utsname()->sysname, init_utsname()->release,
+- gadget->name);
+-
+- dev->dev_gadget = gadget;
+- spin_lock_init(&dev->dev_lock);
+- INIT_LIST_HEAD(&dev->dev_req_list);
+- set_gadget_data(gadget, dev);
+-
+- if ((ret=gs_alloc_ports(dev, GFP_KERNEL)) != 0) {
+- pr_err("gs_bind: cannot allocate ports\n");
+- gs_unbind(gadget);
+- return ret;
++ if (gadget_is_otg(cdev->gadget)) {
++ serial_config_driver.descriptors = otg_desc;
++ serial_config_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+ }
+
+- /* preallocate control response and buffer */
+- dev->dev_ctrl_req = gs_alloc_req(gadget->ep0, GS_MAX_DESC_LEN,
+- GFP_KERNEL);
+- if (dev->dev_ctrl_req == NULL) {
+- gs_unbind(gadget);
+- return -ENOMEM;
+- }
+- gadget->ep0->driver_data = dev;
++ /* register our configuration */
++ status = usb_add_config(cdev, &serial_config_driver);
++ if (status < 0)
++ goto fail;
+
+- pr_info("gs_bind: %s %s bound\n",
+- GS_LONG_NAME, GS_VERSION_STR);
++ INFO(cdev, "%s\n", GS_VERSION_NAME);
+
+ return 0;
+
+-autoconf_fail:
+- kfree(dev);
+- pr_err("gs_bind: cannot autoconfigure on %s\n", gadget->name);
+- return -ENODEV;
+-}
+-
+-static int gs_setup_standard(struct usb_gadget *gadget,
+- const struct usb_ctrlrequest *ctrl)
+-{
+- int ret = -EOPNOTSUPP;
+- struct gs_dev *dev = get_gadget_data(gadget);
+- struct usb_request *req = dev->dev_ctrl_req;
+- u16 wIndex = le16_to_cpu(ctrl->wIndex);
+- u16 wValue = le16_to_cpu(ctrl->wValue);
+- u16 wLength = le16_to_cpu(ctrl->wLength);
+-
+- switch (ctrl->bRequest) {
+- case USB_REQ_GET_DESCRIPTOR:
+- if (ctrl->bRequestType != USB_DIR_IN)
+- break;
+-
+- switch (wValue >> 8) {
+- case USB_DT_DEVICE:
+- ret = min(wLength,
+- (u16)sizeof(struct usb_device_descriptor));
+- memcpy(req->buf, &gs_device_desc, ret);
+- break;
+-
+- case USB_DT_DEVICE_QUALIFIER:
+- if (!gadget_is_dualspeed(gadget))
+- break;
+- ret = min(wLength,
+- (u16)sizeof(struct usb_qualifier_descriptor));
+- memcpy(req->buf, &gs_qualifier_desc, ret);
+- break;
+-
+- case USB_DT_OTHER_SPEED_CONFIG:
+- if (!gadget_is_dualspeed(gadget))
+- break;
+- /* fall through */
+- case USB_DT_CONFIG:
+- ret = gs_build_config_buf(req->buf, gadget,
+- wValue >> 8, wValue & 0xff,
+- gadget_is_otg(gadget));
+- if (ret >= 0)
+- ret = min(wLength, (u16)ret);
+- break;
+-
+- case USB_DT_STRING:
+- /* wIndex == language code. */
+- ret = usb_gadget_get_string(&gs_string_table,
+- wValue & 0xff, req->buf);
+- if (ret >= 0)
+- ret = min(wLength, (u16)ret);
+- break;
+- }
+- break;
+-
+- case USB_REQ_SET_CONFIGURATION:
+- if (ctrl->bRequestType != 0)
+- break;
+- spin_lock(&dev->dev_lock);
+- ret = gs_set_config(dev, wValue);
+- spin_unlock(&dev->dev_lock);
+- break;
+-
+- case USB_REQ_GET_CONFIGURATION:
+- if (ctrl->bRequestType != USB_DIR_IN)
+- break;
+- *(u8 *)req->buf = dev->dev_config;
+- ret = min(wLength, (u16)1);
+- break;
+-
+- case USB_REQ_SET_INTERFACE:
+- if (ctrl->bRequestType != USB_RECIP_INTERFACE
+- || !dev->dev_config
+- || wIndex >= GS_MAX_NUM_INTERFACES)
+- break;
+- if (dev->dev_config == GS_BULK_CONFIG_ID
+- && wIndex != GS_BULK_INTERFACE_ID)
+- break;
+- /* no alternate interface settings */
+- if (wValue != 0)
+- break;
+- spin_lock(&dev->dev_lock);
+- /* PXA hardware partially handles SET_INTERFACE;
+- * we need to kluge around that interference. */
+- if (gadget_is_pxa(gadget)) {
+- ret = gs_set_config(dev, use_acm ?
+- GS_ACM_CONFIG_ID : GS_BULK_CONFIG_ID);
+- goto set_interface_done;
+- }
+- if (dev->dev_config != GS_BULK_CONFIG_ID
+- && wIndex == GS_CONTROL_INTERFACE_ID) {
+- if (dev->dev_notify_ep) {
+- usb_ep_disable(dev->dev_notify_ep);
+- usb_ep_enable(dev->dev_notify_ep, dev->dev_notify_ep_desc);
+- }
+- } else {
+- usb_ep_disable(dev->dev_in_ep);
+- usb_ep_disable(dev->dev_out_ep);
+- usb_ep_enable(dev->dev_in_ep, dev->dev_in_ep_desc);
+- usb_ep_enable(dev->dev_out_ep, dev->dev_out_ep_desc);
+- }
+- ret = 0;
+-set_interface_done:
+- spin_unlock(&dev->dev_lock);
+- break;
+-
+- case USB_REQ_GET_INTERFACE:
+- if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)
+- || dev->dev_config == GS_NO_CONFIG_ID)
+- break;
+- if (wIndex >= GS_MAX_NUM_INTERFACES
+- || (dev->dev_config == GS_BULK_CONFIG_ID
+- && wIndex != GS_BULK_INTERFACE_ID)) {
+- ret = -EDOM;
+- break;
+- }
+- /* no alternate interface settings */
+- *(u8 *)req->buf = 0;
+- ret = min(wLength, (u16)1);
+- break;
+-
+- default:
+- pr_err("gs_setup: unknown standard request, type=%02x, "
+- "request=%02x, value=%04x, index=%04x, length=%d\n",
+- ctrl->bRequestType, ctrl->bRequest,
+- wValue, wIndex, wLength);
+- break;
+- }
+-
+- return ret;
++fail:
++ gserial_cleanup();
++ return status;
+ }
+
+-static void gs_setup_complete_set_line_coding(struct usb_ep *ep,
+- struct usb_request *req)
+-{
+- struct gs_dev *dev = ep->driver_data;
+- struct gs_port *port = dev->dev_port[0]; /* ACM only has one port */
+-
+- switch (req->status) {
+- case 0:
+- /* normal completion */
+- if (req->actual != sizeof(port->port_line_coding))
+- usb_ep_set_halt(ep);
+- else if (port) {
+- struct usb_cdc_line_coding *value = req->buf;
+-
+- /* REVISIT: we currently just remember this data.
+- * If we change that, (a) validate it first, then
+- * (b) update whatever hardware needs updating.
+- */
+- spin_lock(&port->port_lock);
+- port->port_line_coding = *value;
+- spin_unlock(&port->port_lock);
+- }
+- break;
+-
+- case -ESHUTDOWN:
+- /* disconnect */
+- gs_free_req(ep, req);
+- break;
+-
+- default:
+- /* unexpected */
+- break;
+- }
+- return;
+-}
+-
+-static int gs_setup_class(struct usb_gadget *gadget,
+- const struct usb_ctrlrequest *ctrl)
+-{
+- int ret = -EOPNOTSUPP;
+- struct gs_dev *dev = get_gadget_data(gadget);
+- struct gs_port *port = dev->dev_port[0]; /* ACM only has one port */
+- struct usb_request *req = dev->dev_ctrl_req;
+- u16 wIndex = le16_to_cpu(ctrl->wIndex);
+- u16 wValue = le16_to_cpu(ctrl->wValue);
+- u16 wLength = le16_to_cpu(ctrl->wLength);
+-
+- switch (ctrl->bRequest) {
+- case USB_CDC_REQ_SET_LINE_CODING:
+- if (wLength != sizeof(struct usb_cdc_line_coding))
+- break;
+- ret = wLength;
+- req->complete = gs_setup_complete_set_line_coding;
+- break;
+-
+- case USB_CDC_REQ_GET_LINE_CODING:
+- ret = min_t(int, wLength, sizeof(struct usb_cdc_line_coding));
+- if (port) {
+- spin_lock(&port->port_lock);
+- memcpy(req->buf, &port->port_line_coding, ret);
+- spin_unlock(&port->port_lock);
+- }
+- break;
+-
+- case USB_CDC_REQ_SET_CONTROL_LINE_STATE:
+- if (wLength != 0)
+- break;
+- ret = 0;
+- if (port) {
+- /* REVISIT: we currently just remember this data.
+- * If we change that, update whatever hardware needs
+- * updating.
+- */
+- spin_lock(&port->port_lock);
+- port->port_handshake_bits = wValue;
+- spin_unlock(&port->port_lock);
+- }
+- break;
+-
+- default:
+- /* NOTE: strictly speaking, we should accept AT-commands
+- * using SEND_ENCPSULATED_COMMAND/GET_ENCAPSULATED_RESPONSE.
+- * But our call management descriptor says we don't handle
+- * call management, so we should be able to get by without
+- * handling those "required" commands (except by stalling).
+- */
+- pr_err("gs_setup: unknown class request, "
+- "type=%02x, request=%02x, value=%04x, "
+- "index=%04x, length=%d\n",
+- ctrl->bRequestType, ctrl->bRequest,
+- wValue, wIndex, wLength);
+- break;
+- }
+-
+- return ret;
+-}
+-
+-/*
+- * gs_setup_complete
+- */
+-static void gs_setup_complete(struct usb_ep *ep, struct usb_request *req)
+-{
+- if (req->status || req->actual != req->length) {
+- pr_err("gs_setup_complete: status error, status=%d, "
+- "actual=%d, length=%d\n",
+- req->status, req->actual, req->length);
+- }
+-}
+-
+-/*
+- * gs_setup
+- *
+- * Implements all the control endpoint functionality that's not
+- * handled in hardware or the hardware driver.
+- *
+- * Returns the size of the data sent to the host, or a negative
+- * error number.
+- */
+-static int gs_setup(struct usb_gadget *gadget,
+- const struct usb_ctrlrequest *ctrl)
+-{
+- int ret = -EOPNOTSUPP;
+- struct gs_dev *dev = get_gadget_data(gadget);
+- struct usb_request *req = dev->dev_ctrl_req;
+- u16 wIndex = le16_to_cpu(ctrl->wIndex);
+- u16 wValue = le16_to_cpu(ctrl->wValue);
+- u16 wLength = le16_to_cpu(ctrl->wLength);
+-
+- req->complete = gs_setup_complete;
+-
+- switch (ctrl->bRequestType & USB_TYPE_MASK) {
+- case USB_TYPE_STANDARD:
+- ret = gs_setup_standard(gadget, ctrl);
+- break;
+-
+- case USB_TYPE_CLASS:
+- ret = gs_setup_class(gadget, ctrl);
+- break;
+-
+- default:
+- pr_err("gs_setup: unknown request, type=%02x, request=%02x, "
+- "value=%04x, index=%04x, length=%d\n",
+- ctrl->bRequestType, ctrl->bRequest,
+- wValue, wIndex, wLength);
+- break;
+- }
+-
+- /* respond with data transfer before status phase? */
+- if (ret >= 0) {
+- req->length = ret;
+- req->zero = ret < wLength
+- && (ret % gadget->ep0->maxpacket) == 0;
+- ret = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
+- if (ret < 0) {
+- pr_err("gs_setup: cannot queue response, ret=%d\n",
+- ret);
+- req->status = 0;
+- gs_setup_complete(gadget->ep0, req);
+- }
+- }
+-
+- /* device either stalls (ret < 0) or reports success */
+- return ret;
+-}
+-
+-/*
+- * gs_disconnect
+- *
+- * Called when the device is disconnected. Frees the closed
+- * ports and disconnects open ports. Open ports will be freed
+- * on close. Then reallocates the ports for the next connection.
+- */
+-static void gs_disconnect(struct usb_gadget *gadget)
+-{
+- unsigned long flags;
+- struct gs_dev *dev = get_gadget_data(gadget);
+-
+- spin_lock_irqsave(&dev->dev_lock, flags);
+-
+- gs_reset_config(dev);
+-
+- /* free closed ports and disconnect open ports */
+- /* (open ports will be freed when closed) */
+- gs_free_ports(dev);
+-
+- /* re-allocate ports for the next connection */
+- if (gs_alloc_ports(dev, GFP_ATOMIC) != 0)
+- pr_err("gs_disconnect: cannot re-allocate ports\n");
+-
+- spin_unlock_irqrestore(&dev->dev_lock, flags);
+-
+- pr_info("gs_disconnect: %s disconnected\n", GS_LONG_NAME);
+-}
+-
+-static struct usb_gadget_driver gs_gadget_driver = {
+-#ifdef CONFIG_USB_GADGET_DUALSPEED
+- .speed = USB_SPEED_HIGH,
+-#else
+- .speed = USB_SPEED_FULL,
+-#endif /* CONFIG_USB_GADGET_DUALSPEED */
+- .function = GS_LONG_NAME,
+- .bind = gs_bind,
+- .unbind = gs_unbind,
+- .setup = gs_setup,
+- .disconnect = gs_disconnect,
+- .driver = {
+- .name = GS_SHORT_NAME,
+- .owner = THIS_MODULE,
+- },
++static struct usb_composite_driver gserial_driver = {
++ .name = "g_serial",
++ .dev = &device_desc,
++ .strings = dev_strings,
++ .bind = gs_bind,
+ };
+
+-/*
+- * gs_set_config
+- *
+- * Configures the device by enabling device specific
+- * optimizations, setting up the endpoints, allocating
+- * read and write requests and queuing read requests.
+- *
+- * The device lock must be held when calling this function.
+- */
+-static int gs_set_config(struct gs_dev *dev, unsigned config)
++static int __init init(void)
+ {
+- int i;
+- int ret = 0;
+- struct usb_gadget *gadget = dev->dev_gadget;
+- struct usb_ep *ep;
+- struct usb_endpoint_descriptor *out, *in, *notify;
+- struct usb_request *req;
+-
+- if (dev == NULL) {
+- pr_err("gs_set_config: NULL device pointer\n");
+- return 0;
+- }
+-
+- if (config == dev->dev_config)
+- return 0;
+-
+- gs_reset_config(dev);
+-
+- switch (config) {
+- case GS_NO_CONFIG_ID:
+- return 0;
+- case GS_BULK_CONFIG_ID:
+- if (use_acm)
+- return -EINVAL;
+- break;
+- case GS_ACM_CONFIG_ID:
+- if (!use_acm)
+- return -EINVAL;
+- break;
+- default:
+- return -EINVAL;
+- }
+-
+- in = choose_ep_desc(gadget,
+- &gs_highspeed_in_desc,
+- &gs_fullspeed_in_desc);
+- out = choose_ep_desc(gadget,
+- &gs_highspeed_out_desc,
+- &gs_fullspeed_out_desc);
+- notify = dev->dev_notify_ep
+- ? choose_ep_desc(gadget,
+- &gs_highspeed_notify_desc,
+- &gs_fullspeed_notify_desc)
+- : NULL;
+-
+- ret = usb_ep_enable(dev->dev_in_ep, in);
+- if (ret == 0) {
+- dev->dev_in_ep_desc = in;
+- } else {
+- pr_debug("%s: cannot enable %s %s, ret=%d\n",
+- __func__, "IN", dev->dev_in_ep->name, ret);
+- return ret;
+- }
+-
+- ret = usb_ep_enable(dev->dev_out_ep, out);
+- if (ret == 0) {
+- dev->dev_out_ep_desc = out;
+- } else {
+- pr_debug("%s: cannot enable %s %s, ret=%d\n",
+- __func__, "OUT", dev->dev_out_ep->name, ret);
+-fail0:
+- usb_ep_disable(dev->dev_in_ep);
+- return ret;
+- }
+-
+- if (notify) {
+- ret = usb_ep_enable(dev->dev_notify_ep, notify);
+- if (ret == 0) {
+- dev->dev_notify_ep_desc = notify;
+- } else {
+- pr_debug("%s: cannot enable %s %s, ret=%d\n",
+- __func__, "NOTIFY",
+- dev->dev_notify_ep->name, ret);
+- usb_ep_disable(dev->dev_out_ep);
+- goto fail0;
+- }
+- }
+-
+- dev->dev_config = config;
+-
+- /* allocate and queue read requests */
+- ep = dev->dev_out_ep;
+- for (i=0; i<read_q_size && ret == 0; i++) {
+- if ((req=gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC))) {
+- req->complete = gs_read_complete;
+- if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
+- pr_err("gs_set_config: cannot queue read "
+- "request, ret=%d\n", ret);
+- }
+- } else {
+- pr_err("gs_set_config: cannot allocate "
+- "read requests\n");
+- ret = -ENOMEM;
+- goto exit_reset_config;
+- }
+- }
+-
+- /* allocate write requests, and put on free list */
+- ep = dev->dev_in_ep;
+- for (i=0; i<write_q_size; i++) {
+- req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
+- if (req) {
+- req->complete = gs_write_complete;
+- list_add(&req->list, &dev->dev_req_list);
+- } else {
+- pr_err("gs_set_config: cannot allocate "
+- "write requests\n");
+- ret = -ENOMEM;
+- goto exit_reset_config;
+- }
+- }
+-
+- /* REVISIT the ACM mode should be able to actually *issue* some
+- * notifications, for at least serial state change events if
+- * not also for network connection; say so in bmCapabilities.
++ /* We *could* export two configs; that'd be much cleaner...
++ * but neither of these product IDs was defined that way.
+ */
+-
+- pr_info("gs_set_config: %s configured, %s speed %s config\n",
+- GS_LONG_NAME,
+- gadget->speed == USB_SPEED_HIGH ? "high" : "full",
+- config == GS_BULK_CONFIG_ID ? "BULK" : "CDC-ACM");
+-
+- return 0;
+-
+-exit_reset_config:
+- gs_reset_config(dev);
+- return ret;
+-}
+-
+-/*
+- * gs_reset_config
+- *
+- * Mark the device as not configured, disable all endpoints,
+- * which forces completion of pending I/O and frees queued
+- * requests, and free the remaining write requests on the
+- * free list.
+- *
+- * The device lock must be held when calling this function.
+- */
+-static void gs_reset_config(struct gs_dev *dev)
+-{
+- struct usb_request *req;
+-
+- if (dev == NULL) {
+- pr_err("gs_reset_config: NULL device pointer\n");
+- return;
+- }
+-
+- if (dev->dev_config == GS_NO_CONFIG_ID)
+- return;
+-
+- dev->dev_config = GS_NO_CONFIG_ID;
+-
+- /* free write requests on the free list */
+- while(!list_empty(&dev->dev_req_list)) {
+- req = list_entry(dev->dev_req_list.next,
+- struct usb_request, list);
+- list_del(&req->list);
+- gs_free_req(dev->dev_in_ep, req);
+- }
+-
+- /* disable endpoints, forcing completion of pending i/o; */
+- /* completion handlers free their requests in this case */
+- if (dev->dev_notify_ep)
+- usb_ep_disable(dev->dev_notify_ep);
+- usb_ep_disable(dev->dev_in_ep);
+- usb_ep_disable(dev->dev_out_ep);
+-}
+-
+-/*
+- * gs_build_config_buf
+- *
+- * Builds the config descriptors in the given buffer and returns the
+- * length, or a negative error number.
+- */
+-static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
+- u8 type, unsigned int index, int is_otg)
+-{
+- int len;
+- int high_speed = 0;
+- const struct usb_config_descriptor *config_desc;
+- const struct usb_descriptor_header **function;
+-
+- if (index >= gs_device_desc.bNumConfigurations)
+- return -EINVAL;
+-
+- /* other speed switches high and full speed */
+- if (gadget_is_dualspeed(g)) {
+- high_speed = (g->speed == USB_SPEED_HIGH);
+- if (type == USB_DT_OTHER_SPEED_CONFIG)
+- high_speed = !high_speed;
+- }
+-
+ if (use_acm) {
+- config_desc = &gs_acm_config_desc;
+- function = high_speed
+- ? gs_acm_highspeed_function
+- : gs_acm_fullspeed_function;
++ serial_config_driver.label = "CDC ACM config";
++ serial_config_driver.bConfigurationValue = 2;
++ device_desc.bDeviceClass = USB_CLASS_COMM;
++ device_desc.idProduct =
++ __constant_cpu_to_le16(GS_CDC_PRODUCT_ID);
+ } else {
+- config_desc = &gs_bulk_config_desc;
+- function = high_speed
+- ? gs_bulk_highspeed_function
+- : gs_bulk_fullspeed_function;
+- }
+-
+- /* for now, don't advertise srp-only devices */
+- if (!is_otg)
+- function++;
+-
+- len = usb_gadget_config_buf(config_desc, buf, GS_MAX_DESC_LEN, function);
+- if (len < 0)
+- return len;
+-
+- ((struct usb_config_descriptor *)buf)->bDescriptorType = type;
+-
+- return len;
+-}
+-
+-/*
+- * gs_alloc_req
+- *
+- * Allocate a usb_request and its buffer. Returns a pointer to the
+- * usb_request or NULL if there is an error.
+- */
+-static struct usb_request *
+-gs_alloc_req(struct usb_ep *ep, unsigned int len, gfp_t kmalloc_flags)
+-{
+- struct usb_request *req;
+-
+- if (ep == NULL)
+- return NULL;
+-
+- req = usb_ep_alloc_request(ep, kmalloc_flags);
+-
+- if (req != NULL) {
+- req->length = len;
+- req->buf = kmalloc(len, kmalloc_flags);
+- if (req->buf == NULL) {
+- usb_ep_free_request(ep, req);
+- return NULL;
+- }
++ serial_config_driver.label = "Generic Serial config";
++ serial_config_driver.bConfigurationValue = 1;
++ device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC;
++ device_desc.idProduct =
++ __constant_cpu_to_le16(GS_PRODUCT_ID);
+ }
++ strings_dev[STRING_DESCRIPTION_IDX].s = serial_config_driver.label;
+
+- return req;
++ return usb_composite_register(&gserial_driver);
+ }
++module_init(init);
+
+-/*
+- * gs_free_req
+- *
+- * Free a usb_request and its buffer.
+- */
+-static void gs_free_req(struct usb_ep *ep, struct usb_request *req)
++static void __exit cleanup(void)
+ {
+- if (ep != NULL && req != NULL) {
+- kfree(req->buf);
+- usb_ep_free_request(ep, req);
+- }
+-}
+-
+-/*
+- * gs_alloc_ports
+- *
+- * Allocate all ports and set the gs_dev struct to point to them.
+- * Return 0 if successful, or a negative error number.
+- *
+- * The device lock is normally held when calling this function.
+- */
+-static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags)
+-{
+- int i;
+- struct gs_port *port;
+-
+- if (dev == NULL)
+- return -EIO;
+-
+- for (i=0; i<GS_NUM_PORTS; i++) {
+- if ((port=kzalloc(sizeof(struct gs_port), kmalloc_flags)) == NULL)
+- return -ENOMEM;
+-
+- port->port_dev = dev;
+- port->port_num = i;
+- port->port_line_coding.dwDTERate = cpu_to_le32(GS_DEFAULT_DTE_RATE);
+- port->port_line_coding.bCharFormat = GS_DEFAULT_CHAR_FORMAT;
+- port->port_line_coding.bParityType = GS_DEFAULT_PARITY;
+- port->port_line_coding.bDataBits = GS_DEFAULT_DATA_BITS;
+- spin_lock_init(&port->port_lock);
+- init_waitqueue_head(&port->port_write_wait);
+-
+- dev->dev_port[i] = port;
+- }
+-
+- return 0;
+-}
+-
+-/*
+- * gs_free_ports
+- *
+- * Free all closed ports. Open ports are disconnected by
+- * freeing their write buffers, setting their device pointers
+- * and the pointers to them in the device to NULL. These
+- * ports will be freed when closed.
+- *
+- * The device lock is normally held when calling this function.
+- */
+-static void gs_free_ports(struct gs_dev *dev)
+-{
+- int i;
+- unsigned long flags;
+- struct gs_port *port;
+-
+- if (dev == NULL)
+- return;
+-
+- for (i=0; i<GS_NUM_PORTS; i++) {
+- if ((port=dev->dev_port[i]) != NULL) {
+- dev->dev_port[i] = NULL;
+-
+- spin_lock_irqsave(&port->port_lock, flags);
+-
+- if (port->port_write_buf != NULL) {
+- gs_buf_free(port->port_write_buf);
+- port->port_write_buf = NULL;
+- }
+-
+- if (port->port_open_count > 0 || port->port_in_use) {
+- port->port_dev = NULL;
+- wake_up_interruptible(&port->port_write_wait);
+- if (port->port_tty) {
+- tty_hangup(port->port_tty);
+- }
+- spin_unlock_irqrestore(&port->port_lock, flags);
+- } else {
+- spin_unlock_irqrestore(&port->port_lock, flags);
+- kfree(port);
+- }
+-
+- }
+- }
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/* Circular Buffer */
+-
+-/*
+- * gs_buf_alloc
+- *
+- * Allocate a circular buffer and all associated memory.
+- */
+-static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags)
+-{
+- struct gs_buf *gb;
+-
+- if (size == 0)
+- return NULL;
+-
+- gb = kmalloc(sizeof(struct gs_buf), kmalloc_flags);
+- if (gb == NULL)
+- return NULL;
+-
+- gb->buf_buf = kmalloc(size, kmalloc_flags);
+- if (gb->buf_buf == NULL) {
+- kfree(gb);
+- return NULL;
+- }
+-
+- gb->buf_size = size;
+- gb->buf_get = gb->buf_put = gb->buf_buf;
+-
+- return gb;
+-}
+-
+-/*
+- * gs_buf_free
+- *
+- * Free the buffer and all associated memory.
+- */
+-static void gs_buf_free(struct gs_buf *gb)
+-{
+- if (gb) {
+- kfree(gb->buf_buf);
+- kfree(gb);
+- }
+-}
+-
+-/*
+- * gs_buf_clear
+- *
+- * Clear out all data in the circular buffer.
+- */
+-static void gs_buf_clear(struct gs_buf *gb)
+-{
+- if (gb != NULL)
+- gb->buf_get = gb->buf_put;
+- /* equivalent to a get of all data available */
+-}
+-
+-/*
+- * gs_buf_data_avail
+- *
+- * Return the number of bytes of data available in the circular
+- * buffer.
+- */
+-static unsigned int gs_buf_data_avail(struct gs_buf *gb)
+-{
+- if (gb != NULL)
+- return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size;
+- else
+- return 0;
+-}
+-
+-/*
+- * gs_buf_space_avail
+- *
+- * Return the number of bytes of space available in the circular
+- * buffer.
+- */
+-static unsigned int gs_buf_space_avail(struct gs_buf *gb)
+-{
+- if (gb != NULL)
+- return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size;
+- else
+- return 0;
+-}
+-
+-/*
+- * gs_buf_put
+- *
+- * Copy data data from a user buffer and put it into the circular buffer.
+- * Restrict to the amount of space available.
+- *
+- * Return the number of bytes copied.
+- */
+-static unsigned int
+-gs_buf_put(struct gs_buf *gb, const char *buf, unsigned int count)
+-{
+- unsigned int len;
+-
+- if (gb == NULL)
+- return 0;
+-
+- len = gs_buf_space_avail(gb);
+- if (count > len)
+- count = len;
+-
+- if (count == 0)
+- return 0;
+-
+- len = gb->buf_buf + gb->buf_size - gb->buf_put;
+- if (count > len) {
+- memcpy(gb->buf_put, buf, len);
+- memcpy(gb->buf_buf, buf+len, count - len);
+- gb->buf_put = gb->buf_buf + count - len;
+- } else {
+- memcpy(gb->buf_put, buf, count);
+- if (count < len)
+- gb->buf_put += count;
+- else /* count == len */
+- gb->buf_put = gb->buf_buf;
+- }
+-
+- return count;
+-}
+-
+-/*
+- * gs_buf_get
+- *
+- * Get data from the circular buffer and copy to the given buffer.
+- * Restrict to the amount of data available.
+- *
+- * Return the number of bytes copied.
+- */
+-static unsigned int
+-gs_buf_get(struct gs_buf *gb, char *buf, unsigned int count)
+-{
+- unsigned int len;
+-
+- if (gb == NULL)
+- return 0;
+-
+- len = gs_buf_data_avail(gb);
+- if (count > len)
+- count = len;
+-
+- if (count == 0)
+- return 0;
+-
+- len = gb->buf_buf + gb->buf_size - gb->buf_get;
+- if (count > len) {
+- memcpy(buf, gb->buf_get, len);
+- memcpy(buf+len, gb->buf_buf, count - len);
+- gb->buf_get = gb->buf_buf + count - len;
+- } else {
+- memcpy(buf, gb->buf_get, count);
+- if (count < len)
+- gb->buf_get += count;
+- else /* count == len */
+- gb->buf_get = gb->buf_buf;
+- }
+-
+- return count;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static struct tty_driver *gs_tty_driver;
+-
+-/*
+- * gs_module_init
+- *
+- * Register as a USB gadget driver and a tty driver.
+- */
+-static int __init gs_module_init(void)
+-{
+- int i;
+- int retval;
+-
+- retval = usb_gadget_register_driver(&gs_gadget_driver);
+- if (retval) {
+- pr_err("gs_module_init: cannot register gadget driver, "
+- "ret=%d\n", retval);
+- return retval;
+- }
+-
+- gs_tty_driver = alloc_tty_driver(GS_NUM_PORTS);
+- if (!gs_tty_driver)
+- return -ENOMEM;
+- gs_tty_driver->owner = THIS_MODULE;
+- gs_tty_driver->driver_name = GS_SHORT_NAME;
+- gs_tty_driver->name = "ttygs";
+- gs_tty_driver->major = GS_MAJOR;
+- gs_tty_driver->minor_start = GS_MINOR_START;
+- gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
+- gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
+- gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
+- gs_tty_driver->init_termios = tty_std_termios;
+- /* must match GS_DEFAULT_DTE_RATE and friends */
+- gs_tty_driver->init_termios.c_cflag =
+- B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+- gs_tty_driver->init_termios.c_ispeed = GS_DEFAULT_DTE_RATE;
+- gs_tty_driver->init_termios.c_ospeed = GS_DEFAULT_DTE_RATE;
+- tty_set_operations(gs_tty_driver, &gs_tty_ops);
+-
+- for (i = 0; i < GS_NUM_PORTS; i++)
+- mutex_init(&gs_open_close_lock[i]);
+-
+- retval = tty_register_driver(gs_tty_driver);
+- if (retval) {
+- usb_gadget_unregister_driver(&gs_gadget_driver);
+- put_tty_driver(gs_tty_driver);
+- pr_err("gs_module_init: cannot register tty driver, "
+- "ret=%d\n", retval);
+- return retval;
+- }
+-
+- pr_info("gs_module_init: %s %s loaded\n",
+- GS_LONG_NAME, GS_VERSION_STR);
+- return 0;
+-}
+-module_init(gs_module_init);
+-
+-/*
+- * gs_module_exit
+- *
+- * Unregister as a tty driver and a USB gadget driver.
+- */
+-static void __exit gs_module_exit(void)
+-{
+- tty_unregister_driver(gs_tty_driver);
+- put_tty_driver(gs_tty_driver);
+- usb_gadget_unregister_driver(&gs_gadget_driver);
+-
+- pr_info("gs_module_exit: %s %s unloaded\n",
+- GS_LONG_NAME, GS_VERSION_STR);
++ usb_composite_unregister(&gserial_driver);
++ gserial_cleanup();
+ }
+-module_exit(gs_module_exit);
++module_exit(cleanup);
+diff --git a/drivers/usb/gadget/u_ether.c b/drivers/usb/gadget/u_ether.c
+new file mode 100644
+index 0000000..3791e62
+--- /dev/null
++++ b/drivers/usb/gadget/u_ether.c
+@@ -0,0 +1,964 @@
++/*
++ * u_ether.c -- Ethernet-over-USB link layer utilities for Gadget stack
++ *
++ * Copyright (C) 2003-2005,2008 David Brownell
++ * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
++ * Copyright (C) 2008 Nokia Corporation
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++/* #define VERBOSE_DEBUG */
++
++#include <linux/kernel.h>
++#include <linux/utsname.h>
++#include <linux/device.h>
++#include <linux/ctype.h>
++#include <linux/etherdevice.h>
++#include <linux/ethtool.h>
++
++#include "u_ether.h"
++
++
++/*
++ * This component encapsulates the Ethernet link glue needed to provide
++ * one (!) network link through the USB gadget stack, normally "usb0".
++ *
++ * The control and data models are handled by the function driver which
++ * connects to this code; such as CDC Ethernet, "CDC Subset", or RNDIS.
++ * That includes all descriptor and endpoint management.
++ *
++ * Link level addressing is handled by this component using module
++ * parameters; if no such parameters are provided, random link level
++ * addresses are used. Each end of the link uses one address. The
++ * host end address is exported in various ways, and is often recorded
++ * in configuration databases.
++ *
++ * The driver which assembles each configuration using such a link is
++ * responsible for ensuring that each configuration includes at most one
++ * instance of is network link. (The network layer provides ways for
++ * this single "physical" link to be used by multiple virtual links.)
++ */
++
++#define DRIVER_VERSION "29-May-2008"
++
++struct eth_dev {
++ /* lock is held while accessing port_usb
++ * or updating its backlink port_usb->ioport
++ */
++ spinlock_t lock;
++ struct gether *port_usb;
++
++ struct net_device *net;
++ struct usb_gadget *gadget;
++
++ spinlock_t req_lock; /* guard {rx,tx}_reqs */
++ struct list_head tx_reqs, rx_reqs;
++ atomic_t tx_qlen;
++
++ unsigned header_len;
++ struct sk_buff *(*wrap)(struct sk_buff *skb);
++ int (*unwrap)(struct sk_buff *skb);
++
++ struct work_struct work;
++
++ unsigned long todo;
++#define WORK_RX_MEMORY 0
++
++ bool zlp;
++ u8 host_mac[ETH_ALEN];
++};
++
++/*-------------------------------------------------------------------------*/
++
++#define RX_EXTRA 20 /* bytes guarding against rx overflows */
++
++#define DEFAULT_QLEN 2 /* double buffering by default */
++
++
++#ifdef CONFIG_USB_GADGET_DUALSPEED
++
++static unsigned qmult = 5;
++module_param(qmult, uint, S_IRUGO|S_IWUSR);
++MODULE_PARM_DESC(qmult, "queue length multiplier at high speed");
++
++#else /* full speed (low speed doesn't do bulk) */
++#define qmult 1
++#endif
++
++/* for dual-speed hardware, use deeper queues at highspeed */
++static inline int qlen(struct usb_gadget *gadget)
++{
++ if (gadget_is_dualspeed(gadget) && gadget->speed == USB_SPEED_HIGH)
++ return qmult * DEFAULT_QLEN;
++ else
++ return DEFAULT_QLEN;
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* REVISIT there must be a better way than having two sets
++ * of debug calls ...
++ */
++
++#undef DBG
++#undef VDBG
++#undef ERROR
++#undef INFO
++
++#define xprintk(d, level, fmt, args...) \
++ printk(level "%s: " fmt , (d)->net->name , ## args)
++
++#ifdef DEBUG
++#undef DEBUG
++#define DBG(dev, fmt, args...) \
++ xprintk(dev , KERN_DEBUG , fmt , ## args)
++#else
++#define DBG(dev, fmt, args...) \
++ do { } while (0)
++#endif /* DEBUG */
++
++#ifdef VERBOSE_DEBUG
++#define VDBG DBG
++#else
++#define VDBG(dev, fmt, args...) \
++ do { } while (0)
++#endif /* DEBUG */
++
++#define ERROR(dev, fmt, args...) \
++ xprintk(dev , KERN_ERR , fmt , ## args)
++#define INFO(dev, fmt, args...) \
++ xprintk(dev , KERN_INFO , fmt , ## args)
++
++/*-------------------------------------------------------------------------*/
++
++/* NETWORK DRIVER HOOKUP (to the layer above this driver) */
++
++static int eth_change_mtu(struct net_device *net, int new_mtu)
++{
++ struct eth_dev *dev = netdev_priv(net);
++ unsigned long flags;
++ int status = 0;
++
++ /* don't change MTU on "live" link (peer won't know) */
++ spin_lock_irqsave(&dev->lock, flags);
++ if (dev->port_usb)
++ status = -EBUSY;
++ else if (new_mtu <= ETH_HLEN || new_mtu > ETH_FRAME_LEN)
++ status = -ERANGE;
++ else
++ net->mtu = new_mtu;
++ spin_unlock_irqrestore(&dev->lock, flags);
++
++ return status;
++}
++
++static void eth_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *p)
++{
++ struct eth_dev *dev = netdev_priv(net);
++
++ strlcpy(p->driver, "g_ether", sizeof p->driver);
++ strlcpy(p->version, DRIVER_VERSION, sizeof p->version);
++ strlcpy(p->fw_version, dev->gadget->name, sizeof p->fw_version);
++ strlcpy(p->bus_info, dev_name(&dev->gadget->dev), sizeof p->bus_info);
++}
++
++static u32 eth_get_link(struct net_device *net)
++{
++ struct eth_dev *dev = netdev_priv(net);
++ return dev->gadget->speed != USB_SPEED_UNKNOWN;
++}
++
++/* REVISIT can also support:
++ * - WOL (by tracking suspends and issuing remote wakeup)
++ * - msglevel (implies updated messaging)
++ * - ... probably more ethtool ops
++ */
++
++static struct ethtool_ops ops = {
++ .get_drvinfo = eth_get_drvinfo,
++ .get_link = eth_get_link
++};
++
++static void defer_kevent(struct eth_dev *dev, int flag)
++{
++ if (test_and_set_bit(flag, &dev->todo))
++ return;
++ if (!schedule_work(&dev->work))
++ ERROR(dev, "kevent %d may have been dropped\n", flag);
++ else
++ DBG(dev, "kevent %d scheduled\n", flag);
++}
++
++static void rx_complete(struct usb_ep *ep, struct usb_request *req);
++
++static int
++rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags)
++{
++ struct sk_buff *skb;
++ int retval = -ENOMEM;
++ size_t size = 0;
++ struct usb_ep *out;
++ unsigned long flags;
++
++ spin_lock_irqsave(&dev->lock, flags);
++ if (dev->port_usb)
++ out = dev->port_usb->out_ep;
++ else
++ out = NULL;
++ spin_unlock_irqrestore(&dev->lock, flags);
++
++ if (!out)
++ return -ENOTCONN;
++
++
++ /* Padding up to RX_EXTRA handles minor disagreements with host.
++ * Normally we use the USB "terminate on short read" convention;
++ * so allow up to (N*maxpacket), since that memory is normally
++ * already allocated. Some hardware doesn't deal well with short
++ * reads (e.g. DMA must be N*maxpacket), so for now don't trim a
++ * byte off the end (to force hardware errors on overflow).
++ *
++ * RNDIS uses internal framing, and explicitly allows senders to
++ * pad to end-of-packet. That's potentially nice for speed, but
++ * means receivers can't recover lost synch on their own (because
++ * new packets don't only start after a short RX).
++ */
++ size += sizeof(struct ethhdr) + dev->net->mtu + RX_EXTRA;
++ size += dev->port_usb->header_len;
++ size += out->maxpacket - 1;
++ size -= size % out->maxpacket;
++
++ skb = alloc_skb(size + NET_IP_ALIGN, gfp_flags);
++ if (skb == NULL) {
++ DBG(dev, "no rx skb\n");
++ goto enomem;
++ }
++
++ /* Some platforms perform better when IP packets are aligned,
++ * but on at least one, checksumming fails otherwise. Note:
++ * RNDIS headers involve variable numbers of LE32 values.
++ */
++ skb_reserve(skb, NET_IP_ALIGN);
++
++ req->buf = skb->data;
++ req->length = size;
++ req->complete = rx_complete;
++ req->context = skb;
++
++ retval = usb_ep_queue(out, req, gfp_flags);
++ if (retval == -ENOMEM)
++enomem:
++ defer_kevent(dev, WORK_RX_MEMORY);
++ if (retval) {
++ DBG(dev, "rx submit --> %d\n", retval);
++ if (skb)
++ dev_kfree_skb_any(skb);
++ spin_lock_irqsave(&dev->req_lock, flags);
++ list_add(&req->list, &dev->rx_reqs);
++ spin_unlock_irqrestore(&dev->req_lock, flags);
++ }
++ return retval;
++}
++
++static void rx_complete(struct usb_ep *ep, struct usb_request *req)
++{
++ struct sk_buff *skb = req->context;
++ struct eth_dev *dev = ep->driver_data;
++ int status = req->status;
++
++ switch (status) {
++
++ /* normal completion */
++ case 0:
++ skb_put(skb, req->actual);
++ if (dev->unwrap)
++ status = dev->unwrap(skb);
++ if (status < 0
++ || ETH_HLEN > skb->len
++ || skb->len > ETH_FRAME_LEN) {
++ dev->net->stats.rx_errors++;
++ dev->net->stats.rx_length_errors++;
++ DBG(dev, "rx length %d\n", skb->len);
++ break;
++ }
++
++ skb->protocol = eth_type_trans(skb, dev->net);
++ dev->net->stats.rx_packets++;
++ dev->net->stats.rx_bytes += skb->len;
++
++ /* no buffer copies needed, unless hardware can't
++ * use skb buffers.
++ */
++ status = netif_rx(skb);
++ skb = NULL;
++ break;
++
++ /* software-driven interface shutdown */
++ case -ECONNRESET: /* unlink */
++ case -ESHUTDOWN: /* disconnect etc */
++ VDBG(dev, "rx shutdown, code %d\n", status);
++ goto quiesce;
++
++ /* for hardware automagic (such as pxa) */
++ case -ECONNABORTED: /* endpoint reset */
++ DBG(dev, "rx %s reset\n", ep->name);
++ defer_kevent(dev, WORK_RX_MEMORY);
++quiesce:
++ dev_kfree_skb_any(skb);
++ goto clean;
++
++ /* data overrun */
++ case -EOVERFLOW:
++ dev->net->stats.rx_over_errors++;
++ /* FALLTHROUGH */
++
++ default:
++ dev->net->stats.rx_errors++;
++ DBG(dev, "rx status %d\n", status);
++ break;
++ }
++
++ if (skb)
++ dev_kfree_skb_any(skb);
++ if (!netif_running(dev->net)) {
++clean:
++ spin_lock(&dev->req_lock);
++ list_add(&req->list, &dev->rx_reqs);
++ spin_unlock(&dev->req_lock);
++ req = NULL;
++ }
++ if (req)
++ rx_submit(dev, req, GFP_ATOMIC);
++}
++
++static int prealloc(struct list_head *list, struct usb_ep *ep, unsigned n)
++{
++ unsigned i;
++ struct usb_request *req;
++
++ if (!n)
++ return -ENOMEM;
++
++ /* queue/recycle up to N requests */
++ i = n;
++ list_for_each_entry(req, list, list) {
++ if (i-- == 0)
++ goto extra;
++ }
++ while (i--) {
++ req = usb_ep_alloc_request(ep, GFP_ATOMIC);
++ if (!req)
++ return list_empty(list) ? -ENOMEM : 0;
++ list_add(&req->list, list);
++ }
++ return 0;
++
++extra:
++ /* free extras */
++ for (;;) {
++ struct list_head *next;
++
++ next = req->list.next;
++ list_del(&req->list);
++ usb_ep_free_request(ep, req);
++
++ if (next == list)
++ break;
++
++ req = container_of(next, struct usb_request, list);
++ }
++ return 0;
++}
++
++static int alloc_requests(struct eth_dev *dev, struct gether *link, unsigned n)
++{
++ int status;
++
++ spin_lock(&dev->req_lock);
++ status = prealloc(&dev->tx_reqs, link->in_ep, n);
++ if (status < 0)
++ goto fail;
++ status = prealloc(&dev->rx_reqs, link->out_ep, n);
++ if (status < 0)
++ goto fail;
++ goto done;
++fail:
++ DBG(dev, "can't alloc requests\n");
++done:
++ spin_unlock(&dev->req_lock);
++ return status;
++}
++
++static void rx_fill(struct eth_dev *dev, gfp_t gfp_flags)
++{
++ struct usb_request *req;
++ unsigned long flags;
++
++ /* fill unused rxq slots with some skb */
++ spin_lock_irqsave(&dev->req_lock, flags);
++ while (!list_empty(&dev->rx_reqs)) {
++ req = container_of(dev->rx_reqs.next,
++ struct usb_request, list);
++ list_del_init(&req->list);
++ spin_unlock_irqrestore(&dev->req_lock, flags);
++
++ if (rx_submit(dev, req, gfp_flags) < 0) {
++ defer_kevent(dev, WORK_RX_MEMORY);
++ return;
++ }
++
++ spin_lock_irqsave(&dev->req_lock, flags);
++ }
++ spin_unlock_irqrestore(&dev->req_lock, flags);
++}
++
++static void eth_work(struct work_struct *work)
++{
++ struct eth_dev *dev = container_of(work, struct eth_dev, work);
++
++ if (test_and_clear_bit(WORK_RX_MEMORY, &dev->todo)) {
++ if (netif_running(dev->net))
++ rx_fill(dev, GFP_KERNEL);
++ }
++
++ if (dev->todo)
++ DBG(dev, "work done, flags = 0x%lx\n", dev->todo);
++}
++
++static void tx_complete(struct usb_ep *ep, struct usb_request *req)
++{
++ struct sk_buff *skb = req->context;
++ struct eth_dev *dev = ep->driver_data;
++
++ switch (req->status) {
++ default:
++ dev->net->stats.tx_errors++;
++ VDBG(dev, "tx err %d\n", req->status);
++ /* FALLTHROUGH */
++ case -ECONNRESET: /* unlink */
++ case -ESHUTDOWN: /* disconnect etc */
++ break;
++ case 0:
++ dev->net->stats.tx_bytes += skb->len;
++ }
++ dev->net->stats.tx_packets++;
++
++ spin_lock(&dev->req_lock);
++ list_add(&req->list, &dev->tx_reqs);
++ spin_unlock(&dev->req_lock);
++ dev_kfree_skb_any(skb);
++
++ atomic_dec(&dev->tx_qlen);
++ if (netif_carrier_ok(dev->net))
++ netif_wake_queue(dev->net);
++}
++
++static inline int is_promisc(u16 cdc_filter)
++{
++ return cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;
++}
++
++static int eth_start_xmit(struct sk_buff *skb, struct net_device *net)
++{
++ struct eth_dev *dev = netdev_priv(net);
++ int length = skb->len;
++ int retval;
++ struct usb_request *req = NULL;
++ unsigned long flags;
++ struct usb_ep *in;
++ u16 cdc_filter;
++
++ spin_lock_irqsave(&dev->lock, flags);
++ if (dev->port_usb) {
++ in = dev->port_usb->in_ep;
++ cdc_filter = dev->port_usb->cdc_filter;
++ } else {
++ in = NULL;
++ cdc_filter = 0;
++ }
++ spin_unlock_irqrestore(&dev->lock, flags);
++
++ if (!in) {
++ dev_kfree_skb_any(skb);
++ return 0;
++ }
++
++ /* apply outgoing CDC or RNDIS filters */
++ if (!is_promisc(cdc_filter)) {
++ u8 *dest = skb->data;
++
++ if (is_multicast_ether_addr(dest)) {
++ u16 type;
++
++ /* ignores USB_CDC_PACKET_TYPE_MULTICAST and host
++ * SET_ETHERNET_MULTICAST_FILTERS requests
++ */
++ if (is_broadcast_ether_addr(dest))
++ type = USB_CDC_PACKET_TYPE_BROADCAST;
++ else
++ type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;
++ if (!(cdc_filter & type)) {
++ dev_kfree_skb_any(skb);
++ return 0;
++ }
++ }
++ /* ignores USB_CDC_PACKET_TYPE_DIRECTED */
++ }
++
++ spin_lock_irqsave(&dev->req_lock, flags);
++ /*
++ * this freelist can be empty if an interrupt triggered disconnect()
++ * and reconfigured the gadget (shutting down this queue) after the
++ * network stack decided to xmit but before we got the spinlock.
++ */
++ if (list_empty(&dev->tx_reqs)) {
++ spin_unlock_irqrestore(&dev->req_lock, flags);
++ return 1;
++ }
++
++ req = container_of(dev->tx_reqs.next, struct usb_request, list);
++ list_del(&req->list);
++
++ /* temporarily stop TX queue when the freelist empties */
++ if (list_empty(&dev->tx_reqs))
++ netif_stop_queue(net);
++ spin_unlock_irqrestore(&dev->req_lock, flags);
++
++ /* no buffer copies needed, unless the network stack did it
++ * or the hardware can't use skb buffers.
++ * or there's not enough space for extra headers we need
++ */
++ if (dev->wrap) {
++ struct sk_buff *skb_new;
++
++ skb_new = dev->wrap(skb);
++ if (!skb_new)
++ goto drop;
++
++ dev_kfree_skb_any(skb);
++ skb = skb_new;
++ length = skb->len;
++ }
++ req->buf = skb->data;
++ req->context = skb;
++ req->complete = tx_complete;
++
++ /* use zlp framing on tx for strict CDC-Ether conformance,
++ * though any robust network rx path ignores extra padding.
++ * and some hardware doesn't like to write zlps.
++ */
++ req->zero = 1;
++ if (!dev->zlp && (length % in->maxpacket) == 0)
++ length++;
++
++ req->length = length;
++
++ /* throttle highspeed IRQ rate back slightly */
++ if (gadget_is_dualspeed(dev->gadget))
++ req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
++ ? ((atomic_read(&dev->tx_qlen) % qmult) != 0)
++ : 0;
++
++ retval = usb_ep_queue(in, req, GFP_ATOMIC);
++ switch (retval) {
++ default:
++ DBG(dev, "tx queue err %d\n", retval);
++ break;
++ case 0:
++ net->trans_start = jiffies;
++ atomic_inc(&dev->tx_qlen);
++ }
++
++ if (retval) {
++drop:
++ dev->net->stats.tx_dropped++;
++ dev_kfree_skb_any(skb);
++ spin_lock_irqsave(&dev->req_lock, flags);
++ if (list_empty(&dev->tx_reqs))
++ netif_start_queue(net);
++ list_add(&req->list, &dev->tx_reqs);
++ spin_unlock_irqrestore(&dev->req_lock, flags);
++ }
++ return 0;
++}
++
++/*-------------------------------------------------------------------------*/
++
++static void eth_start(struct eth_dev *dev, gfp_t gfp_flags)
++{
++ DBG(dev, "%s\n", __func__);
++
++ /* fill the rx queue */
++ rx_fill(dev, gfp_flags);
++
++ /* and open the tx floodgates */
++ atomic_set(&dev->tx_qlen, 0);
++ netif_wake_queue(dev->net);
++}
++
++static int eth_open(struct net_device *net)
++{
++ struct eth_dev *dev = netdev_priv(net);
++ struct gether *link;
++
++ DBG(dev, "%s\n", __func__);
++ if (netif_carrier_ok(dev->net))
++ eth_start(dev, GFP_KERNEL);
++
++ spin_lock_irq(&dev->lock);
++ link = dev->port_usb;
++ if (link && link->open)
++ link->open(link);
++ spin_unlock_irq(&dev->lock);
++
++ return 0;
++}
++
++static int eth_stop(struct net_device *net)
++{
++ struct eth_dev *dev = netdev_priv(net);
++ unsigned long flags;
++
++ VDBG(dev, "%s\n", __func__);
++ netif_stop_queue(net);
++
++ DBG(dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n",
++ dev->net->stats.rx_packets, dev->net->stats.tx_packets,
++ dev->net->stats.rx_errors, dev->net->stats.tx_errors
++ );
++
++ /* ensure there are no more active requests */
++ spin_lock_irqsave(&dev->lock, flags);
++ if (dev->port_usb) {
++ struct gether *link = dev->port_usb;
++
++ if (link->close)
++ link->close(link);
++
++ /* NOTE: we have no abort-queue primitive we could use
++ * to cancel all pending I/O. Instead, we disable then
++ * reenable the endpoints ... this idiom may leave toggle
++ * wrong, but that's a self-correcting error.
++ *
++ * REVISIT: we *COULD* just let the transfers complete at
++ * their own pace; the network stack can handle old packets.
++ * For the moment we leave this here, since it works.
++ */
++ usb_ep_disable(link->in_ep);
++ usb_ep_disable(link->out_ep);
++ if (netif_carrier_ok(net)) {
++ DBG(dev, "host still using in/out endpoints\n");
++ usb_ep_enable(link->in_ep, link->in);
++ usb_ep_enable(link->out_ep, link->out);
++ }
++ }
++ spin_unlock_irqrestore(&dev->lock, flags);
++
++ return 0;
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* initial value, changed by "ifconfig usb0 hw ether xx:xx:xx:xx:xx:xx" */
++static char *dev_addr;
++module_param(dev_addr, charp, S_IRUGO);
++MODULE_PARM_DESC(dev_addr, "Device Ethernet Address");
++
++/* this address is invisible to ifconfig */
++static char *host_addr;
++module_param(host_addr, charp, S_IRUGO);
++MODULE_PARM_DESC(host_addr, "Host Ethernet Address");
++
++
++static u8 __init nibble(unsigned char c)
++{
++ if (isdigit(c))
++ return c - '0';
++ c = toupper(c);
++ if (isxdigit(c))
++ return 10 + c - 'A';
++ return 0;
++}
++
++static int __init get_ether_addr(const char *str, u8 *dev_addr)
++{
++ if (str) {
++ unsigned i;
++
++ for (i = 0; i < 6; i++) {
++ unsigned char num;
++
++ if ((*str == '.') || (*str == ':'))
++ str++;
++ num = nibble(*str++) << 4;
++ num |= (nibble(*str++));
++ dev_addr [i] = num;
++ }
++ if (is_valid_ether_addr(dev_addr))
++ return 0;
++ }
++ random_ether_addr(dev_addr);
++ return 1;
++}
++
++static struct eth_dev *the_dev;
++
++
++/**
++ * gether_setup - initialize one ethernet-over-usb link
++ * @g: gadget to associated with these links
++ * @ethaddr: NULL, or a buffer in which the ethernet address of the
++ * host side of the link is recorded
++ * Context: may sleep
++ *
++ * This sets up the single network link that may be exported by a
++ * gadget driver using this framework. The link layer addresses are
++ * set up using module parameters.
++ *
++ * Returns negative errno, or zero on success
++ */
++int __init gether_setup(struct usb_gadget *g, u8 ethaddr[ETH_ALEN])
++{
++ struct eth_dev *dev;
++ struct net_device *net;
++ int status;
++
++ if (the_dev)
++ return -EBUSY;
++
++ net = alloc_etherdev(sizeof *dev);
++ if (!net)
++ return -ENOMEM;
++
++ dev = netdev_priv(net);
++ spin_lock_init(&dev->lock);
++ spin_lock_init(&dev->req_lock);
++ INIT_WORK(&dev->work, eth_work);
++ INIT_LIST_HEAD(&dev->tx_reqs);
++ INIT_LIST_HEAD(&dev->rx_reqs);
++
++ /* network device setup */
++ dev->net = net;
++ strcpy(net->name, "usb%d");
++
++ if (get_ether_addr(dev_addr, net->dev_addr))
++ dev_warn(&g->dev,
++ "using random %s ethernet address\n", "self");
++ if (get_ether_addr(host_addr, dev->host_mac))
++ dev_warn(&g->dev,
++ "using random %s ethernet address\n", "host");
++
++ if (ethaddr)
++ memcpy(ethaddr, dev->host_mac, ETH_ALEN);
++
++ net->change_mtu = eth_change_mtu;
++ net->hard_start_xmit = eth_start_xmit;
++ net->open = eth_open;
++ net->stop = eth_stop;
++ /* watchdog_timeo, tx_timeout ... */
++ /* set_multicast_list */
++ SET_ETHTOOL_OPS(net, &ops);
++
++ /* two kinds of host-initiated state changes:
++ * - iff DATA transfer is active, carrier is "on"
++ * - tx queueing enabled if open *and* carrier is "on"
++ */
++ netif_stop_queue(net);
++ netif_carrier_off(net);
++
++ dev->gadget = g;
++ SET_NETDEV_DEV(net, &g->dev);
++
++ status = register_netdev(net);
++ if (status < 0) {
++ dev_dbg(&g->dev, "register_netdev failed, %d\n", status);
++ free_netdev(net);
++ } else {
++ DECLARE_MAC_BUF(tmp);
++
++ INFO(dev, "MAC %s\n", print_mac(tmp, net->dev_addr));
++ INFO(dev, "HOST MAC %s\n", print_mac(tmp, dev->host_mac));
++
++ the_dev = dev;
++ }
++
++ return status;
++}
++
++/**
++ * gether_cleanup - remove Ethernet-over-USB device
++ * Context: may sleep
++ *
++ * This is called to free all resources allocated by @gether_setup().
++ */
++void gether_cleanup(void)
++{
++ if (!the_dev)
++ return;
++
++ unregister_netdev(the_dev->net);
++ free_netdev(the_dev->net);
++
++ /* assuming we used keventd, it must quiesce too */
++ flush_scheduled_work();
++
++ the_dev = NULL;
++}
++
++
++/**
++ * gether_connect - notify network layer that USB link is active
++ * @link: the USB link, set up with endpoints, descriptors matching
++ * current device speed, and any framing wrapper(s) set up.
++ * Context: irqs blocked
++ *
++ * This is called to activate endpoints and let the network layer know
++ * the connection is active ("carrier detect"). It may cause the I/O
++ * queues to open and start letting network packets flow, but will in
++ * any case activate the endpoints so that they respond properly to the
++ * USB host.
++ *
++ * Verify net_device pointer returned using IS_ERR(). If it doesn't
++ * indicate some error code (negative errno), ep->driver_data values
++ * have been overwritten.
++ */
++struct net_device *gether_connect(struct gether *link)
++{
++ struct eth_dev *dev = the_dev;
++ int result = 0;
++
++ if (!dev)
++ return ERR_PTR(-EINVAL);
++
++ link->in_ep->driver_data = dev;
++ result = usb_ep_enable(link->in_ep, link->in);
++ if (result != 0) {
++ DBG(dev, "enable %s --> %d\n",
++ link->in_ep->name, result);
++ goto fail0;
++ }
++
++ link->out_ep->driver_data = dev;
++ result = usb_ep_enable(link->out_ep, link->out);
++ if (result != 0) {
++ DBG(dev, "enable %s --> %d\n",
++ link->out_ep->name, result);
++ goto fail1;
++ }
++
++ if (result == 0)
++ result = alloc_requests(dev, link, qlen(dev->gadget));
++
++ if (result == 0) {
++ dev->zlp = link->is_zlp_ok;
++ DBG(dev, "qlen %d\n", qlen(dev->gadget));
++
++ dev->header_len = link->header_len;
++ dev->unwrap = link->unwrap;
++ dev->wrap = link->wrap;
++
++ spin_lock(&dev->lock);
++ dev->port_usb = link;
++ link->ioport = dev;
++ spin_unlock(&dev->lock);
++
++ netif_carrier_on(dev->net);
++ if (netif_running(dev->net))
++ eth_start(dev, GFP_ATOMIC);
++
++ /* on error, disable any endpoints */
++ } else {
++ (void) usb_ep_disable(link->out_ep);
++fail1:
++ (void) usb_ep_disable(link->in_ep);
++ }
++fail0:
++ /* caller is responsible for cleanup on error */
++ if (result < 0)
++ return ERR_PTR(result);
++ return dev->net;
++}
++
++/**
++ * gether_disconnect - notify network layer that USB link is inactive
++ * @link: the USB link, on which gether_connect() was called
++ * Context: irqs blocked
++ *
++ * This is called to deactivate endpoints and let the network layer know
++ * the connection went inactive ("no carrier").
++ *
++ * On return, the state is as if gether_connect() had never been called.
++ * The endpoints are inactive, and accordingly without active USB I/O.
++ * Pointers to endpoint descriptors and endpoint private data are nulled.
++ */
++void gether_disconnect(struct gether *link)
++{
++ struct eth_dev *dev = link->ioport;
++ struct usb_request *req;
++
++ WARN_ON(!dev);
++ if (!dev)
++ return;
++
++ DBG(dev, "%s\n", __func__);
++
++ netif_stop_queue(dev->net);
++ netif_carrier_off(dev->net);
++
++ /* disable endpoints, forcing (synchronous) completion
++ * of all pending i/o. then free the request objects
++ * and forget about the endpoints.
++ */
++ usb_ep_disable(link->in_ep);
++ spin_lock(&dev->req_lock);
++ while (!list_empty(&dev->tx_reqs)) {
++ req = container_of(dev->tx_reqs.next,
++ struct usb_request, list);
++ list_del(&req->list);
++
++ spin_unlock(&dev->req_lock);
++ usb_ep_free_request(link->in_ep, req);
++ spin_lock(&dev->req_lock);
++ }
++ spin_unlock(&dev->req_lock);
++ link->in_ep->driver_data = NULL;
++ link->in = NULL;
++
++ usb_ep_disable(link->out_ep);
++ spin_lock(&dev->req_lock);
++ while (!list_empty(&dev->rx_reqs)) {
++ req = container_of(dev->rx_reqs.next,
++ struct usb_request, list);
++ list_del(&req->list);
++
++ spin_unlock(&dev->req_lock);
++ usb_ep_free_request(link->out_ep, req);
++ spin_lock(&dev->req_lock);
++ }
++ spin_unlock(&dev->req_lock);
++ link->out_ep->driver_data = NULL;
++ link->out = NULL;
++
++ /* finish forgetting about this USB link episode */
++ dev->header_len = 0;
++ dev->unwrap = NULL;
++ dev->wrap = NULL;
++
++ spin_lock(&dev->lock);
++ dev->port_usb = NULL;
++ link->ioport = NULL;
++ spin_unlock(&dev->lock);
++}
+diff --git a/drivers/usb/gadget/u_ether.h b/drivers/usb/gadget/u_ether.h
+new file mode 100644
+index 0000000..0d1f7ae
+--- /dev/null
++++ b/drivers/usb/gadget/u_ether.h
+@@ -0,0 +1,127 @@
++/*
++ * u_ether.h -- interface to USB gadget "ethernet link" utilities
++ *
++ * Copyright (C) 2003-2005,2008 David Brownell
++ * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
++ * Copyright (C) 2008 Nokia Corporation
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
++ */
++
++#ifndef __U_ETHER_H
++#define __U_ETHER_H
++
++#include <linux/err.h>
++#include <linux/if_ether.h>
++#include <linux/usb/composite.h>
++#include <linux/usb/cdc.h>
++
++#include "gadget_chips.h"
++
++
++/*
++ * This represents the USB side of an "ethernet" link, managed by a USB
++ * function which provides control and (maybe) framing. Two functions
++ * in different configurations could share the same ethernet link/netdev,
++ * using different host interaction models.
++ *
++ * There is a current limitation that only one instance of this link may
++ * be present in any given configuration. When that's a problem, network
++ * layer facilities can be used to package multiple logical links on this
++ * single "physical" one.
++ */
++struct gether {
++ struct usb_function func;
++
++ /* updated by gether_{connect,disconnect} */
++ struct eth_dev *ioport;
++
++ /* endpoints handle full and/or high speeds */
++ struct usb_ep *in_ep;
++ struct usb_ep *out_ep;
++
++ /* descriptors match device speed at gether_connect() time */
++ struct usb_endpoint_descriptor *in;
++ struct usb_endpoint_descriptor *out;
++
++ bool is_zlp_ok;
++
++ u16 cdc_filter;
++
++ /* hooks for added framing, as needed for RNDIS and EEM.
++ * we currently don't support multiple frames per SKB.
++ */
++ u32 header_len;
++ struct sk_buff *(*wrap)(struct sk_buff *skb);
++ int (*unwrap)(struct sk_buff *skb);
++
++ /* called on network open/close */
++ void (*open)(struct gether *);
++ void (*close)(struct gether *);
++};
++
++#define DEFAULT_FILTER (USB_CDC_PACKET_TYPE_BROADCAST \
++ |USB_CDC_PACKET_TYPE_ALL_MULTICAST \
++ |USB_CDC_PACKET_TYPE_PROMISCUOUS \
++ |USB_CDC_PACKET_TYPE_DIRECTED)
++
++
++/* netdev setup/teardown as directed by the gadget driver */
++int gether_setup(struct usb_gadget *g, u8 ethaddr[ETH_ALEN]);
++void gether_cleanup(void);
++
++/* connect/disconnect is handled by individual functions */
++struct net_device *gether_connect(struct gether *);
++void gether_disconnect(struct gether *);
++
++/* Some controllers can't support CDC Ethernet (ECM) ... */
++static inline bool can_support_ecm(struct usb_gadget *gadget)
++{
++ if (!gadget_supports_altsettings(gadget))
++ return false;
++
++ /* SA1100 can do ECM, *without* status endpoint ... but we'll
++ * only use it in non-ECM mode for backwards compatibility
++ * (and since we currently require a status endpoint)
++ */
++ if (gadget_is_sa1100(gadget))
++ return false;
++
++ /* Everything else is *presumably* fine ... but this is a bit
++ * chancy, so be **CERTAIN** there are no hardware issues with
++ * your controller. Add it above if it can't handle CDC.
++ */
++ return true;
++}
++
++/* each configuration may bind one instance of an ethernet link */
++int geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
++int ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
++
++#ifdef CONFIG_USB_ETH_RNDIS
++
++int rndis_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
++
++#else
++
++static inline int
++rndis_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
++{
++ return 0;
++}
++
++#endif
++
++#endif /* __U_ETHER_H */
+diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
+new file mode 100644
+index 0000000..53d5928
+--- /dev/null
++++ b/drivers/usb/gadget/u_serial.c
+@@ -0,0 +1,1330 @@
++/*
++ * u_serial.c - utilities for USB gadget "serial port"/TTY support
++ *
++ * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
++ * Copyright (C) 2008 David Brownell
++ * Copyright (C) 2008 by Nokia Corporation
++ *
++ * This code also borrows from usbserial.c, which is
++ * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
++ * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
++ * Copyright (C) 2000 Al Borchers (alborchers@steinerpoint.com)
++ *
++ * This software is distributed under the terms of the GNU General
++ * Public License ("GPL") as published by the Free Software Foundation,
++ * either version 2 of that License or (at your option) any later version.
++ */
++
++/* #define VERBOSE_DEBUG */
++
++#include <linux/kernel.h>
++#include <linux/interrupt.h>
++#include <linux/device.h>
++#include <linux/delay.h>
++#include <linux/tty.h>
++#include <linux/tty_flip.h>
++
++#include "u_serial.h"
++
++
++/*
++ * This component encapsulates the TTY layer glue needed to provide basic
++ * "serial port" functionality through the USB gadget stack. Each such
++ * port is exposed through a /dev/ttyGS* node.
++ *
++ * After initialization (gserial_setup), these TTY port devices stay
++ * available until they are removed (gserial_cleanup). Each one may be
++ * connected to a USB function (gserial_connect), or disconnected (with
++ * gserial_disconnect) when the USB host issues a config change event.
++ * Data can only flow when the port is connected to the host.
++ *
++ * A given TTY port can be made available in multiple configurations.
++ * For example, each one might expose a ttyGS0 node which provides a
++ * login application. In one case that might use CDC ACM interface 0,
++ * while another configuration might use interface 3 for that. The
++ * work to handle that (including descriptor management) is not part
++ * of this component.
++ *
++ * Configurations may expose more than one TTY port. For example, if
++ * ttyGS0 provides login service, then ttyGS1 might provide dialer access
++ * for a telephone or fax link. And ttyGS2 might be something that just
++ * needs a simple byte stream interface for some messaging protocol that
++ * is managed in userspace ... OBEX, PTP, and MTP have been mentioned.
++ */
++
++#define PREFIX "ttyGS"
++
++/*
++ * gserial is the lifecycle interface, used by USB functions
++ * gs_port is the I/O nexus, used by the tty driver
++ * tty_struct links to the tty/filesystem framework
++ *
++ * gserial <---> gs_port ... links will be null when the USB link is
++ * inactive; managed by gserial_{connect,disconnect}(). each gserial
++ * instance can wrap its own USB control protocol.
++ * gserial->ioport == usb_ep->driver_data ... gs_port
++ * gs_port->port_usb ... gserial
++ *
++ * gs_port <---> tty_struct ... links will be null when the TTY file
++ * isn't opened; managed by gs_open()/gs_close()
++ * gserial->port_tty ... tty_struct
++ * tty_struct->driver_data ... gserial
++ */
++
++/* RX and TX queues can buffer QUEUE_SIZE packets before they hit the
++ * next layer of buffering. For TX that's a circular buffer; for RX
++ * consider it a NOP. A third layer is provided by the TTY code.
++ */
++#define QUEUE_SIZE 16
++#define WRITE_BUF_SIZE 8192 /* TX only */
++
++/* circular buffer */
++struct gs_buf {
++ unsigned buf_size;
++ char *buf_buf;
++ char *buf_get;
++ char *buf_put;
++};
++
++/*
++ * The port structure holds info for each port, one for each minor number
++ * (and thus for each /dev/ node).
++ */
++struct gs_port {
++ spinlock_t port_lock; /* guard port_* access */
++
++ struct gserial *port_usb;
++ struct tty_struct *port_tty;
++
++ unsigned open_count;
++ bool openclose; /* open/close in progress */
++ u8 port_num;
++
++ wait_queue_head_t close_wait; /* wait for last close */
++
++ struct list_head read_pool;
++ struct list_head read_queue;
++ unsigned n_read;
++ struct tasklet_struct push;
++
++ struct list_head write_pool;
++ struct gs_buf port_write_buf;
++ wait_queue_head_t drain_wait; /* wait while writes drain */
++
++ /* REVISIT this state ... */
++ struct usb_cdc_line_coding port_line_coding; /* 8-N-1 etc */
++};
++
++/* increase N_PORTS if you need more */
++#define N_PORTS 4
++static struct portmaster {
++ struct mutex lock; /* protect open/close */
++ struct gs_port *port;
++} ports[N_PORTS];
++static unsigned n_ports;
++
++#define GS_CLOSE_TIMEOUT 15 /* seconds */
++
++
++
++#ifdef VERBOSE_DEBUG
++#define pr_vdebug(fmt, arg...) \
++ pr_debug(fmt, ##arg)
++#else
++#define pr_vdebug(fmt, arg...) \
++ ({ if (0) pr_debug(fmt, ##arg); })
++#endif
++
++/*-------------------------------------------------------------------------*/
++
++/* Circular Buffer */
++
++/*
++ * gs_buf_alloc
++ *
++ * Allocate a circular buffer and all associated memory.
++ */
++static int gs_buf_alloc(struct gs_buf *gb, unsigned size)
++{
++ gb->buf_buf = kmalloc(size, GFP_KERNEL);
++ if (gb->buf_buf == NULL)
++ return -ENOMEM;
++
++ gb->buf_size = size;
++ gb->buf_put = gb->buf_buf;
++ gb->buf_get = gb->buf_buf;
++
++ return 0;
++}
++
++/*
++ * gs_buf_free
++ *
++ * Free the buffer and all associated memory.
++ */
++static void gs_buf_free(struct gs_buf *gb)
++{
++ kfree(gb->buf_buf);
++ gb->buf_buf = NULL;
++}
++
++/*
++ * gs_buf_clear
++ *
++ * Clear out all data in the circular buffer.
++ */
++static void gs_buf_clear(struct gs_buf *gb)
++{
++ gb->buf_get = gb->buf_put;
++ /* equivalent to a get of all data available */
++}
++
++/*
++ * gs_buf_data_avail
++ *
++ * Return the number of bytes of data written into the circular
++ * buffer.
++ */
++static unsigned gs_buf_data_avail(struct gs_buf *gb)
++{
++ return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size;
++}
++
++/*
++ * gs_buf_space_avail
++ *
++ * Return the number of bytes of space available in the circular
++ * buffer.
++ */
++static unsigned gs_buf_space_avail(struct gs_buf *gb)
++{
++ return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size;
++}
++
++/*
++ * gs_buf_put
++ *
++ * Copy data data from a user buffer and put it into the circular buffer.
++ * Restrict to the amount of space available.
++ *
++ * Return the number of bytes copied.
++ */
++static unsigned
++gs_buf_put(struct gs_buf *gb, const char *buf, unsigned count)
++{
++ unsigned len;
++
++ len = gs_buf_space_avail(gb);
++ if (count > len)
++ count = len;
++
++ if (count == 0)
++ return 0;
++
++ len = gb->buf_buf + gb->buf_size - gb->buf_put;
++ if (count > len) {
++ memcpy(gb->buf_put, buf, len);
++ memcpy(gb->buf_buf, buf+len, count - len);
++ gb->buf_put = gb->buf_buf + count - len;
++ } else {
++ memcpy(gb->buf_put, buf, count);
++ if (count < len)
++ gb->buf_put += count;
++ else /* count == len */
++ gb->buf_put = gb->buf_buf;
++ }
++
++ return count;
++}
++
++/*
++ * gs_buf_get
++ *
++ * Get data from the circular buffer and copy to the given buffer.
++ * Restrict to the amount of data available.
++ *
++ * Return the number of bytes copied.
++ */
++static unsigned
++gs_buf_get(struct gs_buf *gb, char *buf, unsigned count)
++{
++ unsigned len;
++
++ len = gs_buf_data_avail(gb);
++ if (count > len)
++ count = len;
++
++ if (count == 0)
++ return 0;
++
++ len = gb->buf_buf + gb->buf_size - gb->buf_get;
++ if (count > len) {
++ memcpy(buf, gb->buf_get, len);
++ memcpy(buf+len, gb->buf_buf, count - len);
++ gb->buf_get = gb->buf_buf + count - len;
++ } else {
++ memcpy(buf, gb->buf_get, count);
++ if (count < len)
++ gb->buf_get += count;
++ else /* count == len */
++ gb->buf_get = gb->buf_buf;
++ }
++
++ return count;
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* I/O glue between TTY (upper) and USB function (lower) driver layers */
++
++/*
++ * gs_alloc_req
++ *
++ * Allocate a usb_request and its buffer. Returns a pointer to the
++ * usb_request or NULL if there is an error.
++ */
++struct usb_request *
++gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
++{
++ struct usb_request *req;
++
++ req = usb_ep_alloc_request(ep, kmalloc_flags);
++
++ if (req != NULL) {
++ req->length = len;
++ req->buf = kmalloc(len, kmalloc_flags);
++ if (req->buf == NULL) {
++ usb_ep_free_request(ep, req);
++ return NULL;
++ }
++ }
++
++ return req;
++}
++
++/*
++ * gs_free_req
++ *
++ * Free a usb_request and its buffer.
++ */
++void gs_free_req(struct usb_ep *ep, struct usb_request *req)
++{
++ kfree(req->buf);
++ usb_ep_free_request(ep, req);
++}
++
++/*
++ * gs_send_packet
++ *
++ * If there is data to send, a packet is built in the given
++ * buffer and the size is returned. If there is no data to
++ * send, 0 is returned.
++ *
++ * Called with port_lock held.
++ */
++static unsigned
++gs_send_packet(struct gs_port *port, char *packet, unsigned size)
++{
++ unsigned len;
++
++ len = gs_buf_data_avail(&port->port_write_buf);
++ if (len < size)
++ size = len;
++ if (size != 0)
++ size = gs_buf_get(&port->port_write_buf, packet, size);
++ return size;
++}
++
++/*
++ * gs_start_tx
++ *
++ * This function finds available write requests, calls
++ * gs_send_packet to fill these packets with data, and
++ * continues until either there are no more write requests
++ * available or no more data to send. This function is
++ * run whenever data arrives or write requests are available.
++ *
++ * Context: caller owns port_lock; port_usb is non-null.
++ */
++static int gs_start_tx(struct gs_port *port)
++/*
++__releases(&port->port_lock)
++__acquires(&port->port_lock)
++*/
++{
++ struct list_head *pool = &port->write_pool;
++ struct usb_ep *in = port->port_usb->in;
++ int status = 0;
++ bool do_tty_wake = false;
++
++ while (!list_empty(pool)) {
++ struct usb_request *req;
++ int len;
++
++ req = list_entry(pool->next, struct usb_request, list);
++ len = gs_send_packet(port, req->buf, in->maxpacket);
++ if (len == 0) {
++ wake_up_interruptible(&port->drain_wait);
++ break;
++ }
++ do_tty_wake = true;
++
++ req->length = len;
++ list_del(&req->list);
++
++ pr_vdebug(PREFIX "%d: tx len=%d, 0x%02x 0x%02x 0x%02x ...\n",
++ port->port_num, len, *((u8 *)req->buf),
++ *((u8 *)req->buf+1), *((u8 *)req->buf+2));
++
++ /* Drop lock while we call out of driver; completions
++ * could be issued while we do so. Disconnection may
++ * happen too; maybe immediately before we queue this!
++ *
++ * NOTE that we may keep sending data for a while after
++ * the TTY closed (dev->ioport->port_tty is NULL).
++ */
++ spin_unlock(&port->port_lock);
++ status = usb_ep_queue(in, req, GFP_ATOMIC);
++ spin_lock(&port->port_lock);
++
++ if (status) {
++ pr_debug("%s: %s %s err %d\n",
++ __func__, "queue", in->name, status);
++ list_add(&req->list, pool);
++ break;
++ }
++
++ /* abort immediately after disconnect */
++ if (!port->port_usb)
++ break;
++ }
++
++ if (do_tty_wake && port->port_tty)
++ tty_wakeup(port->port_tty);
++ return status;
++}
++
++/*
++ * Context: caller owns port_lock, and port_usb is set
++ */
++static unsigned gs_start_rx(struct gs_port *port)
++/*
++__releases(&port->port_lock)
++__acquires(&port->port_lock)
++*/
++{
++ struct list_head *pool = &port->read_pool;
++ struct usb_ep *out = port->port_usb->out;
++ unsigned started = 0;
++
++ while (!list_empty(pool)) {
++ struct usb_request *req;
++ int status;
++ struct tty_struct *tty;
++
++ /* no more rx if closed */
++ tty = port->port_tty;
++ if (!tty)
++ break;
++
++ req = list_entry(pool->next, struct usb_request, list);
++ list_del(&req->list);
++ req->length = out->maxpacket;
++
++ /* drop lock while we call out; the controller driver
++ * may need to call us back (e.g. for disconnect)
++ */
++ spin_unlock(&port->port_lock);
++ status = usb_ep_queue(out, req, GFP_ATOMIC);
++ spin_lock(&port->port_lock);
++
++ if (status) {
++ pr_debug("%s: %s %s err %d\n",
++ __func__, "queue", out->name, status);
++ list_add(&req->list, pool);
++ break;
++ }
++ started++;
++
++ /* abort immediately after disconnect */
++ if (!port->port_usb)
++ break;
++ }
++ return started;
++}
++
++/*
++ * RX tasklet takes data out of the RX queue and hands it up to the TTY
++ * layer until it refuses to take any more data (or is throttled back).
++ * Then it issues reads for any further data.
++ *
++ * If the RX queue becomes full enough that no usb_request is queued,
++ * the OUT endpoint may begin NAKing as soon as its FIFO fills up.
++ * So QUEUE_SIZE packets plus however many the FIFO holds (usually two)
++ * can be buffered before the TTY layer's buffers (currently 64 KB).
++ */
++static void gs_rx_push(unsigned long _port)
++{
++ struct gs_port *port = (void *)_port;
++ struct tty_struct *tty;
++ struct list_head *queue = &port->read_queue;
++ bool disconnect = false;
++ bool do_push = false;
++
++ /* hand any queued data to the tty */
++ spin_lock_irq(&port->port_lock);
++ tty = port->port_tty;
++ while (!list_empty(queue)) {
++ struct usb_request *req;
++
++ req = list_first_entry(queue, struct usb_request, list);
++
++ /* discard data if tty was closed */
++ if (!tty)
++ goto recycle;
++
++ /* leave data queued if tty was rx throttled */
++ if (test_bit(TTY_THROTTLED, &tty->flags))
++ break;
++
++ switch (req->status) {
++ case -ESHUTDOWN:
++ disconnect = true;
++ pr_vdebug(PREFIX "%d: shutdown\n", port->port_num);
++ break;
++
++ default:
++ /* presumably a transient fault */
++ pr_warning(PREFIX "%d: unexpected RX status %d\n",
++ port->port_num, req->status);
++ /* FALLTHROUGH */
++ case 0:
++ /* normal completion */
++ break;
++ }
++
++ /* push data to (open) tty */
++ if (req->actual) {
++ char *packet = req->buf;
++ unsigned size = req->actual;
++ unsigned n;
++ int count;
++
++ /* we may have pushed part of this packet already... */
++ n = port->n_read;
++ if (n) {
++ packet += n;
++ size -= n;
++ }
++
++ count = tty_insert_flip_string(tty, packet, size);
++ if (count)
++ do_push = true;
++ if (count != size) {
++ /* stop pushing; TTY layer can't handle more */
++ port->n_read += count;
++ pr_vdebug(PREFIX "%d: rx block %d/%d\n",
++ port->port_num,
++ count, req->actual);
++ break;
++ }
++ port->n_read = 0;
++ }
++recycle:
++ list_move(&req->list, &port->read_pool);
++ }
++
++ /* Push from tty to ldisc; this is immediate with low_latency, and
++ * may trigger callbacks to this driver ... so drop the spinlock.
++ */
++ if (tty && do_push) {
++ spin_unlock_irq(&port->port_lock);
++ tty_flip_buffer_push(tty);
++ wake_up_interruptible(&tty->read_wait);
++ spin_lock_irq(&port->port_lock);
++
++ /* tty may have been closed */
++ tty = port->port_tty;
++ }
++
++
++ /* We want our data queue to become empty ASAP, keeping data
++ * in the tty and ldisc (not here). If we couldn't push any
++ * this time around, there may be trouble unless there's an
++ * implicit tty_unthrottle() call on its way...
++ *
++ * REVISIT we should probably add a timer to keep the tasklet
++ * from starving ... but it's not clear that case ever happens.
++ */
++ if (!list_empty(queue) && tty) {
++ if (!test_bit(TTY_THROTTLED, &tty->flags)) {
++ if (do_push)
++ tasklet_schedule(&port->push);
++ else
++ pr_warning(PREFIX "%d: RX not scheduled?\n",
++ port->port_num);
++ }
++ }
++
++ /* If we're still connected, refill the USB RX queue. */
++ if (!disconnect && port->port_usb)
++ gs_start_rx(port);
++
++ spin_unlock_irq(&port->port_lock);
++}
++
++static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
++{
++ struct gs_port *port = ep->driver_data;
++
++ /* Queue all received data until the tty layer is ready for it. */
++ spin_lock(&port->port_lock);
++ list_add_tail(&req->list, &port->read_queue);
++ tasklet_schedule(&port->push);
++ spin_unlock(&port->port_lock);
++}
++
++static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
++{
++ struct gs_port *port = ep->driver_data;
++
++ spin_lock(&port->port_lock);
++ list_add(&req->list, &port->write_pool);
++
++ switch (req->status) {
++ default:
++ /* presumably a transient fault */
++ pr_warning("%s: unexpected %s status %d\n",
++ __func__, ep->name, req->status);
++ /* FALL THROUGH */
++ case 0:
++ /* normal completion */
++ gs_start_tx(port);
++ break;
++
++ case -ESHUTDOWN:
++ /* disconnect */
++ pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
++ break;
++ }
++
++ spin_unlock(&port->port_lock);
++}
++
++static void gs_free_requests(struct usb_ep *ep, struct list_head *head)
++{
++ struct usb_request *req;
++
++ while (!list_empty(head)) {
++ req = list_entry(head->next, struct usb_request, list);
++ list_del(&req->list);
++ gs_free_req(ep, req);
++ }
++}
++
++static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head,
++ void (*fn)(struct usb_ep *, struct usb_request *))
++{
++ int i;
++ struct usb_request *req;
++
++ /* Pre-allocate up to QUEUE_SIZE transfers, but if we can't
++ * do quite that many this time, don't fail ... we just won't
++ * be as speedy as we might otherwise be.
++ */
++ for (i = 0; i < QUEUE_SIZE; i++) {
++ req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
++ if (!req)
++ return list_empty(head) ? -ENOMEM : 0;
++ req->complete = fn;
++ list_add_tail(&req->list, head);
++ }
++ return 0;
++}
++
++/**
++ * gs_start_io - start USB I/O streams
++ * @dev: encapsulates endpoints to use
++ * Context: holding port_lock; port_tty and port_usb are non-null
++ *
++ * We only start I/O when something is connected to both sides of
++ * this port. If nothing is listening on the host side, we may
++ * be pointlessly filling up our TX buffers and FIFO.
++ */
++static int gs_start_io(struct gs_port *port)
++{
++ struct list_head *head = &port->read_pool;
++ struct usb_ep *ep = port->port_usb->out;
++ int status;
++ unsigned started;
++
++ /* Allocate RX and TX I/O buffers. We can't easily do this much
++ * earlier (with GFP_KERNEL) because the requests are coupled to
++ * endpoints, as are the packet sizes we'll be using. Different
++ * configurations may use different endpoints with a given port;
++ * and high speed vs full speed changes packet sizes too.
++ */
++ status = gs_alloc_requests(ep, head, gs_read_complete);
++ if (status)
++ return status;
++
++ status = gs_alloc_requests(port->port_usb->in, &port->write_pool,
++ gs_write_complete);
++ if (status) {
++ gs_free_requests(ep, head);
++ return status;
++ }
++
++ /* queue read requests */
++ port->n_read = 0;
++ started = gs_start_rx(port);
++
++ /* unblock any pending writes into our circular buffer */
++ if (started) {
++ tty_wakeup(port->port_tty);
++ } else {
++ gs_free_requests(ep, head);
++ gs_free_requests(port->port_usb->in, &port->write_pool);
++ status = -EIO;
++ }
++
++ return status;
++}
++
++/*-------------------------------------------------------------------------*/
++
++/* TTY Driver */
++
++/*
++ * gs_open sets up the link between a gs_port and its associated TTY.
++ * That link is broken *only* by TTY close(), and all driver methods
++ * know that.
++ */
++static int gs_open(struct tty_struct *tty, struct file *file)
++{
++ int port_num = tty->index;
++ struct gs_port *port;
++ int status;
++
++ if (port_num < 0 || port_num >= n_ports)
++ return -ENXIO;
++
++ do {
++ mutex_lock(&ports[port_num].lock);
++ port = ports[port_num].port;
++ if (!port)
++ status = -ENODEV;
++ else {
++ spin_lock_irq(&port->port_lock);
++
++ /* already open? Great. */
++ if (port->open_count) {
++ status = 0;
++ port->open_count++;
++
++ /* currently opening/closing? wait ... */
++ } else if (port->openclose) {
++ status = -EBUSY;
++
++ /* ... else we do the work */
++ } else {
++ status = -EAGAIN;
++ port->openclose = true;
++ }
++ spin_unlock_irq(&port->port_lock);
++ }
++ mutex_unlock(&ports[port_num].lock);
++
++ switch (status) {
++ default:
++ /* fully handled */
++ return status;
++ case -EAGAIN:
++ /* must do the work */
++ break;
++ case -EBUSY:
++ /* wait for EAGAIN task to finish */
++ msleep(1);
++ /* REVISIT could have a waitchannel here, if
++ * concurrent open performance is important
++ */
++ break;
++ }
++ } while (status != -EAGAIN);
++
++ /* Do the "real open" */
++ spin_lock_irq(&port->port_lock);
++
++ /* allocate circular buffer on first open */
++ if (port->port_write_buf.buf_buf == NULL) {
++
++ spin_unlock_irq(&port->port_lock);
++ status = gs_buf_alloc(&port->port_write_buf, WRITE_BUF_SIZE);
++ spin_lock_irq(&port->port_lock);
++
++ if (status) {
++ pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n",
++ port->port_num, tty, file);
++ port->openclose = false;
++ goto exit_unlock_port;
++ }
++ }
++
++ /* REVISIT if REMOVED (ports[].port NULL), abort the open
++ * to let rmmod work faster (but this way isn't wrong).
++ */
++
++ /* REVISIT maybe wait for "carrier detect" */
++
++ tty->driver_data = port;
++ port->port_tty = tty;
++
++ port->open_count = 1;
++ port->openclose = false;
++
++ /* low_latency means ldiscs work in tasklet context, without
++ * needing a workqueue schedule ... easier to keep up.
++ */
++ tty->low_latency = 1;
++
++ /* if connected, start the I/O stream */
++ if (port->port_usb) {
++ struct gserial *gser = port->port_usb;
++
++ pr_debug("gs_open: start ttyGS%d\n", port->port_num);
++ gs_start_io(port);
++
++ if (gser->connect)
++ gser->connect(gser);
++ }
++
++ pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file);
++
++ status = 0;
++
++exit_unlock_port:
++ spin_unlock_irq(&port->port_lock);
++ return status;
++}
++
++static int gs_writes_finished(struct gs_port *p)
++{
++ int cond;
++
++ /* return true on disconnect or empty buffer */
++ spin_lock_irq(&p->port_lock);
++ cond = (p->port_usb == NULL) || !gs_buf_data_avail(&p->port_write_buf);
++ spin_unlock_irq(&p->port_lock);
++
++ return cond;
++}
++
++static void gs_close(struct tty_struct *tty, struct file *file)
++{
++ struct gs_port *port = tty->driver_data;
++ struct gserial *gser;
++
++ spin_lock_irq(&port->port_lock);
++
++ if (port->open_count != 1) {
++ if (port->open_count == 0)
++ WARN_ON(1);
++ else
++ --port->open_count;
++ goto exit;
++ }
++
++ pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file);
++
++ /* mark port as closing but in use; we can drop port lock
++ * and sleep if necessary
++ */
++ port->openclose = true;
++ port->open_count = 0;
++
++ gser = port->port_usb;
++ if (gser && gser->disconnect)
++ gser->disconnect(gser);
++
++ /* wait for circular write buffer to drain, disconnect, or at
++ * most GS_CLOSE_TIMEOUT seconds; then discard the rest
++ */
++ if (gs_buf_data_avail(&port->port_write_buf) > 0 && gser) {
++ spin_unlock_irq(&port->port_lock);
++ wait_event_interruptible_timeout(port->drain_wait,
++ gs_writes_finished(port),
++ GS_CLOSE_TIMEOUT * HZ);
++ spin_lock_irq(&port->port_lock);
++ gser = port->port_usb;
++ }
++
++ /* Iff we're disconnected, there can be no I/O in flight so it's
++ * ok to free the circular buffer; else just scrub it. And don't
++ * let the push tasklet fire again until we're re-opened.
++ */
++ if (gser == NULL)
++ gs_buf_free(&port->port_write_buf);
++ else
++ gs_buf_clear(&port->port_write_buf);
++
++ tty->driver_data = NULL;
++ port->port_tty = NULL;
++
++ port->openclose = false;
++
++ pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
++ port->port_num, tty, file);
++
++ wake_up_interruptible(&port->close_wait);
++exit:
++ spin_unlock_irq(&port->port_lock);
++}
++
++static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
++{
++ struct gs_port *port = tty->driver_data;
++ unsigned long flags;
++ int status;
++
++ pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
++ port->port_num, tty, count);
++
++ spin_lock_irqsave(&port->port_lock, flags);
++ if (count)
++ count = gs_buf_put(&port->port_write_buf, buf, count);
++ /* treat count == 0 as flush_chars() */
++ if (port->port_usb)
++ status = gs_start_tx(port);
++ spin_unlock_irqrestore(&port->port_lock, flags);
++
++ return count;
++}
++
++static int gs_put_char(struct tty_struct *tty, unsigned char ch)
++{
++ struct gs_port *port = tty->driver_data;
++ unsigned long flags;
++ int status;
++
++ pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %p\n",
++ port->port_num, tty, ch, __builtin_return_address(0));
++
++ spin_lock_irqsave(&port->port_lock, flags);
++ status = gs_buf_put(&port->port_write_buf, &ch, 1);
++ spin_unlock_irqrestore(&port->port_lock, flags);
++
++ return status;
++}
++
++static void gs_flush_chars(struct tty_struct *tty)
++{
++ struct gs_port *port = tty->driver_data;
++ unsigned long flags;
++
++ pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
++
++ spin_lock_irqsave(&port->port_lock, flags);
++ if (port->port_usb)
++ gs_start_tx(port);
++ spin_unlock_irqrestore(&port->port_lock, flags);
++}
++
++static int gs_write_room(struct tty_struct *tty)
++{
++ struct gs_port *port = tty->driver_data;
++ unsigned long flags;
++ int room = 0;
++
++ spin_lock_irqsave(&port->port_lock, flags);
++ if (port->port_usb)
++ room = gs_buf_space_avail(&port->port_write_buf);
++ spin_unlock_irqrestore(&port->port_lock, flags);
++
++ pr_vdebug("gs_write_room: (%d,%p) room=%d\n",
++ port->port_num, tty, room);
++
++ return room;
++}
++
++static int gs_chars_in_buffer(struct tty_struct *tty)
++{
++ struct gs_port *port = tty->driver_data;
++ unsigned long flags;
++ int chars = 0;
++
++ spin_lock_irqsave(&port->port_lock, flags);
++ chars = gs_buf_data_avail(&port->port_write_buf);
++ spin_unlock_irqrestore(&port->port_lock, flags);
++
++ pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
++ port->port_num, tty, chars);
++
++ return chars;
++}
++
++/* undo side effects of setting TTY_THROTTLED */
++static void gs_unthrottle(struct tty_struct *tty)
++{
++ struct gs_port *port = tty->driver_data;
++ unsigned long flags;
++
++ spin_lock_irqsave(&port->port_lock, flags);
++ if (port->port_usb) {
++ /* Kickstart read queue processing. We don't do xon/xoff,
++ * rts/cts, or other handshaking with the host, but if the
++ * read queue backs up enough we'll be NAKing OUT packets.
++ */
++ tasklet_schedule(&port->push);
++ pr_vdebug(PREFIX "%d: unthrottle\n", port->port_num);
++ }
++ spin_unlock_irqrestore(&port->port_lock, flags);
++}
++
++static int gs_break_ctl(struct tty_struct *tty, int duration)
++{
++ struct gs_port *port = tty->driver_data;
++ int status = 0;
++ struct gserial *gser;
++
++ pr_vdebug("gs_break_ctl: ttyGS%d, send break (%d) \n",
++ port->port_num, duration);
++
++ spin_lock_irq(&port->port_lock);
++ gser = port->port_usb;
++ if (gser && gser->send_break)
++ status = gser->send_break(gser, duration);
++ spin_unlock_irq(&port->port_lock);
++
++ return status;
++}
++
++static const struct tty_operations gs_tty_ops = {
++ .open = gs_open,
++ .close = gs_close,
++ .write = gs_write,
++ .put_char = gs_put_char,
++ .flush_chars = gs_flush_chars,
++ .write_room = gs_write_room,
++ .chars_in_buffer = gs_chars_in_buffer,
++ .unthrottle = gs_unthrottle,
++ .break_ctl = gs_break_ctl,
++};
++
++/*-------------------------------------------------------------------------*/
++
++static struct tty_driver *gs_tty_driver;
++
++static int __init
++gs_port_alloc(unsigned port_num, struct usb_cdc_line_coding *coding)
++{
++ struct gs_port *port;
++
++ port = kzalloc(sizeof(struct gs_port), GFP_KERNEL);
++ if (port == NULL)
++ return -ENOMEM;
++
++ spin_lock_init(&port->port_lock);
++ init_waitqueue_head(&port->close_wait);
++ init_waitqueue_head(&port->drain_wait);
++
++ tasklet_init(&port->push, gs_rx_push, (unsigned long) port);
++
++ INIT_LIST_HEAD(&port->read_pool);
++ INIT_LIST_HEAD(&port->read_queue);
++ INIT_LIST_HEAD(&port->write_pool);
++
++ port->port_num = port_num;
++ port->port_line_coding = *coding;
++
++ ports[port_num].port = port;
++
++ return 0;
++}
++
++/**
++ * gserial_setup - initialize TTY driver for one or more ports
++ * @g: gadget to associate with these ports
++ * @count: how many ports to support
++ * Context: may sleep
++ *
++ * The TTY stack needs to know in advance how many devices it should
++ * plan to manage. Use this call to set up the ports you will be
++ * exporting through USB. Later, connect them to functions based
++ * on what configuration is activated by the USB host; and disconnect
++ * them as appropriate.
++ *
++ * An example would be a two-configuration device in which both
++ * configurations expose port 0, but through different functions.
++ * One configuration could even expose port 1 while the other
++ * one doesn't.
++ *
++ * Returns negative errno or zero.
++ */
++int __init gserial_setup(struct usb_gadget *g, unsigned count)
++{
++ unsigned i;
++ struct usb_cdc_line_coding coding;
++ int status;
++
++ if (count == 0 || count > N_PORTS)
++ return -EINVAL;
++
++ gs_tty_driver = alloc_tty_driver(count);
++ if (!gs_tty_driver)
++ return -ENOMEM;
++
++ gs_tty_driver->owner = THIS_MODULE;
++ gs_tty_driver->driver_name = "g_serial";
++ gs_tty_driver->name = PREFIX;
++ /* uses dynamically assigned dev_t values */
++
++ gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
++ gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
++ gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
++ gs_tty_driver->init_termios = tty_std_termios;
++
++ /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
++ * MS-Windows. Otherwise, most of these flags shouldn't affect
++ * anything unless we were to actually hook up to a serial line.
++ */
++ gs_tty_driver->init_termios.c_cflag =
++ B9600 | CS8 | CREAD | HUPCL | CLOCAL;
++ gs_tty_driver->init_termios.c_ispeed = 9600;
++ gs_tty_driver->init_termios.c_ospeed = 9600;
++
++ coding.dwDTERate = __constant_cpu_to_le32(9600);
++ coding.bCharFormat = 8;
++ coding.bParityType = USB_CDC_NO_PARITY;
++ coding.bDataBits = USB_CDC_1_STOP_BITS;
++
++ tty_set_operations(gs_tty_driver, &gs_tty_ops);
++
++ /* make devices be openable */
++ for (i = 0; i < count; i++) {
++ mutex_init(&ports[i].lock);
++ status = gs_port_alloc(i, &coding);
++ if (status) {
++ count = i;
++ goto fail;
++ }
++ }
++ n_ports = count;
++
++ /* export the driver ... */
++ status = tty_register_driver(gs_tty_driver);
++ if (status) {
++ put_tty_driver(gs_tty_driver);
++ pr_err("%s: cannot register, err %d\n",
++ __func__, status);
++ goto fail;
++ }
++
++ /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */
++ for (i = 0; i < count; i++) {
++ struct device *tty_dev;
++
++ tty_dev = tty_register_device(gs_tty_driver, i, &g->dev);
++ if (IS_ERR(tty_dev))
++ pr_warning("%s: no classdev for port %d, err %ld\n",
++ __func__, i, PTR_ERR(tty_dev));
++ }
++
++ pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
++ count, (count == 1) ? "" : "s");
++
++ return status;
++fail:
++ while (count--)
++ kfree(ports[count].port);
++ put_tty_driver(gs_tty_driver);
++ gs_tty_driver = NULL;
++ return status;
++}
++
++static int gs_closed(struct gs_port *port)
++{
++ int cond;
++
++ spin_lock_irq(&port->port_lock);
++ cond = (port->open_count == 0) && !port->openclose;
++ spin_unlock_irq(&port->port_lock);
++ return cond;
++}
++
++/**
++ * gserial_cleanup - remove TTY-over-USB driver and devices
++ * Context: may sleep
++ *
++ * This is called to free all resources allocated by @gserial_setup().
++ * Accordingly, it may need to wait until some open /dev/ files have
++ * closed.
++ *
++ * The caller must have issued @gserial_disconnect() for any ports
++ * that had previously been connected, so that there is never any
++ * I/O pending when it's called.
++ */
++void gserial_cleanup(void)
++{
++ unsigned i;
++ struct gs_port *port;
++
++ if (!gs_tty_driver)
++ return;
++
++ /* start sysfs and /dev/ttyGS* node removal */
++ for (i = 0; i < n_ports; i++)
++ tty_unregister_device(gs_tty_driver, i);
++
++ for (i = 0; i < n_ports; i++) {
++ /* prevent new opens */
++ mutex_lock(&ports[i].lock);
++ port = ports[i].port;
++ ports[i].port = NULL;
++ mutex_unlock(&ports[i].lock);
++
++ tasklet_kill(&port->push);
++
++ /* wait for old opens to finish */
++ wait_event(port->close_wait, gs_closed(port));
++
++ WARN_ON(port->port_usb != NULL);
++
++ kfree(port);
++ }
++ n_ports = 0;
++
++ tty_unregister_driver(gs_tty_driver);
++ gs_tty_driver = NULL;
++
++ pr_debug("%s: cleaned up ttyGS* support\n", __func__);
++}
++
++/**
++ * gserial_connect - notify TTY I/O glue that USB link is active
++ * @gser: the function, set up with endpoints and descriptors
++ * @port_num: which port is active
++ * Context: any (usually from irq)
++ *
++ * This is called activate endpoints and let the TTY layer know that
++ * the connection is active ... not unlike "carrier detect". It won't
++ * necessarily start I/O queues; unless the TTY is held open by any
++ * task, there would be no point. However, the endpoints will be
++ * activated so the USB host can perform I/O, subject to basic USB
++ * hardware flow control.
++ *
++ * Caller needs to have set up the endpoints and USB function in @dev
++ * before calling this, as well as the appropriate (speed-specific)
++ * endpoint descriptors, and also have set up the TTY driver by calling
++ * @gserial_setup().
++ *
++ * Returns negative errno or zero.
++ * On success, ep->driver_data will be overwritten.
++ */
++int gserial_connect(struct gserial *gser, u8 port_num)
++{
++ struct gs_port *port;
++ unsigned long flags;
++ int status;
++
++ if (!gs_tty_driver || port_num >= n_ports)
++ return -ENXIO;
++
++ /* we "know" gserial_cleanup() hasn't been called */
++ port = ports[port_num].port;
++
++ /* activate the endpoints */
++ status = usb_ep_enable(gser->in, gser->in_desc);
++ if (status < 0)
++ return status;
++ gser->in->driver_data = port;
++
++ status = usb_ep_enable(gser->out, gser->out_desc);
++ if (status < 0)
++ goto fail_out;
++ gser->out->driver_data = port;
++
++ /* then tell the tty glue that I/O can work */
++ spin_lock_irqsave(&port->port_lock, flags);
++ gser->ioport = port;
++ port->port_usb = gser;
++
++ /* REVISIT unclear how best to handle this state...
++ * we don't really couple it with the Linux TTY.
++ */
++ gser->port_line_coding = port->port_line_coding;
++
++ /* REVISIT if waiting on "carrier detect", signal. */
++
++ /* if it's already open, start I/O ... and notify the serial
++ * protocol about open/close status (connect/disconnect).
++ */
++ if (port->open_count) {
++ pr_debug("gserial_connect: start ttyGS%d\n", port->port_num);
++ gs_start_io(port);
++ if (gser->connect)
++ gser->connect(gser);
++ } else {
++ if (gser->disconnect)
++ gser->disconnect(gser);
++ }
++
++ spin_unlock_irqrestore(&port->port_lock, flags);
++
++ return status;
++
++fail_out:
++ usb_ep_disable(gser->in);
++ gser->in->driver_data = NULL;
++ return status;
++}
++
++/**
++ * gserial_disconnect - notify TTY I/O glue that USB link is inactive
++ * @gser: the function, on which gserial_connect() was called
++ * Context: any (usually from irq)
++ *
++ * This is called to deactivate endpoints and let the TTY layer know
++ * that the connection went inactive ... not unlike "hangup".
++ *
++ * On return, the state is as if gserial_connect() had never been called;
++ * there is no active USB I/O on these endpoints.
++ */
++void gserial_disconnect(struct gserial *gser)
++{
++ struct gs_port *port = gser->ioport;
++ unsigned long flags;
++
++ if (!port)
++ return;
++
++ /* tell the TTY glue not to do I/O here any more */
++ spin_lock_irqsave(&port->port_lock, flags);
++
++ /* REVISIT as above: how best to track this? */
++ port->port_line_coding = gser->port_line_coding;
++
++ port->port_usb = NULL;
++ gser->ioport = NULL;
++ if (port->open_count > 0 || port->openclose) {
++ wake_up_interruptible(&port->drain_wait);
++ if (port->port_tty)
++ tty_hangup(port->port_tty);
++ }
++ spin_unlock_irqrestore(&port->port_lock, flags);
++
++ /* disable endpoints, aborting down any active I/O */
++ usb_ep_disable(gser->out);
++ gser->out->driver_data = NULL;
++
++ usb_ep_disable(gser->in);
++ gser->in->driver_data = NULL;
++
++ /* finally, free any unused/unusable I/O buffers */
++ spin_lock_irqsave(&port->port_lock, flags);
++ if (port->open_count == 0 && !port->openclose)
++ gs_buf_free(&port->port_write_buf);
++ gs_free_requests(gser->out, &port->read_pool);
++ gs_free_requests(gser->out, &port->read_queue);
++ gs_free_requests(gser->in, &port->write_pool);
++ spin_unlock_irqrestore(&port->port_lock, flags);
++}
+diff --git a/drivers/usb/gadget/u_serial.h b/drivers/usb/gadget/u_serial.h
+new file mode 100644
+index 0000000..af3910d
+--- /dev/null
++++ b/drivers/usb/gadget/u_serial.h
+@@ -0,0 +1,66 @@
++/*
++ * u_serial.h - interface to USB gadget "serial port"/TTY utilities
++ *
++ * Copyright (C) 2008 David Brownell
++ * Copyright (C) 2008 by Nokia Corporation
++ *
++ * This software is distributed under the terms of the GNU General
++ * Public License ("GPL") as published by the Free Software Foundation,
++ * either version 2 of that License or (at your option) any later version.
++ */
++
++#ifndef __U_SERIAL_H
++#define __U_SERIAL_H
++
++#include <linux/usb/composite.h>
++#include <linux/usb/cdc.h>
++
++/*
++ * One non-multiplexed "serial" I/O port ... there can be several of these
++ * on any given USB peripheral device, if it provides enough endpoints.
++ *
++ * The "u_serial" utility component exists to do one thing: manage TTY
++ * style I/O using the USB peripheral endpoints listed here, including
++ * hookups to sysfs and /dev for each logical "tty" device.
++ *
++ * REVISIT at least ACM could support tiocmget() if needed.
++ *
++ * REVISIT someday, allow multiplexing several TTYs over these endpoints.
++ */
++struct gserial {
++ struct usb_function func;
++
++ /* port is managed by gserial_{connect,disconnect} */
++ struct gs_port *ioport;
++
++ struct usb_ep *in;
++ struct usb_ep *out;
++ struct usb_endpoint_descriptor *in_desc;
++ struct usb_endpoint_descriptor *out_desc;
++
++ /* REVISIT avoid this CDC-ACM support harder ... */
++ struct usb_cdc_line_coding port_line_coding; /* 9600-8-N-1 etc */
++
++ /* notification callbacks */
++ void (*connect)(struct gserial *p);
++ void (*disconnect)(struct gserial *p);
++ int (*send_break)(struct gserial *p, int duration);
++};
++
++/* utilities to allocate/free request and buffer */
++struct usb_request *gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t flags);
++void gs_free_req(struct usb_ep *, struct usb_request *req);
++
++/* port setup/teardown is handled by gadget driver */
++int gserial_setup(struct usb_gadget *g, unsigned n_ports);
++void gserial_cleanup(void);
++
++/* connect/disconnect is handled by individual functions */
++int gserial_connect(struct gserial *, u8 port_num);
++void gserial_disconnect(struct gserial *);
++
++/* functions are bound to configurations by a config or gadget driver */
++int acm_bind_config(struct usb_configuration *c, u8 port_num);
++int gser_bind_config(struct usb_configuration *c, u8 port_num);
++
++#endif /* __U_SERIAL_H */
+diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
+index fce4924..aa0bd4f 100644
+--- a/drivers/usb/gadget/zero.c
++++ b/drivers/usb/gadget/zero.c
+@@ -1,8 +1,8 @@
+ /*
+ * zero.c -- Gadget Zero, for USB development
+ *
+- * Copyright (C) 2003-2007 David Brownell
+- * All rights reserved.
++ * Copyright (C) 2003-2008 David Brownell
++ * Copyright (C) 2008 by Nokia Corporation
+ *
+ * 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
+@@ -30,12 +30,7 @@
+ *
+ * It supports two similar configurations. One sinks whatever the usb host
+ * writes, and in return sources zeroes. The other loops whatever the host
+- * writes back, so the host can read it. Module options include:
+- *
+- * buflen=N default N=4096, buffer size used
+- * qlen=N default N=32, how many buffers in the loopback queue
+- * loopdefault default false, list loopback config first
+- * autoresume=N default N=0, seconds before triggering remote wakeup
++ * writes back, so the host can read it.
+ *
+ * Many drivers will only have one configuration, letting them be much
+ * simpler if they also don't support high speed operation (like this
+@@ -47,94 +42,35 @@
+ * work with low capability USB controllers without four bulk endpoints.
+ */
+
++/*
++ * driver assumes self-powered hardware, and
++ * has no way for users to trigger remote wakeup.
++ */
++
+ /* #define VERBOSE_DEBUG */
+
+ #include <linux/kernel.h>
+ #include <linux/utsname.h>
+ #include <linux/device.h>
+
+-#include <linux/usb/ch9.h>
+-#include <linux/usb/gadget.h>
+-
++#include "g_zero.h"
+ #include "gadget_chips.h"
+
+
+ /*-------------------------------------------------------------------------*/
+
+-#define DRIVER_VERSION "Earth Day 2008"
++#define DRIVER_VERSION "Cinco de Mayo 2008"
+
+-static const char shortname[] = "zero";
+ static const char longname[] = "Gadget Zero";
+
+-static const char source_sink[] = "source and sink data";
+-static const char loopback[] = "loop input to output";
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/*
+- * driver assumes self-powered hardware, and
+- * has no way for users to trigger remote wakeup.
+- *
+- * this version autoconfigures as much as possible,
+- * which is reasonable for most "bulk-only" drivers.
+- */
+-static const char *EP_IN_NAME; /* source */
+-static const char *EP_OUT_NAME; /* sink */
+-
+-/*-------------------------------------------------------------------------*/
+-
+-/* big enough to hold our biggest descriptor */
+-#define USB_BUFSIZ 256
+-
+-struct zero_dev {
+- spinlock_t lock;
+- struct usb_gadget *gadget;
+- struct usb_request *req; /* for control responses */
+-
+- /* when configured, we have one of two configs:
+- * - source data (in to host) and sink it (out from host)
+- * - or loop it back (out from host back in to host)
+- */
+- u8 config;
+- struct usb_ep *in_ep, *out_ep;
+-
+- /* autoresume timer */
+- struct timer_list resume;
+-};
+-
+-#define DBG(d, fmt, args...) \
+- dev_dbg(&(d)->gadget->dev , fmt , ## args)
+-#define VDBG(d, fmt, args...) \
+- dev_vdbg(&(d)->gadget->dev , fmt , ## args)
+-#define ERROR(d, fmt, args...) \
+- dev_err(&(d)->gadget->dev , fmt , ## args)
+-#define WARN(d, fmt, args...) \
+- dev_warn(&(d)->gadget->dev , fmt , ## args)
+-#define INFO(d, fmt, args...) \
+- dev_info(&(d)->gadget->dev , fmt , ## args)
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static unsigned buflen = 4096;
+-static unsigned qlen = 32;
+-static unsigned pattern = 0;
+-
+-module_param(buflen, uint, S_IRUGO);
+-module_param(qlen, uint, S_IRUGO);
+-module_param(pattern, uint, S_IRUGO|S_IWUSR);
+-
+-/*
+- * if it's nonzero, autoresume says how many seconds to wait
+- * before trying to wake up the host after suspend.
+- */
+-static unsigned autoresume = 0;
+-module_param(autoresume, uint, 0);
++unsigned buflen = 4096;
++module_param(buflen, uint, 0);
+
+ /*
+ * Normally the "loopback" configuration is second (index 1) so
+ * it's not the default. Here's where to change that order, to
+- * work better with hosts where config changes are problematic.
+- * Or controllers (like superh) that only support one config.
++ * work better with hosts where config changes are problematic or
++ * controllers (like original superh) that only support one config.
+ */
+ static int loopdefault = 0;
+ module_param(loopdefault, bool, S_IRUGO|S_IWUSR);
+@@ -156,24 +92,6 @@ module_param(loopdefault, bool, S_IRUGO|S_IWUSR);
+
+ /*-------------------------------------------------------------------------*/
+
+-/*
+- * DESCRIPTORS ... most are static, but strings and (full)
+- * configuration descriptors are built on demand.
+- */
+-
+-#define STRING_MANUFACTURER 25
+-#define STRING_PRODUCT 42
+-#define STRING_SERIAL 101
+-#define STRING_SOURCE_SINK 250
+-#define STRING_LOOPBACK 251
+-
+-/*
+- * This device advertises two configurations; these numbers work
+- * on a pxa250 as well as more flexible hardware.
+- */
+-#define CONFIG_SOURCE_SINK 3
+-#define CONFIG_LOOPBACK 2
+-
+ static struct usb_device_descriptor device_desc = {
+ .bLength = sizeof device_desc,
+ .bDescriptorType = USB_DT_DEVICE,
+@@ -183,248 +101,64 @@ static struct usb_device_descriptor device_desc = {
+
+ .idVendor = __constant_cpu_to_le16(DRIVER_VENDOR_NUM),
+ .idProduct = __constant_cpu_to_le16(DRIVER_PRODUCT_NUM),
+- .iManufacturer = STRING_MANUFACTURER,
+- .iProduct = STRING_PRODUCT,
+- .iSerialNumber = STRING_SERIAL,
+ .bNumConfigurations = 2,
+ };
+
+-static struct usb_config_descriptor source_sink_config = {
+- .bLength = sizeof source_sink_config,
+- .bDescriptorType = USB_DT_CONFIG,
+-
+- /* compute wTotalLength on the fly */
+- .bNumInterfaces = 1,
+- .bConfigurationValue = CONFIG_SOURCE_SINK,
+- .iConfiguration = STRING_SOURCE_SINK,
+- .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
+- .bMaxPower = 1, /* self-powered */
+-};
+-
+-static struct usb_config_descriptor loopback_config = {
+- .bLength = sizeof loopback_config,
+- .bDescriptorType = USB_DT_CONFIG,
+-
+- /* compute wTotalLength on the fly */
+- .bNumInterfaces = 1,
+- .bConfigurationValue = CONFIG_LOOPBACK,
+- .iConfiguration = STRING_LOOPBACK,
+- .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
+- .bMaxPower = 1, /* self-powered */
+-};
+-
++#ifdef CONFIG_USB_OTG
+ static struct usb_otg_descriptor otg_descriptor = {
+ .bLength = sizeof otg_descriptor,
+ .bDescriptorType = USB_DT_OTG,
+
+- .bmAttributes = USB_OTG_SRP,
+-};
+-
+-/* one interface in each configuration */
+-
+-static const struct usb_interface_descriptor source_sink_intf = {
+- .bLength = sizeof source_sink_intf,
+- .bDescriptorType = USB_DT_INTERFACE,
+-
+- .bNumEndpoints = 2,
+- .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
+- .iInterface = STRING_SOURCE_SINK,
+-};
+-
+-static const struct usb_interface_descriptor loopback_intf = {
+- .bLength = sizeof loopback_intf,
+- .bDescriptorType = USB_DT_INTERFACE,
+-
+- .bNumEndpoints = 2,
+- .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
+- .iInterface = STRING_LOOPBACK,
+-};
+-
+-/* two full speed bulk endpoints; their use is config-dependent */
+-
+-static struct usb_endpoint_descriptor fs_source_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+-
+- .bEndpointAddress = USB_DIR_IN,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+-};
+-
+-static struct usb_endpoint_descriptor fs_sink_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+-
+- .bEndpointAddress = USB_DIR_OUT,
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+-};
+-
+-static const struct usb_descriptor_header *fs_source_sink_function[] = {
+- (struct usb_descriptor_header *) &otg_descriptor,
+- (struct usb_descriptor_header *) &source_sink_intf,
+- (struct usb_descriptor_header *) &fs_sink_desc,
+- (struct usb_descriptor_header *) &fs_source_desc,
+- NULL,
+-};
+-
+-static const struct usb_descriptor_header *fs_loopback_function[] = {
+- (struct usb_descriptor_header *) &otg_descriptor,
+- (struct usb_descriptor_header *) &loopback_intf,
+- (struct usb_descriptor_header *) &fs_sink_desc,
+- (struct usb_descriptor_header *) &fs_source_desc,
+- NULL,
+-};
+-
+-/*
+- * usb 2.0 devices need to expose both high speed and full speed
+- * descriptors, unless they only run at full speed.
+- *
+- * that means alternate endpoint descriptors (bigger packets)
+- * and a "device qualifier" ... plus more construction options
+- * for the config descriptor.
+- */
+-
+-static struct usb_endpoint_descriptor hs_source_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+-
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .wMaxPacketSize = __constant_cpu_to_le16(512),
+-};
+-
+-static struct usb_endpoint_descriptor hs_sink_desc = {
+- .bLength = USB_DT_ENDPOINT_SIZE,
+- .bDescriptorType = USB_DT_ENDPOINT,
+-
+- .bmAttributes = USB_ENDPOINT_XFER_BULK,
+- .wMaxPacketSize = __constant_cpu_to_le16(512),
+-};
+-
+-static struct usb_qualifier_descriptor dev_qualifier = {
+- .bLength = sizeof dev_qualifier,
+- .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
+-
+- .bcdUSB = __constant_cpu_to_le16(0x0200),
+- .bDeviceClass = USB_CLASS_VENDOR_SPEC,
+-
+- .bNumConfigurations = 2,
++ /* REVISIT SRP-only hardware is possible, although
++ * it would not be called "OTG" ...
++ */
++ .bmAttributes = USB_OTG_SRP | USB_OTG_HNP,
+ };
+
+-static const struct usb_descriptor_header *hs_source_sink_function[] = {
++const struct usb_descriptor_header *otg_desc[] = {
+ (struct usb_descriptor_header *) &otg_descriptor,
+- (struct usb_descriptor_header *) &source_sink_intf,
+- (struct usb_descriptor_header *) &hs_source_desc,
+- (struct usb_descriptor_header *) &hs_sink_desc,
+ NULL,
+ };
++#endif
+
+-static const struct usb_descriptor_header *hs_loopback_function[] = {
+- (struct usb_descriptor_header *) &otg_descriptor,
+- (struct usb_descriptor_header *) &loopback_intf,
+- (struct usb_descriptor_header *) &hs_source_desc,
+- (struct usb_descriptor_header *) &hs_sink_desc,
+- NULL,
+-};
++/* string IDs are assigned dynamically */
+
+-/* maxpacket and other transfer characteristics vary by speed. */
+-static inline struct usb_endpoint_descriptor *
+-ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
+- struct usb_endpoint_descriptor *fs)
+-{
+- if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+- return hs;
+- return fs;
+-}
++#define STRING_MANUFACTURER_IDX 0
++#define STRING_PRODUCT_IDX 1
++#define STRING_SERIAL_IDX 2
+
+ static char manufacturer[50];
+
+ /* default serial number takes at least two packets */
+ static char serial[] = "0123456789.0123456789.0123456789";
+
+-
+-/* static strings, in UTF-8 */
+-static struct usb_string strings[] = {
+- { STRING_MANUFACTURER, manufacturer, },
+- { STRING_PRODUCT, longname, },
+- { STRING_SERIAL, serial, },
+- { STRING_LOOPBACK, loopback, },
+- { STRING_SOURCE_SINK, source_sink, },
++static struct usb_string strings_dev[] = {
++ [STRING_MANUFACTURER_IDX].s = manufacturer,
++ [STRING_PRODUCT_IDX].s = longname,
++ [STRING_SERIAL_IDX].s = serial,
+ { } /* end of list */
+ };
+
+-static struct usb_gadget_strings stringtab = {
++static struct usb_gadget_strings stringtab_dev = {
+ .language = 0x0409, /* en-us */
+- .strings = strings,
++ .strings = strings_dev,
+ };
+
+-/*
+- * config descriptors are also handcrafted. these must agree with code
+- * that sets configurations, and with code managing interfaces and their
+- * altsettings. other complexity may come from:
+- *
+- * - high speed support, including "other speed config" rules
+- * - multiple configurations
+- * - interfaces with alternate settings
+- * - embedded class or vendor-specific descriptors
+- *
+- * this handles high speed, and has a second config that could as easily
+- * have been an alternate interface setting (on most hardware).
+- *
+- * NOTE: to demonstrate (and test) more USB capabilities, this driver
+- * should include an altsetting to test interrupt transfers, including
+- * high bandwidth modes at high speed. (Maybe work like Intel's test
+- * device?)
+- */
+-static int config_buf(struct usb_gadget *gadget,
+- u8 *buf, u8 type, unsigned index)
+-{
+- int is_source_sink;
+- int len;
+- const struct usb_descriptor_header **function;
+- int hs = 0;
+-
+- /* two configurations will always be index 0 and index 1 */
+- if (index > 1)
+- return -EINVAL;
+- is_source_sink = loopdefault ? (index == 1) : (index == 0);
+-
+- if (gadget_is_dualspeed(gadget)) {
+- hs = (gadget->speed == USB_SPEED_HIGH);
+- if (type == USB_DT_OTHER_SPEED_CONFIG)
+- hs = !hs;
+- }
+- if (hs)
+- function = is_source_sink
+- ? hs_source_sink_function
+- : hs_loopback_function;
+- else
+- function = is_source_sink
+- ? fs_source_sink_function
+- : fs_loopback_function;
+-
+- /* for now, don't advertise srp-only devices */
+- if (!gadget_is_otg(gadget))
+- function++;
+-
+- len = usb_gadget_config_buf(is_source_sink
+- ? &source_sink_config
+- : &loopback_config,
+- buf, USB_BUFSIZ, function);
+- if (len < 0)
+- return len;
+- ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
+- return len;
+-}
++static struct usb_gadget_strings *dev_strings[] = {
++ &stringtab_dev,
++ NULL,
++};
+
+ /*-------------------------------------------------------------------------*/
+
+-static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
++struct usb_request *alloc_ep_req(struct usb_ep *ep)
+ {
+ struct usb_request *req;
+
+ req = usb_ep_alloc_request(ep, GFP_ATOMIC);
+ if (req) {
+- req->length = length;
+- req->buf = kmalloc(length, GFP_ATOMIC);
++ req->length = buflen;
++ req->buf = kmalloc(buflen, GFP_ATOMIC);
+ if (!req->buf) {
+ usb_ep_free_request(ep, req);
+ req = NULL;
+@@ -433,681 +167,73 @@ static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
+ return req;
+ }
+
+-static void free_ep_req(struct usb_ep *ep, struct usb_request *req)
++void free_ep_req(struct usb_ep *ep, struct usb_request *req)
+ {
+ kfree(req->buf);
+ usb_ep_free_request(ep, req);
+ }
+
+-/*-------------------------------------------------------------------------*/
+-
+-/*
+- * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripherals,
+- * this just sinks bulk packets OUT to the peripheral and sources them IN
+- * to the host, optionally with specific data patterns.
+- *
+- * In terms of control messaging, this supports all the standard requests
+- * plus two that support control-OUT tests.
+- *
+- * Note that because this doesn't queue more than one request at a time,
+- * some other function must be used to test queueing logic. The network
+- * link (g_ether) is probably the best option for that.
+- */
+-
+-/* optionally require specific source/sink data patterns */
+-
+-static int
+-check_read_data(
+- struct zero_dev *dev,
+- struct usb_ep *ep,
+- struct usb_request *req
+-)
++static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep)
+ {
+- unsigned i;
+- u8 *buf = req->buf;
+-
+- for (i = 0; i < req->actual; i++, buf++) {
+- switch (pattern) {
+- /* all-zeroes has no synchronization issues */
+- case 0:
+- if (*buf == 0)
+- continue;
+- break;
+- /* mod63 stays in sync with short-terminated transfers,
+- * or otherwise when host and gadget agree on how large
+- * each usb transfer request should be. resync is done
+- * with set_interface or set_config.
+- */
+- case 1:
+- if (*buf == (u8)(i % 63))
+- continue;
+- break;
+- }
+- ERROR(dev, "bad OUT byte, buf[%d] = %d\n", i, *buf);
+- usb_ep_set_halt(ep);
+- return -EINVAL;
++ int value;
++
++ if (ep->driver_data) {
++ value = usb_ep_disable(ep);
++ if (value < 0)
++ DBG(cdev, "disable %s --> %d\n",
++ ep->name, value);
++ ep->driver_data = NULL;
+ }
+- return 0;
+ }
+
+-static void reinit_write_data(struct usb_ep *ep, struct usb_request *req)
++void disable_endpoints(struct usb_composite_dev *cdev,
++ struct usb_ep *in, struct usb_ep *out)
+ {
+- unsigned i;
+- u8 *buf = req->buf;
+-
+- switch (pattern) {
+- case 0:
+- memset(req->buf, 0, req->length);
+- break;
+- case 1:
+- for (i = 0; i < req->length; i++)
+- *buf++ = (u8) (i % 63);
+- break;
+- }
+-}
+-
+-/* if there is only one request in the queue, there'll always be an
+- * irq delay between end of one request and start of the next.
+- * that prevents using hardware dma queues.
+- */
+-static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)
+-{
+- struct zero_dev *dev = ep->driver_data;
+- int status = req->status;
+-
+- switch (status) {
+-
+- case 0: /* normal completion? */
+- if (ep == dev->out_ep) {
+- check_read_data(dev, ep, req);
+- memset(req->buf, 0x55, req->length);
+- } else
+- reinit_write_data(ep, req);
+- break;
+-
+- /* this endpoint is normally active while we're configured */
+- case -ECONNABORTED: /* hardware forced ep reset */
+- case -ECONNRESET: /* request dequeued */
+- case -ESHUTDOWN: /* disconnect from host */
+- VDBG(dev, "%s gone (%d), %d/%d\n", ep->name, status,
+- req->actual, req->length);
+- if (ep == dev->out_ep)
+- check_read_data(dev, ep, req);
+- free_ep_req(ep, req);
+- return;
+-
+- case -EOVERFLOW: /* buffer overrun on read means that
+- * we didn't provide a big enough
+- * buffer.
+- */
+- default:
+-#if 1
+- DBG(dev, "%s complete --> %d, %d/%d\n", ep->name,
+- status, req->actual, req->length);
+-#endif
+- case -EREMOTEIO: /* short read */
+- break;
+- }
+-
+- status = usb_ep_queue(ep, req, GFP_ATOMIC);
+- if (status) {
+- ERROR(dev, "kill %s: resubmit %d bytes --> %d\n",
+- ep->name, req->length, status);
+- usb_ep_set_halt(ep);
+- /* FIXME recover later ... somehow */
+- }
+-}
+-
+-static struct usb_request *source_sink_start_ep(struct usb_ep *ep)
+-{
+- struct usb_request *req;
+- int status;
+-
+- req = alloc_ep_req(ep, buflen);
+- if (!req)
+- return NULL;
+-
+- memset(req->buf, 0, req->length);
+- req->complete = source_sink_complete;
+-
+- if (strcmp(ep->name, EP_IN_NAME) == 0)
+- reinit_write_data(ep, req);
+- else
+- memset(req->buf, 0x55, req->length);
+-
+- status = usb_ep_queue(ep, req, GFP_ATOMIC);
+- if (status) {
+- struct zero_dev *dev = ep->driver_data;
+-
+- ERROR(dev, "start %s --> %d\n", ep->name, status);
+- free_ep_req(ep, req);
+- req = NULL;
+- }
+-
+- return req;
+-}
+-
+-static int set_source_sink_config(struct zero_dev *dev)
+-{
+- int result = 0;
+- struct usb_ep *ep;
+- struct usb_gadget *gadget = dev->gadget;
+-
+- gadget_for_each_ep(ep, gadget) {
+- const struct usb_endpoint_descriptor *d;
+-
+- /* one endpoint writes (sources) zeroes in (to the host) */
+- if (strcmp(ep->name, EP_IN_NAME) == 0) {
+- d = ep_desc(gadget, &hs_source_desc, &fs_source_desc);
+- result = usb_ep_enable(ep, d);
+- if (result == 0) {
+- ep->driver_data = dev;
+- if (source_sink_start_ep(ep) != NULL) {
+- dev->in_ep = ep;
+- continue;
+- }
+- usb_ep_disable(ep);
+- result = -EIO;
+- }
+-
+- /* one endpoint reads (sinks) anything out (from the host) */
+- } else if (strcmp(ep->name, EP_OUT_NAME) == 0) {
+- d = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);
+- result = usb_ep_enable(ep, d);
+- if (result == 0) {
+- ep->driver_data = dev;
+- if (source_sink_start_ep(ep) != NULL) {
+- dev->out_ep = ep;
+- continue;
+- }
+- usb_ep_disable(ep);
+- result = -EIO;
+- }
+-
+- /* ignore any other endpoints */
+- } else
+- continue;
+-
+- /* stop on error */
+- ERROR(dev, "can't start %s, result %d\n", ep->name, result);
+- break;
+- }
+- if (result == 0)
+- DBG(dev, "buflen %d\n", buflen);
+-
+- /* caller is responsible for cleanup on error */
+- return result;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static void loopback_complete(struct usb_ep *ep, struct usb_request *req)
+-{
+- struct zero_dev *dev = ep->driver_data;
+- int status = req->status;
+-
+- switch (status) {
+-
+- case 0: /* normal completion? */
+- if (ep == dev->out_ep) {
+- /* loop this OUT packet back IN to the host */
+- req->zero = (req->actual < req->length);
+- req->length = req->actual;
+- status = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC);
+- if (status == 0)
+- return;
+-
+- /* "should never get here" */
+- ERROR(dev, "can't loop %s to %s: %d\n",
+- ep->name, dev->in_ep->name,
+- status);
+- }
+-
+- /* queue the buffer for some later OUT packet */
+- req->length = buflen;
+- status = usb_ep_queue(dev->out_ep, req, GFP_ATOMIC);
+- if (status == 0)
+- return;
+-
+- /* "should never get here" */
+- /* FALLTHROUGH */
+-
+- default:
+- ERROR(dev, "%s loop complete --> %d, %d/%d\n", ep->name,
+- status, req->actual, req->length);
+- /* FALLTHROUGH */
+-
+- /* NOTE: since this driver doesn't maintain an explicit record
+- * of requests it submitted (just maintains qlen count), we
+- * rely on the hardware driver to clean up on disconnect or
+- * endpoint disable.
+- */
+- case -ECONNABORTED: /* hardware forced ep reset */
+- case -ECONNRESET: /* request dequeued */
+- case -ESHUTDOWN: /* disconnect from host */
+- free_ep_req(ep, req);
+- return;
+- }
+-}
+-
+-static int set_loopback_config(struct zero_dev *dev)
+-{
+- int result = 0;
+- struct usb_ep *ep;
+- struct usb_gadget *gadget = dev->gadget;
+-
+- gadget_for_each_ep(ep, gadget) {
+- const struct usb_endpoint_descriptor *d;
+-
+- /* one endpoint writes data back IN to the host */
+- if (strcmp(ep->name, EP_IN_NAME) == 0) {
+- d = ep_desc(gadget, &hs_source_desc, &fs_source_desc);
+- result = usb_ep_enable(ep, d);
+- if (result == 0) {
+- ep->driver_data = dev;
+- dev->in_ep = ep;
+- continue;
+- }
+-
+- /* one endpoint just reads OUT packets */
+- } else if (strcmp(ep->name, EP_OUT_NAME) == 0) {
+- d = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);
+- result = usb_ep_enable(ep, d);
+- if (result == 0) {
+- ep->driver_data = dev;
+- dev->out_ep = ep;
+- continue;
+- }
+-
+- /* ignore any other endpoints */
+- } else
+- continue;
+-
+- /* stop on error */
+- ERROR(dev, "can't enable %s, result %d\n", ep->name, result);
+- break;
+- }
+-
+- /* allocate a bunch of read buffers and queue them all at once.
+- * we buffer at most 'qlen' transfers; fewer if any need more
+- * than 'buflen' bytes each.
+- */
+- if (result == 0) {
+- struct usb_request *req;
+- unsigned i;
+-
+- ep = dev->out_ep;
+- for (i = 0; i < qlen && result == 0; i++) {
+- req = alloc_ep_req(ep, buflen);
+- if (req) {
+- req->complete = loopback_complete;
+- result = usb_ep_queue(ep, req, GFP_ATOMIC);
+- if (result)
+- DBG(dev, "%s queue req --> %d\n",
+- ep->name, result);
+- } else
+- result = -ENOMEM;
+- }
+- }
+- if (result == 0)
+- DBG(dev, "qlen %d, buflen %d\n", qlen, buflen);
+-
+- /* caller is responsible for cleanup on error */
+- return result;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static void zero_reset_config(struct zero_dev *dev)
+-{
+- if (dev->config == 0)
+- return;
+-
+- DBG(dev, "reset config\n");
+-
+- /* just disable endpoints, forcing completion of pending i/o.
+- * all our completion handlers free their requests in this case.
+- */
+- if (dev->in_ep) {
+- usb_ep_disable(dev->in_ep);
+- dev->in_ep = NULL;
+- }
+- if (dev->out_ep) {
+- usb_ep_disable(dev->out_ep);
+- dev->out_ep = NULL;
+- }
+- dev->config = 0;
+- del_timer(&dev->resume);
+-}
+-
+-/* change our operational config. this code must agree with the code
+- * that returns config descriptors, and altsetting code.
+- *
+- * it's also responsible for power management interactions. some
+- * configurations might not work with our current power sources.
+- *
+- * note that some device controller hardware will constrain what this
+- * code can do, perhaps by disallowing more than one configuration or
+- * by limiting configuration choices (like the pxa2xx).
+- */
+-static int zero_set_config(struct zero_dev *dev, unsigned number)
+-{
+- int result = 0;
+- struct usb_gadget *gadget = dev->gadget;
+-
+- if (number == dev->config)
+- return 0;
+-
+- if (gadget_is_sa1100(gadget) && dev->config) {
+- /* tx fifo is full, but we can't clear it...*/
+- ERROR(dev, "can't change configurations\n");
+- return -ESPIPE;
+- }
+- zero_reset_config(dev);
+-
+- switch (number) {
+- case CONFIG_SOURCE_SINK:
+- result = set_source_sink_config(dev);
+- break;
+- case CONFIG_LOOPBACK:
+- result = set_loopback_config(dev);
+- break;
+- default:
+- result = -EINVAL;
+- /* FALL THROUGH */
+- case 0:
+- return result;
+- }
+-
+- if (!result && (!dev->in_ep || !dev->out_ep))
+- result = -ENODEV;
+- if (result)
+- zero_reset_config(dev);
+- else {
+- char *speed;
+-
+- switch (gadget->speed) {
+- case USB_SPEED_LOW: speed = "low"; break;
+- case USB_SPEED_FULL: speed = "full"; break;
+- case USB_SPEED_HIGH: speed = "high"; break;
+- default: speed = "?"; break;
+- }
+-
+- dev->config = number;
+- INFO(dev, "%s speed config #%d: %s\n", speed, number,
+- (number == CONFIG_SOURCE_SINK)
+- ? source_sink : loopback);
+- }
+- return result;
+-}
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static void zero_setup_complete(struct usb_ep *ep, struct usb_request *req)
+-{
+- if (req->status || req->actual != req->length)
+- DBG((struct zero_dev *) ep->driver_data,
+- "setup complete --> %d, %d/%d\n",
+- req->status, req->actual, req->length);
+-}
+-
+-/*
+- * The setup() callback implements all the ep0 functionality that's
+- * not handled lower down, in hardware or the hardware driver (like
+- * device and endpoint feature flags, and their status). It's all
+- * housekeeping for the gadget function we're implementing. Most of
+- * the work is in config-specific setup.
+- */
+-static int
+-zero_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
+-{
+- struct zero_dev *dev = get_gadget_data(gadget);
+- struct usb_request *req = dev->req;
+- int value = -EOPNOTSUPP;
+- u16 w_index = le16_to_cpu(ctrl->wIndex);
+- u16 w_value = le16_to_cpu(ctrl->wValue);
+- u16 w_length = le16_to_cpu(ctrl->wLength);
+-
+- /* usually this stores reply data in the pre-allocated ep0 buffer,
+- * but config change events will reconfigure hardware.
+- */
+- req->zero = 0;
+- switch (ctrl->bRequest) {
+-
+- case USB_REQ_GET_DESCRIPTOR:
+- if (ctrl->bRequestType != USB_DIR_IN)
+- goto unknown;
+- switch (w_value >> 8) {
+-
+- case USB_DT_DEVICE:
+- value = min(w_length, (u16) sizeof device_desc);
+- memcpy(req->buf, &device_desc, value);
+- break;
+- case USB_DT_DEVICE_QUALIFIER:
+- if (!gadget_is_dualspeed(gadget))
+- break;
+- value = min(w_length, (u16) sizeof dev_qualifier);
+- memcpy(req->buf, &dev_qualifier, value);
+- break;
+-
+- case USB_DT_OTHER_SPEED_CONFIG:
+- if (!gadget_is_dualspeed(gadget))
+- break;
+- // FALLTHROUGH
+- case USB_DT_CONFIG:
+- value = config_buf(gadget, req->buf,
+- w_value >> 8,
+- w_value & 0xff);
+- if (value >= 0)
+- value = min(w_length, (u16) value);
+- break;
+-
+- case USB_DT_STRING:
+- /* wIndex == language code.
+- * this driver only handles one language, you can
+- * add string tables for other languages, using
+- * any UTF-8 characters
+- */
+- value = usb_gadget_get_string(&stringtab,
+- w_value & 0xff, req->buf);
+- if (value >= 0)
+- value = min(w_length, (u16) value);
+- break;
+- }
+- break;
+-
+- /* currently two configs, two speeds */
+- case USB_REQ_SET_CONFIGURATION:
+- if (ctrl->bRequestType != 0)
+- goto unknown;
+- if (gadget->a_hnp_support)
+- DBG(dev, "HNP available\n");
+- else if (gadget->a_alt_hnp_support)
+- DBG(dev, "HNP needs a different root port\n");
+- else
+- VDBG(dev, "HNP inactive\n");
+- spin_lock(&dev->lock);
+- value = zero_set_config(dev, w_value);
+- spin_unlock(&dev->lock);
+- break;
+- case USB_REQ_GET_CONFIGURATION:
+- if (ctrl->bRequestType != USB_DIR_IN)
+- goto unknown;
+- *(u8 *)req->buf = dev->config;
+- value = min(w_length, (u16) 1);
+- break;
+-
+- /* until we add altsetting support, or other interfaces,
+- * only 0/0 are possible. pxa2xx only supports 0/0 (poorly)
+- * and already killed pending endpoint I/O.
+- */
+- case USB_REQ_SET_INTERFACE:
+- if (ctrl->bRequestType != USB_RECIP_INTERFACE)
+- goto unknown;
+- spin_lock(&dev->lock);
+- if (dev->config && w_index == 0 && w_value == 0) {
+- u8 config = dev->config;
+-
+- /* resets interface configuration, forgets about
+- * previous transaction state (queued bufs, etc)
+- * and re-inits endpoint state (toggle etc)
+- * no response queued, just zero status == success.
+- * if we had more than one interface we couldn't
+- * use this "reset the config" shortcut.
+- */
+- zero_reset_config(dev);
+- zero_set_config(dev, config);
+- value = 0;
+- }
+- spin_unlock(&dev->lock);
+- break;
+- case USB_REQ_GET_INTERFACE:
+- if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
+- goto unknown;
+- if (!dev->config)
+- break;
+- if (w_index != 0) {
+- value = -EDOM;
+- break;
+- }
+- *(u8 *)req->buf = 0;
+- value = min(w_length, (u16) 1);
+- break;
+-
+- /*
+- * These are the same vendor-specific requests supported by
+- * Intel's USB 2.0 compliance test devices. We exceed that
+- * device spec by allowing multiple-packet requests.
+- */
+- case 0x5b: /* control WRITE test -- fill the buffer */
+- if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
+- goto unknown;
+- if (w_value || w_index)
+- break;
+- /* just read that many bytes into the buffer */
+- if (w_length > USB_BUFSIZ)
+- break;
+- value = w_length;
+- break;
+- case 0x5c: /* control READ test -- return the buffer */
+- if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
+- goto unknown;
+- if (w_value || w_index)
+- break;
+- /* expect those bytes are still in the buffer; send back */
+- if (w_length > USB_BUFSIZ
+- || w_length != req->length)
+- break;
+- value = w_length;
+- break;
+-
+- default:
+-unknown:
+- VDBG(dev,
+- "unknown control req%02x.%02x v%04x i%04x l%d\n",
+- ctrl->bRequestType, ctrl->bRequest,
+- w_value, w_index, w_length);
+- }
+-
+- /* respond with data transfer before status phase? */
+- if (value >= 0) {
+- req->length = value;
+- req->zero = value < w_length;
+- value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
+- if (value < 0) {
+- DBG(dev, "ep_queue --> %d\n", value);
+- req->status = 0;
+- zero_setup_complete(gadget->ep0, req);
+- }
+- }
+-
+- /* device either stalls (value < 0) or reports success */
+- return value;
+-}
+-
+-static void zero_disconnect(struct usb_gadget *gadget)
+-{
+- struct zero_dev *dev = get_gadget_data(gadget);
+- unsigned long flags;
+-
+- spin_lock_irqsave(&dev->lock, flags);
+- zero_reset_config(dev);
+-
+- /* a more significant application might have some non-usb
+- * activities to quiesce here, saving resources like power
+- * or pushing the notification up a network stack.
+- */
+- spin_unlock_irqrestore(&dev->lock, flags);
+-
+- /* next we may get setup() calls to enumerate new connections;
+- * or an unbind() during shutdown (including removing module).
+- */
+-}
+-
+-static void zero_autoresume(unsigned long _dev)
+-{
+- struct zero_dev *dev = (struct zero_dev *) _dev;
+- int status;
+-
+- /* normally the host would be woken up for something
+- * more significant than just a timer firing...
+- */
+- if (dev->gadget->speed != USB_SPEED_UNKNOWN) {
+- status = usb_gadget_wakeup(dev->gadget);
+- DBG(dev, "wakeup --> %d\n", status);
+- }
++ disable_ep(cdev, in);
++ disable_ep(cdev, out);
+ }
+
+ /*-------------------------------------------------------------------------*/
+
+-static void zero_unbind(struct usb_gadget *gadget)
++static int __init zero_bind(struct usb_composite_dev *cdev)
+ {
+- struct zero_dev *dev = get_gadget_data(gadget);
+-
+- DBG(dev, "unbind\n");
+-
+- /* we've already been disconnected ... no i/o is active */
+- if (dev->req) {
+- dev->req->length = USB_BUFSIZ;
+- free_ep_req(gadget->ep0, dev->req);
+- }
+- del_timer_sync(&dev->resume);
+- kfree(dev);
+- set_gadget_data(gadget, NULL);
+-}
+-
+-static int __init zero_bind(struct usb_gadget *gadget)
+-{
+- struct zero_dev *dev;
+- struct usb_ep *ep;
+ int gcnum;
++ struct usb_gadget *gadget = cdev->gadget;
++ int id;
+
+- /* FIXME this can't yet work right with SH ... it has only
+- * one configuration, numbered one.
++ /* Allocate string descriptor numbers ... note that string
++ * contents can be overridden by the composite_dev glue.
+ */
+- if (gadget_is_sh(gadget))
+- return -ENODEV;
+-
+- /* Bulk-only drivers like this one SHOULD be able to
+- * autoconfigure on any sane usb controller driver,
+- * but there may also be important quirks to address.
++ id = usb_string_id(cdev);
++ if (id < 0)
++ return id;
++ strings_dev[STRING_MANUFACTURER_IDX].id = id;
++ device_desc.iManufacturer = id;
++
++ id = usb_string_id(cdev);
++ if (id < 0)
++ return id;
++ strings_dev[STRING_PRODUCT_IDX].id = id;
++ device_desc.iProduct = id;
++
++ id = usb_string_id(cdev);
++ if (id < 0)
++ return id;
++ strings_dev[STRING_SERIAL_IDX].id = id;
++ device_desc.iSerialNumber = id;
++
++ /* Register primary, then secondary configuration. Note that
++ * SH3 only allows one config...
+ */
+- usb_ep_autoconfig_reset(gadget);
+- ep = usb_ep_autoconfig(gadget, &fs_source_desc);
+- if (!ep) {
+-autoconf_fail:
+- pr_err("%s: can't autoconfigure on %s\n",
+- shortname, gadget->name);
+- return -ENODEV;
++ if (loopdefault) {
++ loopback_add(cdev);
++ if (!gadget_is_sh(gadget))
++ sourcesink_add(cdev);
++ } else {
++ sourcesink_add(cdev);
++ if (!gadget_is_sh(gadget))
++ loopback_add(cdev);
+ }
+- EP_IN_NAME = ep->name;
+- ep->driver_data = ep; /* claim */
+-
+- ep = usb_ep_autoconfig(gadget, &fs_sink_desc);
+- if (!ep)
+- goto autoconf_fail;
+- EP_OUT_NAME = ep->name;
+- ep->driver_data = ep; /* claim */
+
+ gcnum = usb_gadget_controller_number(gadget);
+ if (gcnum >= 0)
+@@ -1115,144 +241,44 @@ autoconf_fail:
+ else {
+ /* gadget zero is so simple (for now, no altsettings) that
+ * it SHOULD NOT have problems with bulk-capable hardware.
+- * so warn about unrcognized controllers, don't panic.
++ * so just warn about unrcognized controllers -- don't panic.
+ *
+ * things like configuration and altsetting numbering
+ * can need hardware-specific attention though.
+ */
+ pr_warning("%s: controller '%s' not recognized\n",
+- shortname, gadget->name);
++ longname, gadget->name);
+ device_desc.bcdDevice = __constant_cpu_to_le16(0x9999);
+ }
+
+
+- /* ok, we made sense of the hardware ... */
+- dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+- if (!dev)
+- return -ENOMEM;
+- spin_lock_init(&dev->lock);
+- dev->gadget = gadget;
+- set_gadget_data(gadget, dev);
+-
+- init_timer(&dev->resume);
+- dev->resume.function = zero_autoresume;
+- dev->resume.data = (unsigned long) dev;
+-
+- /* preallocate control response and buffer */
+- dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
+- if (!dev->req)
+- goto enomem;
+- dev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);
+- if (!dev->req->buf)
+- goto enomem;
+-
+- dev->req->complete = zero_setup_complete;
+-
+- device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
+-
+- if (gadget_is_dualspeed(gadget)) {
+- /* assume ep0 uses the same value for both speeds ... */
+- dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
+-
+- /* and that all endpoints are dual-speed */
+- hs_source_desc.bEndpointAddress =
+- fs_source_desc.bEndpointAddress;
+- hs_sink_desc.bEndpointAddress =
+- fs_sink_desc.bEndpointAddress;
+- }
+-
+- if (gadget_is_otg(gadget)) {
+- otg_descriptor.bmAttributes |= USB_OTG_HNP,
+- source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+- loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+- }
+-
+- usb_gadget_set_selfpowered(gadget);
+-
+- if (autoresume) {
+- source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+- loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+- }
+-
+- gadget->ep0->driver_data = dev;
+-
+- INFO(dev, "%s, version: " DRIVER_VERSION "\n", longname);
+- INFO(dev, "using %s, OUT %s IN %s\n", gadget->name,
+- EP_OUT_NAME, EP_IN_NAME);
++ INFO(cdev, "%s, version: " DRIVER_VERSION "\n", longname);
+
+ snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
+ init_utsname()->sysname, init_utsname()->release,
+ gadget->name);
+
+ return 0;
+-
+-enomem:
+- zero_unbind(gadget);
+- return -ENOMEM;
+ }
+
+-/*-------------------------------------------------------------------------*/
+-
+-static void zero_suspend(struct usb_gadget *gadget)
+-{
+- struct zero_dev *dev = get_gadget_data(gadget);
+-
+- if (gadget->speed == USB_SPEED_UNKNOWN)
+- return;
+-
+- if (autoresume) {
+- mod_timer(&dev->resume, jiffies + (HZ * autoresume));
+- DBG(dev, "suspend, wakeup in %d seconds\n", autoresume);
+- } else
+- DBG(dev, "suspend\n");
+-}
+-
+-static void zero_resume(struct usb_gadget *gadget)
+-{
+- struct zero_dev *dev = get_gadget_data(gadget);
+-
+- DBG(dev, "resume\n");
+- del_timer(&dev->resume);
+-}
+-
+-
+-/*-------------------------------------------------------------------------*/
+-
+-static struct usb_gadget_driver zero_driver = {
+-#ifdef CONFIG_USB_GADGET_DUALSPEED
+- .speed = USB_SPEED_HIGH,
+-#else
+- .speed = USB_SPEED_FULL,
+-#endif
+- .function = (char *) longname,
++static struct usb_composite_driver zero_driver = {
++ .name = "zero",
++ .dev = &device_desc,
++ .strings = dev_strings,
+ .bind = zero_bind,
+- .unbind = __exit_p(zero_unbind),
+-
+- .setup = zero_setup,
+- .disconnect = zero_disconnect,
+-
+- .suspend = zero_suspend,
+- .resume = zero_resume,
+-
+- .driver = {
+- .name = (char *) shortname,
+- .owner = THIS_MODULE,
+- },
+ };
+
+ MODULE_AUTHOR("David Brownell");
+ MODULE_LICENSE("GPL");
+
+-
+ static int __init init(void)
+ {
+- return usb_gadget_register_driver(&zero_driver);
++ return usb_composite_register(&zero_driver);
+ }
+ module_init(init);
+
+ static void __exit cleanup(void)
+ {
+- usb_gadget_unregister_driver(&zero_driver);
++ usb_composite_unregister(&zero_driver);
+ }
+ module_exit(cleanup);
+-
+diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
+new file mode 100644
+index 0000000..c932390
+--- /dev/null
++++ b/include/linux/usb/composite.h
+@@ -0,0 +1,338 @@
++/*
++ * composite.h -- framework for usb gadgets which are composite devices
++ *
++ * Copyright (C) 2006-2008 David Brownell
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software
++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
++ */
++
++#ifndef __LINUX_USB_COMPOSITE_H
++#define __LINUX_USB_COMPOSITE_H
++
++/*
++ * This framework is an optional layer on top of the USB Gadget interface,
++ * making it easier to build (a) Composite devices, supporting multiple
++ * functions within any single configuration, and (b) Multi-configuration
++ * devices, also supporting multiple functions but without necessarily
++ * having more than one function per configuration.
++ *
++ * Example: a device with a single configuration supporting both network
++ * link and mass storage functions is a composite device. Those functions
++ * might alternatively be packaged in individual configurations, but in
++ * the composite model the host can use both functions at the same time.
++ */
++
++#include <linux/usb/ch9.h>
++#include <linux/usb/gadget.h>
++
++
++struct usb_configuration;
++
++/**
++ * struct usb_function - describes one function of a configuration
++ * @name: For diagnostics, identifies the function.
++ * @strings: tables of strings, keyed by identifiers assigned during bind()
++ * and by language IDs provided in control requests
++ * @descriptors: Table of full (or low) speed descriptors, using interface and
++ * string identifiers assigned during @bind(). If this pointer is null,
++ * the function will not be available at full speed (or at low speed).
++ * @hs_descriptors: Table of high speed descriptors, using interface and
++ * string identifiers assigned during @bind(). If this pointer is null,
++ * the function will not be available at high speed.
++ * @config: assigned when @usb_add_function() is called; this is the
++ * configuration with which this function is associated.
++ * @bind: Before the gadget can register, all of its functions bind() to the
++ * available resources including string and interface identifiers used
++ * in interface or class descriptors; endpoints; I/O buffers; and so on.
++ * @unbind: Reverses @bind; called as a side effect of unregistering the
++ * driver which added this function.
++ * @set_alt: (REQUIRED) Reconfigures altsettings; function drivers may
++ * initialize usb_ep.driver data at this time (when it is used).
++ * Note that setting an interface to its current altsetting resets
++ * interface state, and that all interfaces have a disabled state.
++ * @get_alt: Returns the active altsetting. If this is not provided,
++ * then only altsetting zero is supported.
++ * @disable: (REQUIRED) Indicates the function should be disabled. Reasons
++ * include host resetting or reconfiguring the gadget, and disconnection.
++ * @setup: Used for interface-specific control requests.
++ * @suspend: Notifies functions when the host stops sending USB traffic.
++ * @resume: Notifies functions when the host restarts USB traffic.
++ *
++ * A single USB function uses one or more interfaces, and should in most
++ * cases support operation at both full and high speeds. Each function is
++ * associated by @usb_add_function() with a one configuration; that function
++ * causes @bind() to be called so resources can be allocated as part of
++ * setting up a gadget driver. Those resources include endpoints, which
++ * should be allocated using @usb_ep_autoconfig().
++ *
++ * To support dual speed operation, a function driver provides descriptors
++ * for both high and full speed operation. Except in rare cases that don't
++ * involve bulk endpoints, each speed needs different endpoint descriptors.
++ *
++ * Function drivers choose their own strategies for managing instance data.
++ * The simplest strategy just declares it "static', which means the function
++ * can only be activated once. If the function needs to be exposed in more
++ * than one configuration at a given speed, it needs to support multiple
++ * usb_function structures (one for each configuration).
++ *
++ * A more complex strategy might encapsulate a @usb_function structure inside
++ * a driver-specific instance structure to allows multiple activations. An
++ * example of multiple activations might be a CDC ACM function that supports
++ * two or more distinct instances within the same configuration, providing
++ * several independent logical data links to a USB host.
++ */
++struct usb_function {
++ const char *name;
++ struct usb_gadget_strings **strings;
++ struct usb_descriptor_header **descriptors;
++ struct usb_descriptor_header **hs_descriptors;
++
++ struct usb_configuration *config;
++
++ /* REVISIT: bind() functions can be marked __init, which
++ * makes trouble for section mismatch analysis. See if
++ * we can't restructure things to avoid mismatching.
++ * Related: unbind() may kfree() but bind() won't...
++ */
++
++ /* configuration management: bind/unbind */
++ int (*bind)(struct usb_configuration *,
++ struct usb_function *);
++ void (*unbind)(struct usb_configuration *,
++ struct usb_function *);
++
++ /* runtime state management */
++ int (*set_alt)(struct usb_function *,
++ unsigned interface, unsigned alt);
++ int (*get_alt)(struct usb_function *,
++ unsigned interface);
++ void (*disable)(struct usb_function *);
++ int (*setup)(struct usb_function *,
++ const struct usb_ctrlrequest *);
++ void (*suspend)(struct usb_function *);
++ void (*resume)(struct usb_function *);
++
++ /* internals */
++ struct list_head list;
++};
++
++int usb_add_function(struct usb_configuration *, struct usb_function *);
++
++int usb_interface_id(struct usb_configuration *, struct usb_function *);
++
++/**
++ * ep_choose - select descriptor endpoint at current device speed
++ * @g: gadget, connected and running at some speed
++ * @hs: descriptor to use for high speed operation
++ * @fs: descriptor to use for full or low speed operation
++ */
++static inline struct usb_endpoint_descriptor *
++ep_choose(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
++ struct usb_endpoint_descriptor *fs)
++{
++ if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
++ return hs;
++ return fs;
++}
++
++#define MAX_CONFIG_INTERFACES 16 /* arbitrary; max 255 */
++
++/**
++ * struct usb_configuration - represents one gadget configuration
++ * @label: For diagnostics, describes the configuration.
++ * @strings: Tables of strings, keyed by identifiers assigned during @bind()
++ * and by language IDs provided in control requests.
++ * @descriptors: Table of descriptors preceding all function descriptors.
++ * Examples include OTG and vendor-specific descriptors.
++ * @bind: Called from @usb_add_config() to allocate resources unique to this
++ * configuration and to call @usb_add_function() for each function used.
++ * @unbind: Reverses @bind; called as a side effect of unregistering the
++ * driver which added this configuration.
++ * @setup: Used to delegate control requests that aren't handled by standard
++ * device infrastructure or directed at a specific interface.
++ * @bConfigurationValue: Copied into configuration descriptor.
++ * @iConfiguration: Copied into configuration descriptor.
++ * @bmAttributes: Copied into configuration descriptor.
++ * @bMaxPower: Copied into configuration descriptor.
++ * @cdev: assigned by @usb_add_config() before calling @bind(); this is
++ * the device associated with this configuration.
++ *
++ * Configurations are building blocks for gadget drivers structured around
++ * function drivers. Simple USB gadgets require only one function and one
++ * configuration, and handle dual-speed hardware by always providing the same
++ * functionality. Slightly more complex gadgets may have more than one
++ * single-function configuration at a given speed; or have configurations
++ * that only work at one speed.
++ *
++ * Composite devices are, by definition, ones with configurations which
++ * include more than one function.
++ *
++ * The lifecycle of a usb_configuration includes allocation, initialization
++ * of the fields described above, and calling @usb_add_config() to set up
++ * internal data and bind it to a specific device. The configuration's
++ * @bind() method is then used to initialize all the functions and then
++ * call @usb_add_function() for them.
++ *
++ * Those functions would normally be independant of each other, but that's
++ * not mandatory. CDC WMC devices are an example where functions often
++ * depend on other functions, with some functions subsidiary to others.
++ * Such interdependency may be managed in any way, so long as all of the
++ * descriptors complete by the time the composite driver returns from
++ * its bind() routine.
++ */
++struct usb_configuration {
++ const char *label;
++ struct usb_gadget_strings **strings;
++ const struct usb_descriptor_header **descriptors;
++
++ /* REVISIT: bind() functions can be marked __init, which
++ * makes trouble for section mismatch analysis. See if
++ * we can't restructure things to avoid mismatching...
++ */
++
++ /* configuration management: bind/unbind */
++ int (*bind)(struct usb_configuration *);
++ void (*unbind)(struct usb_configuration *);
++ int (*setup)(struct usb_configuration *,
++ const struct usb_ctrlrequest *);
++
++ /* fields in the config descriptor */
++ u8 bConfigurationValue;
++ u8 iConfiguration;
++ u8 bmAttributes;
++ u8 bMaxPower;
++
++ struct usb_composite_dev *cdev;
++
++ /* internals */
++ struct list_head list;
++ struct list_head functions;
++ u8 next_interface_id;
++ unsigned highspeed:1;
++ unsigned fullspeed:1;
++ struct usb_function *interface[MAX_CONFIG_INTERFACES];
++};
++
++int usb_add_config(struct usb_composite_dev *,
++ struct usb_configuration *);
++
++/**
++ * struct usb_composite_driver - groups configurations into a gadget
++ * @name: For diagnostics, identifies the driver.
++ * @dev: Template descriptor for the device, including default device
++ * identifiers.
++ * @strings: tables of strings, keyed by identifiers assigned during bind()
++ * and language IDs provided in control requests
++ * @bind: (REQUIRED) Used to allocate resources that are shared across the
++ * whole device, such as string IDs, and add its configurations using
++ * @usb_add_config(). This may fail by returning a negative errno
++ * value; it should return zero on successful initialization.
++ * @unbind: Reverses @bind(); called as a side effect of unregistering
++ * this driver.
++ *
++ * Devices default to reporting self powered operation. Devices which rely
++ * on bus powered operation should report this in their @bind() method.
++ *
++ * Before returning from @bind, various fields in the template descriptor
++ * may be overridden. These include the idVendor/idProduct/bcdDevice values
++ * normally to bind the appropriate host side driver, and the three strings
++ * (iManufacturer, iProduct, iSerialNumber) normally used to provide user
++ * meaningful device identifiers. (The strings will not be defined unless
++ * they are defined in @dev and @strings.) The correct ep0 maxpacket size
++ * is also reported, as defined by the underlying controller driver.
++ */
++struct usb_composite_driver {
++ const char *name;
++ const struct usb_device_descriptor *dev;
++ struct usb_gadget_strings **strings;
++
++ /* REVISIT: bind() functions can be marked __init, which
++ * makes trouble for section mismatch analysis. See if
++ * we can't restructure things to avoid mismatching...
++ */
++
++ int (*bind)(struct usb_composite_dev *);
++ int (*unbind)(struct usb_composite_dev *);
++};
++
++extern int usb_composite_register(struct usb_composite_driver *);
++extern void usb_composite_unregister(struct usb_composite_driver *);
++
++
++/**
++ * struct usb_composite_device - represents one composite usb gadget
++ * @gadget: read-only, abstracts the gadget's usb peripheral controller
++ * @req: used for control responses; buffer is pre-allocated
++ * @bufsiz: size of buffer pre-allocated in @req
++ * @config: the currently active configuration
++ *
++ * One of these devices is allocated and initialized before the
++ * associated device driver's bind() is called.
++ *
++ * OPEN ISSUE: it appears that some WUSB devices will need to be
++ * built by combining a normal (wired) gadget with a wireless one.
++ * This revision of the gadget framework should probably try to make
++ * sure doing that won't hurt too much.
++ *
++ * One notion for how to handle Wireless USB devices involves:
++ * (a) a second gadget here, discovery mechanism TBD, but likely
++ * needing separate "register/unregister WUSB gadget" calls;
++ * (b) updates to usb_gadget to include flags "is it wireless",
++ * "is it wired", plus (presumably in a wrapper structure)
++ * bandgroup and PHY info;
++ * (c) presumably a wireless_ep wrapping a usb_ep, and reporting
++ * wireless-specific parameters like maxburst and maxsequence;
++ * (d) configurations that are specific to wireless links;
++ * (e) function drivers that understand wireless configs and will
++ * support wireless for (additional) function instances;
++ * (f) a function to support association setup (like CBAF), not
++ * necessarily requiring a wireless adapter;
++ * (g) composite device setup that can create one or more wireless
++ * configs, including appropriate association setup support;
++ * (h) more, TBD.
++ */
++struct usb_composite_dev {
++ struct usb_gadget *gadget;
++ struct usb_request *req;
++ unsigned bufsiz;
++
++ struct usb_configuration *config;
++
++ /* internals */
++ struct usb_device_descriptor desc;
++ struct list_head configs;
++ struct usb_composite_driver *driver;
++ u8 next_string_id;
++
++ spinlock_t lock;
++
++ /* REVISIT use and existence of lock ... */
++};
++
++extern int usb_string_id(struct usb_composite_dev *c);
++
++/* messaging utils */
++#define DBG(d, fmt, args...) \
++ dev_dbg(&(d)->gadget->dev , fmt , ## args)
++#define VDBG(d, fmt, args...) \
++ dev_vdbg(&(d)->gadget->dev , fmt , ## args)
++#define ERROR(d, fmt, args...) \
++ dev_err(&(d)->gadget->dev , fmt , ## args)
++#define WARNING(d, fmt, args...) \
++ dev_warn(&(d)->gadget->dev , fmt , ## args)
++#define INFO(d, fmt, args...) \
++ dev_info(&(d)->gadget->dev , fmt , ## args)
++
++#endif /* __LINUX_USB_COMPOSITE_H */
+diff --git a/include/linux/usb/ehci_def.h b/include/linux/usb/ehci_def.h
+new file mode 100644
+index 0000000..5b88e36
+--- /dev/null
++++ b/include/linux/usb/ehci_def.h
+@@ -0,0 +1,160 @@
++/*
++ * Copyright (c) 2001-2002 by David Brownell
++ *
++ * 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.
++ *
++ * This program is distributed in the hope that it will be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
++ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
++ * for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program; if not, write to the Free Software Foundation,
++ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
++ */
++
++#ifndef __LINUX_USB_EHCI_DEF_H
++#define __LINUX_USB_EHCI_DEF_H
++
++/* EHCI register interface, corresponds to EHCI Revision 0.95 specification */
++
++/* Section 2.2 Host Controller Capability Registers */
++struct ehci_caps {
++ /* these fields are specified as 8 and 16 bit registers,
++ * but some hosts can't perform 8 or 16 bit PCI accesses.
++ */
++ u32 hc_capbase;
++#define HC_LENGTH(p) (((p)>>00)&0x00ff) /* bits 7:0 */
++#define HC_VERSION(p) (((p)>>16)&0xffff) /* bits 31:16 */
++ u32 hcs_params; /* HCSPARAMS - offset 0x4 */
++#define HCS_DEBUG_PORT(p) (((p)>>20)&0xf) /* bits 23:20, debug port? */
++#define HCS_INDICATOR(p) ((p)&(1 << 16)) /* true: has port indicators */
++#define HCS_N_CC(p) (((p)>>12)&0xf) /* bits 15:12, #companion HCs */
++#define HCS_N_PCC(p) (((p)>>8)&0xf) /* bits 11:8, ports per CC */
++#define HCS_PORTROUTED(p) ((p)&(1 << 7)) /* true: port routing */
++#define HCS_PPC(p) ((p)&(1 << 4)) /* true: port power control */
++#define HCS_N_PORTS(p) (((p)>>0)&0xf) /* bits 3:0, ports on HC */
++
++ u32 hcc_params; /* HCCPARAMS - offset 0x8 */
++#define HCC_EXT_CAPS(p) (((p)>>8)&0xff) /* for pci extended caps */
++#define HCC_ISOC_CACHE(p) ((p)&(1 << 7)) /* true: can cache isoc frame */
++#define HCC_ISOC_THRES(p) (((p)>>4)&0x7) /* bits 6:4, uframes cached */
++#define HCC_CANPARK(p) ((p)&(1 << 2)) /* true: can park on async qh */
++#define HCC_PGM_FRAMELISTLEN(p) ((p)&(1 << 1)) /* true: periodic_size changes*/
++#define HCC_64BIT_ADDR(p) ((p)&(1)) /* true: can use 64-bit addr */
++ u8 portroute [8]; /* nibbles for routing - offset 0xC */
++} __attribute__ ((packed));
++
++
++/* Section 2.3 Host Controller Operational Registers */
++struct ehci_regs {
++
++ /* USBCMD: offset 0x00 */
++ u32 command;
++/* 23:16 is r/w intr rate, in microframes; default "8" == 1/msec */
++#define CMD_PARK (1<<11) /* enable "park" on async qh */
++#define CMD_PARK_CNT(c) (((c)>>8)&3) /* how many transfers to park for */
++#define CMD_LRESET (1<<7) /* partial reset (no ports, etc) */
++#define CMD_IAAD (1<<6) /* "doorbell" interrupt async advance */
++#define CMD_ASE (1<<5) /* async schedule enable */
++#define CMD_PSE (1<<4) /* periodic schedule enable */
++/* 3:2 is periodic frame list size */
++#define CMD_RESET (1<<1) /* reset HC not bus */
++#define CMD_RUN (1<<0) /* start/stop HC */
++
++ /* USBSTS: offset 0x04 */
++ u32 status;
++#define STS_ASS (1<<15) /* Async Schedule Status */
++#define STS_PSS (1<<14) /* Periodic Schedule Status */
++#define STS_RECL (1<<13) /* Reclamation */
++#define STS_HALT (1<<12) /* Not running (any reason) */
++/* some bits reserved */
++ /* these STS_* flags are also intr_enable bits (USBINTR) */
++#define STS_IAA (1<<5) /* Interrupted on async advance */
++#define STS_FATAL (1<<4) /* such as some PCI access errors */
++#define STS_FLR (1<<3) /* frame list rolled over */
++#define STS_PCD (1<<2) /* port change detect */
++#define STS_ERR (1<<1) /* "error" completion (overflow, ...) */
++#define STS_INT (1<<0) /* "normal" completion (short, ...) */
++
++ /* USBINTR: offset 0x08 */
++ u32 intr_enable;
++
++ /* FRINDEX: offset 0x0C */
++ u32 frame_index; /* current microframe number */
++ /* CTRLDSSEGMENT: offset 0x10 */
++ u32 segment; /* address bits 63:32 if needed */
++ /* PERIODICLISTBASE: offset 0x14 */
++ u32 frame_list; /* points to periodic list */
++ /* ASYNCLISTADDR: offset 0x18 */
++ u32 async_next; /* address of next async queue head */
++
++ u32 reserved [9];
++
++ /* CONFIGFLAG: offset 0x40 */
++ u32 configured_flag;
++#define FLAG_CF (1<<0) /* true: we'll support "high speed" */
++
++ /* PORTSC: offset 0x44 */
++ u32 port_status [0]; /* up to N_PORTS */
++/* 31:23 reserved */
++#define PORT_WKOC_E (1<<22) /* wake on overcurrent (enable) */
++#define PORT_WKDISC_E (1<<21) /* wake on disconnect (enable) */
++#define PORT_WKCONN_E (1<<20) /* wake on connect (enable) */
++/* 19:16 for port testing */
++#define PORT_LED_OFF (0<<14)
++#define PORT_LED_AMBER (1<<14)
++#define PORT_LED_GREEN (2<<14)
++#define PORT_LED_MASK (3<<14)
++#define PORT_OWNER (1<<13) /* true: companion hc owns this port */
++#define PORT_POWER (1<<12) /* true: has power (see PPC) */
++#define PORT_USB11(x) (((x)&(3<<10)) == (1<<10)) /* USB 1.1 device */
++/* 11:10 for detecting lowspeed devices (reset vs release ownership) */
++/* 9 reserved */
++#define PORT_RESET (1<<8) /* reset port */
++#define PORT_SUSPEND (1<<7) /* suspend port */
++#define PORT_RESUME (1<<6) /* resume it */
++#define PORT_OCC (1<<5) /* over current change */
++#define PORT_OC (1<<4) /* over current active */
++#define PORT_PEC (1<<3) /* port enable change */
++#define PORT_PE (1<<2) /* port enable */
++#define PORT_CSC (1<<1) /* connect status change */
++#define PORT_CONNECT (1<<0) /* device connected */
++#define PORT_RWC_BITS (PORT_CSC | PORT_PEC | PORT_OCC)
++} __attribute__ ((packed));
++
++#define USBMODE 0x68 /* USB Device mode */
++#define USBMODE_SDIS (1<<3) /* Stream disable */
++#define USBMODE_BE (1<<2) /* BE/LE endianness select */
++#define USBMODE_CM_HC (3<<0) /* host controller mode */
++#define USBMODE_CM_IDLE (0<<0) /* idle state */
++
++/* Appendix C, Debug port ... intended for use with special "debug devices"
++ * that can help if there's no serial console. (nonstandard enumeration.)
++ */
++struct ehci_dbg_port {
++ u32 control;
++#define DBGP_OWNER (1<<30)
++#define DBGP_ENABLED (1<<28)
++#define DBGP_DONE (1<<16)
++#define DBGP_INUSE (1<<10)
++#define DBGP_ERRCODE(x) (((x)>>7)&0x07)
++# define DBGP_ERR_BAD 1
++# define DBGP_ERR_SIGNAL 2
++#define DBGP_ERROR (1<<6)
++#define DBGP_GO (1<<5)
++#define DBGP_OUT (1<<4)
++#define DBGP_LEN(x) (((x)>>0)&0x0f)
++ u32 pids;
++#define DBGP_PID_GET(x) (((x)>>16)&0xff)
++#define DBGP_PID_SET(data, tok) (((data)<<8)|(tok))
++ u32 data03;
++ u32 data47;
++ u32 address;
++#define DBGP_EPADDR(dev, ep) (((dev)<<8)|(ep))
++} __attribute__ ((packed));
++
++#endif /* __LINUX_USB_EHCI_DEF_H */
+diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
+index cf468fb..0460a74 100644
+--- a/include/linux/usb/gadget.h
++++ b/include/linux/usb/gadget.h
+@@ -33,7 +33,8 @@ struct usb_ep;
+ * @short_not_ok: When reading data, makes short packets be
+ * treated as errors (queue stops advancing till cleanup).
+ * @complete: Function called when request completes, so this request and
+- * its buffer may be re-used.
++ * its buffer may be re-used. The function will always be called with
++ * interrupts disabled, and it must not sleep.
+ * Reads terminate with a short packet, or when the buffer fills,
+ * whichever comes first. When writes terminate, some data bytes
+ * will usually still be in flight (often in a hardware fifo).
+@@ -271,7 +272,10 @@ static inline void usb_ep_free_request(struct usb_ep *ep,
+ * (Note that some USB device controllers disallow protocol stall responses
+ * in some cases.) When control responses are deferred (the response is
+ * written after the setup callback returns), then usb_ep_set_halt() may be
+- * used on ep0 to trigger protocol stalls.
++ * used on ep0 to trigger protocol stalls. Depending on the controller,
++ * it may not be possible to trigger a status-stage protocol stall when the
++ * data stage is over, that is, from within the response's completion
++ * routine.
+ *
+ * For periodic endpoints, like interrupt or isochronous ones, the usb host
+ * arranges to poll once per interval, and the gadget driver usually will
+@@ -858,6 +862,25 @@ int usb_descriptor_fillbuf(void *, unsigned,
+ int usb_gadget_config_buf(const struct usb_config_descriptor *config,
+ void *buf, unsigned buflen, const struct usb_descriptor_header **desc);
+
++/* copy a NULL-terminated vector of descriptors */
++struct usb_descriptor_header **usb_copy_descriptors(
++ struct usb_descriptor_header **);
++
++/* return copy of endpoint descriptor given original descriptor set */
++struct usb_endpoint_descriptor *usb_find_endpoint(
++ struct usb_descriptor_header **src,
++ struct usb_descriptor_header **copy,
++ struct usb_endpoint_descriptor *match);
++
++/**
++ * usb_free_descriptors - free descriptors returned by usb_copy_descriptors()
++ * @v: vector of descriptors
++ */
++static inline void usb_free_descriptors(struct usb_descriptor_header **v)
++{
++ kfree(v);
++}
++
+ /*-------------------------------------------------------------------------*/
+
+ /* utility wrapping a simple endpoint selection policy */
+diff --git a/include/linux/usb/irda.h b/include/linux/usb/irda.h
+new file mode 100644
+index 0000000..e345cea
+--- /dev/null
++++ b/include/linux/usb/irda.h
+@@ -0,0 +1,151 @@
++/*
++ * USB IrDA Bridge Device Definition
++ */
++
++#ifndef __LINUX_USB_IRDA_H
++#define __LINUX_USB_IRDA_H
++
++/* This device should use Application-specific class */
++
++#define USB_SUBCLASS_IRDA 0x02
++
++/*-------------------------------------------------------------------------*/
++
++/* Class-Specific requests (bRequest field) */
++
++#define USB_REQ_CS_IRDA_RECEIVING 1
++#define USB_REQ_CS_IRDA_CHECK_MEDIA_BUSY 3
++#define USB_REQ_CS_IRDA_RATE_SNIFF 4
++#define USB_REQ_CS_IRDA_UNICAST_LIST 5
++#define USB_REQ_CS_IRDA_GET_CLASS_DESC 6
++
++/*-------------------------------------------------------------------------*/
++
++/* Class-Specific descriptor */
++
++#define USB_DT_CS_IRDA 0x21
++
++/*-------------------------------------------------------------------------*/
++
++/* Data sizes */
++
++#define USB_IRDA_DS_2048 (1 << 5)
++#define USB_IRDA_DS_1024 (1 << 4)
++#define USB_IRDA_DS_512 (1 << 3)
++#define USB_IRDA_DS_256 (1 << 2)
++#define USB_IRDA_DS_128 (1 << 1)
++#define USB_IRDA_DS_64 (1 << 0)
++
++/* Window sizes */
++
++#define USB_IRDA_WS_7 (1 << 6)
++#define USB_IRDA_WS_6 (1 << 5)
++#define USB_IRDA_WS_5 (1 << 4)
++#define USB_IRDA_WS_4 (1 << 3)
++#define USB_IRDA_WS_3 (1 << 2)
++#define USB_IRDA_WS_2 (1 << 1)
++#define USB_IRDA_WS_1 (1 << 0)
++
++/* Min turnaround times in usecs */
++
++#define USB_IRDA_MTT_0 (1 << 7)
++#define USB_IRDA_MTT_10 (1 << 6)
++#define USB_IRDA_MTT_50 (1 << 5)
++#define USB_IRDA_MTT_100 (1 << 4)
++#define USB_IRDA_MTT_500 (1 << 3)
++#define USB_IRDA_MTT_1000 (1 << 2)
++#define USB_IRDA_MTT_5000 (1 << 1)
++#define USB_IRDA_MTT_10000 (1 << 0)
++
++/* Baud rates */
++
++#define USB_IRDA_BR_4000000 (1 << 8)
++#define USB_IRDA_BR_1152000 (1 << 7)
++#define USB_IRDA_BR_576000 (1 << 6)
++#define USB_IRDA_BR_115200 (1 << 5)
++#define USB_IRDA_BR_57600 (1 << 4)
++#define USB_IRDA_BR_38400 (1 << 3)
++#define USB_IRDA_BR_19200 (1 << 2)
++#define USB_IRDA_BR_9600 (1 << 1)
++#define USB_IRDA_BR_2400 (1 << 0)
++
++/* Additional BOFs */
++
++#define USB_IRDA_AB_0 (1 << 7)
++#define USB_IRDA_AB_1 (1 << 6)
++#define USB_IRDA_AB_2 (1 << 5)
++#define USB_IRDA_AB_3 (1 << 4)
++#define USB_IRDA_AB_6 (1 << 3)
++#define USB_IRDA_AB_12 (1 << 2)
++#define USB_IRDA_AB_24 (1 << 1)
++#define USB_IRDA_AB_48 (1 << 0)
++
++/* IRDA Rate Sniff */
++
++#define USB_IRDA_RATE_SNIFF 1
++
++/*-------------------------------------------------------------------------*/
++
++struct usb_irda_cs_descriptor {
++ __u8 bLength;
++ __u8 bDescriptorType;
++
++ __le16 bcdSpecRevision;
++ __u8 bmDataSize;
++ __u8 bmWindowSize;
++ __u8 bmMinTurnaroundTime;
++ __le16 wBaudRate;
++ __u8 bmAdditionalBOFs;
++ __u8 bIrdaRateSniff;
++ __u8 bMaxUnicastList;
++} __attribute__ ((packed));
++
++/*-------------------------------------------------------------------------*/
++
++/* Data Format */
++
++#define USB_IRDA_STATUS_MEDIA_BUSY (1 << 7)
++
++/* The following is a 4-bit value used for both
++ * inbound and outbound headers:
++ *
++ * 0 - speed ignored
++ * 1 - 2400 bps
++ * 2 - 9600 bps
++ * 3 - 19200 bps
++ * 4 - 38400 bps
++ * 5 - 57600 bps
++ * 6 - 115200 bps
++ * 7 - 576000 bps
++ * 8 - 1.152 Mbps
++ * 9 - 5 mbps
++ * 10..15 - Reserved
++ */
++#define USB_IRDA_STATUS_LINK_SPEED 0x0f
++
++/* The following is a 4-bit value used only for
++ * outbound header:
++ *
++ * 0 - No change (BOF ignored)
++ * 1 - 48 BOFs
++ * 2 - 24 BOFs
++ * 3 - 12 BOFs
++ * 4 - 6 BOFs
++ * 5 - 3 BOFs
++ * 6 - 2 BOFs
++ * 7 - 1 BOFs
++ * 8 - 0 BOFs
++ * 9..15 - Reserved
++ */
++#define USB_IRDA_EXTRA_BOFS 0xf0
++
++struct usb_irda_inbound_header {
++ __u8 bmStatus;
++};
++
++struct usb_irda_outbound_header {
++ __u8 bmChange;
++};
++
++#endif /* __LINUX_USB_IRDA_H */
++
+diff --git a/include/linux/usb/musb.h b/include/linux/usb/musb.h
+new file mode 100644
+index 0000000..630962c
+--- /dev/null
++++ b/include/linux/usb/musb.h
+@@ -0,0 +1,98 @@
++/*
++ * This is used to for host and peripheral modes of the driver for
++ * Inventra (Multidrop) Highspeed Dual-Role Controllers: (M)HDRC.
++ *
++ * Board initialization should put one of these into dev->platform_data,
++ * probably on some platform_device named "musb_hdrc". It encapsulates
++ * key configuration differences between boards.
++ */
++
++/* The USB role is defined by the connector used on the board, so long as
++ * standards are being followed. (Developer boards sometimes won't.)
++ */
++enum musb_mode {
++ MUSB_UNDEFINED = 0,
++ MUSB_HOST, /* A or Mini-A connector */
++ MUSB_PERIPHERAL, /* B or Mini-B connector */
++ MUSB_OTG /* Mini-AB connector */
++};
++
++struct clk;
++
++struct musb_hdrc_eps_bits {
++ const char name[16];
++ u8 bits;
++};
++
++struct musb_hdrc_config {
++ /* MUSB configuration-specific details */
++ unsigned multipoint:1; /* multipoint device */
++ unsigned dyn_fifo:1; /* supports dynamic fifo sizing */
++ unsigned soft_con:1; /* soft connect required */
++ unsigned utm_16:1; /* utm data witdh is 16 bits */
++ unsigned big_endian:1; /* true if CPU uses big-endian */
++ unsigned mult_bulk_tx:1; /* Tx ep required for multbulk pkts */
++ unsigned mult_bulk_rx:1; /* Rx ep required for multbulk pkts */
++ unsigned high_iso_tx:1; /* Tx ep required for HB iso */
++ unsigned high_iso_rx:1; /* Rx ep required for HD iso */
++ unsigned dma:1; /* supports DMA */
++ unsigned vendor_req:1; /* vendor registers required */
++
++ u8 num_eps; /* number of endpoints _with_ ep0 */
++ u8 dma_channels; /* number of dma channels */
++ u8 dyn_fifo_size; /* dynamic size in bytes */
++ u8 vendor_ctrl; /* vendor control reg width */
++ u8 vendor_stat; /* vendor status reg witdh */
++ u8 dma_req_chan; /* bitmask for required dma channels */
++ u8 ram_bits; /* ram address size */
++
++ struct musb_hdrc_eps_bits *eps_bits;
++};
++
++struct musb_hdrc_platform_data {
++ /* MUSB_HOST, MUSB_PERIPHERAL, or MUSB_OTG */
++ u8 mode;
++
++ /* for clk_get() */
++ const char *clock;
++
++ /* (HOST or OTG) switch VBUS on/off */
++ int (*set_vbus)(struct device *dev, int is_on);
++
++ /* (HOST or OTG) mA/2 power supplied on (default = 8mA) */
++ u8 power;
++
++ /* (PERIPHERAL) mA/2 max power consumed (default = 100mA) */
++ u8 min_power;
++
++ /* (HOST or OTG) msec/2 after VBUS on till power good */
++ u8 potpgt;
++
++ /* Power the device on or off */
++ int (*set_power)(int state);
++
++ /* Turn device clock on or off */
++ int (*set_clock)(struct clk *clock, int is_on);
++
++ /* MUSB configuration-specific details */
++ struct musb_hdrc_config *config;
++};
++
++
++/* TUSB 6010 support */
++
++#define TUSB6010_OSCCLK_60 16667 /* psec/clk @ 60.0 MHz */
++#define TUSB6010_REFCLK_24 41667 /* psec/clk @ 24.0 MHz XI */
++#define TUSB6010_REFCLK_19 52083 /* psec/clk @ 19.2 MHz CLKIN */
++
++#ifdef CONFIG_ARCH_OMAP2
++
++extern int __init tusb6010_setup_interface(
++ struct musb_hdrc_platform_data *data,
++ unsigned ps_refclk, unsigned waitpin,
++ unsigned async_cs, unsigned sync_cs,
++ unsigned irq, unsigned dmachan);
++
++extern int tusb6010_platform_retime(unsigned is_refclk);
++
++#endif /* OMAP2 */
+diff --git a/include/linux/usb/rndis_host.h b/include/linux/usb/rndis_host.h
+index 29d6458..0a6e6d4 100644
+--- a/include/linux/usb/rndis_host.h
++++ b/include/linux/usb/rndis_host.h
+@@ -260,7 +260,8 @@ struct rndis_keepalive_c { /* IN (optionally OUT) */
+
+
+ extern void rndis_status(struct usbnet *dev, struct urb *urb);
+-extern int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf);
++extern int
++rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen);
+ extern int
+ generic_rndis_bind(struct usbnet *dev, struct usb_interface *intf, int flags);
+ extern void rndis_unbind(struct usbnet *dev, struct usb_interface *intf);
+diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
+index 8f891cb..655341d 100644
+--- a/include/linux/usb/serial.h
++++ b/include/linux/usb/serial.h
+@@ -17,7 +17,8 @@
+ #include <linux/mutex.h>
+
+ #define SERIAL_TTY_MAJOR 188 /* Nice legal number now */
+-#define SERIAL_TTY_MINORS 255 /* loads of devices :) */
++#define SERIAL_TTY_MINORS 254 /* loads of devices :) */
++#define SERIAL_TTY_NO_MINOR 255 /* No minor was assigned */
+
+ /* The maximum number of ports one device can grab at once */
+ #define MAX_NUM_PORTS 8
+@@ -62,7 +63,7 @@
+ */
+ struct usb_serial_port {
+ struct usb_serial *serial;
+- struct tty_struct *tty;
++ struct tty_port port;
+ spinlock_t lock;
+ struct mutex mutex;
+ unsigned char number;
+@@ -89,7 +90,6 @@ struct usb_serial_port {
+
+ wait_queue_head_t write_wait;
+ struct work_struct work;
+- int open_count;
+ char throttled;
+ char throttle_req;
+ char console;
+@@ -217,22 +217,27 @@ struct usb_serial_driver {
+ int (*resume)(struct usb_serial *serial);
+
+ /* serial function calls */
+- int (*open)(struct usb_serial_port *port, struct file *filp);
+- void (*close)(struct usb_serial_port *port, struct file *filp);
+- int (*write)(struct usb_serial_port *port, const unsigned char *buf,
+- int count);
+- int (*write_room)(struct usb_serial_port *port);
+- int (*ioctl)(struct usb_serial_port *port, struct file *file,
++ /* Called by console with tty = NULL and by tty */
++ int (*open)(struct tty_struct *tty,
++ struct usb_serial_port *port, struct file *filp);
++ void (*close)(struct tty_struct *tty,
++ struct usb_serial_port *port, struct file *filp);
++ int (*write)(struct tty_struct *tty, struct usb_serial_port *port,
++ const unsigned char *buf, int count);
++ /* Called only by the tty layer */
++ int (*write_room)(struct tty_struct *tty);
++ int (*ioctl)(struct tty_struct *tty, struct file *file,
+ unsigned int cmd, unsigned long arg);
+- void (*set_termios)(struct usb_serial_port *port, struct ktermios *old);
+- void (*break_ctl)(struct usb_serial_port *port, int break_state);
+- int (*chars_in_buffer)(struct usb_serial_port *port);
+- void (*throttle)(struct usb_serial_port *port);
+- void (*unthrottle)(struct usb_serial_port *port);
+- int (*tiocmget)(struct usb_serial_port *port, struct file *file);
+- int (*tiocmset)(struct usb_serial_port *port, struct file *file,
++ void (*set_termios)(struct tty_struct *tty,
++ struct usb_serial_port *port, struct ktermios *old);
++ void (*break_ctl)(struct tty_struct *tty, int break_state);
++ int (*chars_in_buffer)(struct tty_struct *tty);
++ void (*throttle)(struct tty_struct *tty);
++ void (*unthrottle)(struct tty_struct *tty);
++ int (*tiocmget)(struct tty_struct *tty, struct file *file);
++ int (*tiocmset)(struct tty_struct *tty, struct file *file,
+ unsigned int set, unsigned int clear);
+-
++ /* USB events */
+ void (*read_int_callback)(struct urb *urb);
+ void (*write_int_callback)(struct urb *urb);
+ void (*read_bulk_callback)(struct urb *urb);
+@@ -270,19 +275,19 @@ static inline void usb_serial_console_disconnect(struct usb_serial *serial) {}
+ /* Functions needed by other parts of the usbserial core */
+ extern struct usb_serial *usb_serial_get_by_index(unsigned int minor);
+ extern void usb_serial_put(struct usb_serial *serial);
+-extern int usb_serial_generic_open(struct usb_serial_port *port,
+- struct file *filp);
+-extern int usb_serial_generic_write(struct usb_serial_port *port,
+- const unsigned char *buf, int count);
+-extern void usb_serial_generic_close(struct usb_serial_port *port,
+- struct file *filp);
++extern int usb_serial_generic_open(struct tty_struct *tty,
++ struct usb_serial_port *port, struct file *filp);
++extern int usb_serial_generic_write(struct tty_struct *tty,
++ struct usb_serial_port *port, const unsigned char *buf, int count);
++extern void usb_serial_generic_close(struct tty_struct *tty,
++ struct usb_serial_port *port, struct file *filp);
+ extern int usb_serial_generic_resume(struct usb_serial *serial);
+-extern int usb_serial_generic_write_room(struct usb_serial_port *port);
+-extern int usb_serial_generic_chars_in_buffer(struct usb_serial_port *port);
++extern int usb_serial_generic_write_room(struct tty_struct *tty);
++extern int usb_serial_generic_chars_in_buffer(struct tty_struct *tty);
+ extern void usb_serial_generic_read_bulk_callback(struct urb *urb);
+ extern void usb_serial_generic_write_bulk_callback(struct urb *urb);
+-extern void usb_serial_generic_throttle(struct usb_serial_port *port);
+-extern void usb_serial_generic_unthrottle(struct usb_serial_port *port);
++extern void usb_serial_generic_throttle(struct tty_struct *tty);
++extern void usb_serial_generic_unthrottle(struct tty_struct *tty);
+ extern void usb_serial_generic_shutdown(struct usb_serial *serial);
+ extern int usb_serial_generic_register(int debug);
+ extern void usb_serial_generic_deregister(void);
projects / vuplus_openembedded / commitdiff