linux-handhelds-pxa: move 2.4 specific patches to /obsolete too

Signed-off-by: Andrea Adami <andrea.adami@gmail.com>

4 files changed, 0 insertions, 29559 deletions

diff --git a/recipes/linux/files/linux-2.4-cpufreq.patch b/recipes/linux/files/linux-2.4-cpufreq.patch
deleted file mode 100644
index c3526bb30d..0000000000
--- a/recipes/linux/files/linux-2.4-cpufreq.patch
+++ /dev/null
@@ -1,20 +0,0 @@
-Index: include/linux/cpufreq.h
-===================================================================
-RCS file: /cvs/linux/kernel/include/linux/cpufreq.h,v
-retrieving revision 1.4
-diff -u -r1.4 cpufreq.h
---- linux/include/linux/cpufreq.h	23 Aug 2002 22:18:47 -0000	1.4
-+++ linux/include/linux/cpufreq.h	29 Apr 2004 08:44:18 -0000
-@@ -16,9 +16,9 @@
- #include <linux/notifier.h>
- 
- #ifndef CONFIG_SMP
--#define cpufreq_current(cpu)	((void)(cpu), __cpufreq_cur)
--#define cpufreq_max(cpu)	((void)(cpu), __cpufreq_max)
--#define cpufreq_min(cpu)	((void)(cpu), __cpufreq_min)
-+#define cpufreq_current(cpu)	(__cpufreq_cur)
-+#define cpufreq_max(cpu)	(__cpufreq_max)
-+#define cpufreq_min(cpu)	(__cpufreq_min)
- #else
- /*
-  * Should be something like:
diff --git a/recipes/linux/files/linux-2.4-mmc-debugging.patch b/recipes/linux/files/linux-2.4-mmc-debugging.patch
deleted file mode 100644
index 6cde9e8ed2..0000000000
--- a/recipes/linux/files/linux-2.4-mmc-debugging.patch
+++ /dev/null
@@ -1,15 +0,0 @@
---- kernel/include/linux/mmc/mmc_protocol.h	2005-04-09 17:30:57.930462521 +0200
-+++ /tmp/mmc_protocol.h	2005-04-09 17:30:33.649097537 +0200
-@@ -273,10 +273,10 @@
- #define START_MMC_DEBUG(n) do { if (n <= g_mmc_debug)
- #define END_MMC_DEBUG      } while (0)
- #else
- #define MMC_DEBUG(n, args...)
--#define START_MMC_DEBUG(n)
--#define END_MMC_DEBUG
-+#define START_MMC_DEBUG(n) do { if (0)
-+#define END_MMC_DEBUG      } while (0)
- #endif /* CONFIG_MMC_DEBUG */
- 
- #endif  /* MMC_MMC_PROTOCOL_H */
- 
diff --git a/recipes/linux/files/linux-2.4-no-short-loads.patch b/recipes/linux/files/linux-2.4-no-short-loads.patch
deleted file mode 100644
index f2d6c74224..0000000000
--- a/recipes/linux/files/linux-2.4-no-short-loads.patch
+++ /dev/null
@@ -1,18 +0,0 @@
-Index: arch/arm/Makefile
-===================================================================
-RCS file: /cvs/linux/kernel/arch/arm/Makefile,v
-retrieving revision 1.47
-diff -u -r1.47 Makefile
---- linux/arch/arm/Makefile	9 Jul 2003 14:10:56 -0000	1.47
-+++ linux/arch/arm/Makefile	28 Apr 2004 21:11:04 -0000
-@@ -60,8 +60,8 @@
- tune-$(CONFIG_CPU_XSCALE)	:=-mtune=xscale
- #tune-$(CONFIG_CPU_XSCALE)	:=-mtune=strongarm
- 
--CFLAGS_BOOT	:=$(apcs-y) $(arch-y) $(tune-y) -mshort-load-bytes -msoft-float -Uarm
--CFLAGS		+=$(apcs-y) $(arch-y) $(tune-y) -mshort-load-bytes -msoft-float -Uarm
-+CFLAGS_BOOT	:=$(apcs-y) $(arch-y) $(tune-y) -msoft-float -Uarm
-+CFLAGS		+=$(apcs-y) $(arch-y) $(tune-y) -msoft-float -Uarm
- AFLAGS		+=$(apcs-y) $(arch-y) -msoft-float
- 
- ifeq ($(CONFIG_CPU_26),y)
diff --git a/recipes/linux/files/linux-2.4-usb-gadget.patch b/recipes/linux/files/linux-2.4-usb-gadget.patch
deleted file mode 100644
index 0864ee98f5..0000000000
--- a/recipes/linux/files/linux-2.4-usb-gadget.patch
+++ /dev/null
@@ -1,29506 +0,0 @@
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/Documentation/Configure.help kernel/Documentation/Configure.help
---- /tmp/kernel/Documentation/Configure.help	2005-04-22 17:52:12.265476882 +0200
-+++ kernel/Documentation/Configure.help	2005-04-22 17:57:15.940717930 +0200
-@@ -23701,6 +23701,163 @@
-   brave people.  System crashes and other bad things are likely to occur if
-   you use this driver.  If in doubt, select N.
- 
-+CONFIG_USB_GADGET
-+  USB is a master/slave protocol, organized with one master
-+  host (such as a PC) controlling up to 127 peripheral devices.
-+  The USB hardware is asymmetric, which makes it easier to set up:
-+  you can't connect two "to-the-host" connectors to each other.
-+
-+  Linux can run in the host, or in the peripheral.  In both cases
-+  you need a low level bus controller driver, and some software
-+  talking to it.  Peripheral controllers are often discrete silicon,
-+  or are integrated with the CPU in a microcontroller.  The more
-+  familiar host side controllers have names like like "EHCI", "OHCI",
-+  or "UHCI", and are usually integrated into southbridges on PC
-+  motherboards.
-+
-+  Enable this configuration option if you want to run Linux inside
-+  a USB peripheral device.  Configure one hardware driver for your
-+  peripheral/device side bus controller, and a "gadget driver" for
-+  your peripheral protocol.  (If you use modular gadget drivers,
-+  you may configure more than one.)
-+
-+  If in doubt, say "N" and don't enable these drivers; most people
-+  don't have this kind of hardware (except maybe inside Linux PDAs).
-+
-+CONFIG_USB_GADGET_NET2280
-+  NetChip 2280 is a PCI based USB peripheral controller which
-+  supports both full and high speed USB 2.0 data transfers.  
-+           
-+  It has six configurable endpoints, as well as endpoint zero
-+  (for control transfers) and several endpoints with dedicated
-+  functions.
-+
-+  Say "y" to link the driver statically, or "m" to build a
-+  dynamically linked module called "net2280" and force all
-+  gadget drivers to also be dynamically linked.
-+
-+CONFIG_USB_GADGET_GOKU
-+  The Toshiba TC86C001 is a PCI device which includes controllers
-+  for full speed USB devices, IDE, I2C, SIO, plus a USB host (OHCI).
-+  
-+  The device controller has three configurable (bulk or interrupt)
-+  endpoints, plus endpoint zero (for control transfers).
-+
-+  Say "y" to link the driver statically, or "m" to build a
-+  dynamically linked module called "goku_udc" and force all
-+  gadget drivers to also be dynamically linked.
-+
-+CONFIG_USB_GADGET_PXA2XX
-+  Intel's PXA 2xx series XScale ARM-5TE processors include
-+  an integrated full speed USB 1.1 device controller.
-+
-+  It has fifteen fixed-function endpoints, as well as endpoint
-+  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
-+  gadget drivers to also be dynamically linked.
-+
-+CONFIG_USB_GADGET_SUPERH
-+  Some Renesas SuperH processors (SH7705, SH7727...) include an
-+  integrated high speed USB 1.1 device controller.
-+
-+  It has three fixed-function endpoints, as well as endpoint zero (for
-+  control transfers).
-+
-+  Say "y" to link the driver statically, or "m" to build a
-+  dynamically linked module called "superh_udc" and force all
-+  gadget drivers to also be dynamically linked.
-+
-+CONFIG_USB_ZERO
-+  Gadget Zero is a two-configuration device.  It either sinks and
-+  sources bulk data; or it loops back a configurable number of
-+  transfers.  It also implements control requests, for "chapter 9"
-+  conformance.  The driver needs only two bulk-capable endpoints, so
-+  it can work on top of most device-side usb controllers.  It's
-+  useful for testing, and is also a working example showing how
-+  USB "gadget drivers" can be written.
-+
-+  Make this be the first driver you try using on top of any new
-+  USB peripheral controller driver.  Then you can use host-side
-+  test software, like the "usbtest" driver, to put your hardware
-+  and its driver through a basic set of functional tests.
-+
-+  Gadget Zero also works with the host-side "usb-skeleton" driver,
-+  and with many kinds of host-side test software.  You may need
-+  to tweak product and vendor IDs before host software knows about
-+  this device, and arrange to select an appropriate configuration.
-+
-+  Say "y" to link the driver statically, or "m" to build a
-+  dynamically linked module called "g_zero".
-+
-+CONFIG_USB_ETH
-+  This driver implements Ethernet style communication, in either
-+  of two ways:
-+          
-+   - The "Communication Device Class" (CDC) Ethernet Control Model.
-+     That protocol is often avoided with pure Ethernet adapters, in
-+     favor of simpler vendor-specific hardware, but is widely
-+     supported by firmware for smart network devices.
-+
-+   - On hardware can't implement that protocol, a simpler approach
-+     is used, placing fewer demands on USB.
-+
-+   Within the USB device, this gadget driver exposes a network device
-+   "usbX", where X depends on what other networking devices you have.
-+   Treat it like a two-node Ethernet link:  host, and gadget.
-+
-+   The Linux-USB host-side "usbnet" driver interoperates with this
-+   driver, so that deep I/O queues can be supported.  On 2.4 kernels,
-+   use "CDCEther" instead, if you're using the CDC option. That CDC
-+   mode should also interoperate with standard CDC Ethernet class
-+   drivers on other host operating systems.
-+
-+   Say "y" to link the driver statically, or "m" to build a
-+   dynamically linked module called "g_ether".
-+
-+CONFIG_USB_ETH_RNDIS
-+  Microsoft Windows XP bundles the "Remote NDIS" (RNDIS) protocol,
-+  and Microsoft provides redistributable binary RNDIS drivers for
-+  older versions of Windows.
-+
-+  If you say "y" here, the Ethernet gadget driver will try to provide
-+  a second device configuration, supporting RNDIS to talk to such
-+  Microsoft USB hosts.
-+
-+CONFIG_USB_FILE_STORAGE
-+  The File-backed Storage Gadget acts as a USB Mass Storage
-+  disk drive.  As its storage repository it can use a regular
-+  file or a block device (in much the same way as the "loop"
-+  device driver), specified as a module parameter.
-+
-+CONFIG_USB_FILE_STORAGE_TEST
-+  Say "y" to generate the larger testing version of the
-+  File-backed Storage Gadget, useful for probing the
-+  behavior of USB Mass Storage hosts.  Not needed for
-+  normal operation.
-+
-+CONFIG_USB_ETH_RNDIS
-+  Microsoft Windows XP bundles the "Remote NDIS" (RNDIS) protocol,
-+  and Microsoft provides redistributable binary RNDIS drivers for
-+  older versions of Windows.
-+
-+  If you say "y" here, the Ethernet gadget driver will try to provide
-+  a second device configuration, supporting RNDIS to talk to such
-+  Microsoft USB hosts.
-+
-+CONFIG_USB_FILE_STORAGE
-+  The File-backed Storage Gadget acts as a USB Mass Storage
-+  disk drive.  As its storage repository it can use a regular
-+  file or a block device (in much the same way as the "loop"
-+  device driver), specified as a module parameter.
-+
-+CONFIG_USB_FILE_STORAGE_TEST
-+  Say "y" to generate the larger testing version of the
-+  File-backed Storage Gadget, useful for probing the
-+  behavior of USB Mass Storage hosts.  Not needed for
-+  normal operation.
-+
- Winbond W83977AF IrDA Device Driver
- CONFIG_WINBOND_FIR
-   Say Y here if you want to build IrDA support for the Winbond
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/Makefile kernel/Makefile
---- /tmp/kernel/Makefile	2005-04-22 17:52:12.362461090 +0200
-+++ kernel/Makefile	2005-04-22 17:53:19.374549284 +0200
-@@ -196,6 +196,7 @@
- DRIVERS-$(CONFIG_HAMRADIO) += drivers/net/hamradio/hamradio.o
- DRIVERS-$(CONFIG_TC) += drivers/tc/tc.a
- DRIVERS-$(CONFIG_USB) += drivers/usb/usbdrv.o
-+DRIVERS-$(CONFIG_USB_GADGET) += drivers/usb/gadget/built-in.o
- DRIVERS-$(CONFIG_LAB) += drivers/bootldr/labmod.o
- DRIVERS-$(CONFIG_INPUT) += drivers/input/inputdrv.o
- DRIVERS-$(CONFIG_I2O) += drivers/message/i2o/i2o.o
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/Makefile kernel/drivers/Makefile
---- /tmp/kernel/drivers/Makefile	2005-04-22 17:52:12.728401503 +0200
-+++ kernel/drivers/Makefile	2005-04-22 17:53:19.523525026 +0200
-@@ -27,6 +27,7 @@
- subdir-$(CONFIG_MAC)		+= macintosh
- subdir-$(CONFIG_PPC)		+= macintosh
- subdir-$(CONFIG_USB)		+= usb
-+subdir-$(CONFIG_USB_GADGET)    += usb/gadget
- subdir-$(CONFIG_INPUT)		+= input
- subdir-$(CONFIG_PHONE)		+= telephony
- subdir-$(CONFIG_SGI)		+= sgi
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/Config.in kernel/drivers/usb/Config.in
---- /tmp/kernel/drivers/usb/Config.in	2005-04-22 17:52:20.663109467 +0200
-+++ kernel/drivers/usb/Config.in	2005-04-22 17:53:19.376548959 +0200
-@@ -120,4 +120,7 @@
-    dep_tristate '  USB Auerswald ISDN support (EXPERIMENTAL)' CONFIG_USB_AUERSWALD $CONFIG_USB $CONFIG_EXPERIMENTAL
-    dep_tristate '  Tieman Voyager USB Braille display support (EXPERIMENTAL)' CONFIG_USB_BRLVGER $CONFIG_USB $CONFIG_EXPERIMENTAL
- fi
-+
-+source drivers/usb/gadget/Config.in
-+
- endmenu
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/Config.in kernel/drivers/usb/gadget/Config.in
---- /tmp/kernel/drivers/usb/gadget/Config.in	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/Config.in	2005-04-22 17:53:19.403544563 +0200
-@@ -0,0 +1,128 @@
-+#
-+# USB device-side configuration
-+# for 2.4 kbuild, drivers/usb/gadget/Config.in
-+#
-+# Long term, this likely doesn't all belong in one directory
-+# Plan to split it up eventually.
-+#
-+mainmenu_option next_comment
-+comment 'Support for USB gadgets'
-+
-+tristate 'Support for USB Gadgets' CONFIG_USB_GADGET
-+if [ "$CONFIG_USB_GADGET" = "y" -o "$CONFIG_USB_GADGET" = "m" ]; then
-+  
-+  #
-+  # really want _exactly one_ device controller driver at a time,
-+  # since they control compile options for gadget drivers.
-+  #
-+  choice 'USB Peripheral Controller Driver' "\
-+	Intel-PXA2xx/IXP4xx		CONFIG_USB_GADGET_PXA2XX \
-+	National-N9603/N9604		CONFIG_USB_GADGET_N9604 \
-+	NetChip-2280			CONFIG_USB_GADGET_NET2280 \
-+	Renesas-SH7705/7727		CONFIG_USB_GADGET_SUPERH  \
-+	Toshiba-TC86C001(Goku-S)	CONFIG_USB_GADGET_GOKU \
-+	" NetChip-2280
-+
-+  define_tristate CONFIG_USB_GADGET_CONTROLLER n
-+
-+  if [ "$CONFIG_ARCH_PXA" = "y" -o "$CONFIG_ARCH_IXP425" = "y" ] ; then
-+     if [ "$CONFIG_USB_GADGET_PXA2XX" = "y" ] ; then
-+       define_tristate CONFIG_USB_PXA2XX $CONFIG_USB_GADGET
-+       define_tristate CONFIG_USB_GADGET_CONTROLLER $CONFIG_USB_PXA2XX
-+     fi
-+  fi
-+  if [ "$CONFIG_PCI" = "y" -a "$CONFIG_USB_GADGET_NET2280" = "y" ] ; then
-+    define_tristate CONFIG_USB_NET2280 $CONFIG_USB_GADGET
-+    define_tristate CONFIG_USB_GADGET_CONTROLLER $CONFIG_USB_NET2280
-+  fi
-+  if [ "$CONFIG_SUPERH" = "y" -a "$CONFIG_USB_GADGET_SUPERH" = "y" ] ; then
-+    define_tristate CONFIG_USB_SUPERH $CONFIG_USB_GADGET
-+    define_tristate CONFIG_USB_GADGET_CONTROLLER $CONFIG_USB_SUPERH
-+  fi
-+  if [ "$CONFIG_PCI" = "y" -a "$CONFIG_USB_GADGET_GOKU" = "y" ] ; then
-+    define_tristate CONFIG_USB_GOKU $CONFIG_USB_GADGET
-+    define_tristate CONFIG_USB_GADGET_CONTROLLER $CONFIG_USB_GOKU
-+  fi
-+  if [ "$CONFIG_USB_GADGET_N9604" = "y" ] ; then
-+    define_tristate CONFIG_USB_N9604 $CONFIG_USB_GADGET
-+    define_tristate CONFIG_USB_GADGET_CONTROLLER $CONFIG_USB_N9604
-+  fi
-+
-+  # or any other controller that supports high speed transfers ...
-+  define_bool CONFIG_USB_GADGET_DUALSPEED $CONFIG_USB_GADGET_NET2280
-+
-+  if [ "$CONFIG_USB_GADGET_CONTROLLER" = "y" -o "$CONFIG_USB_GADGET_CONTROLLER" = "m" ] ; then
-+
-+  #
-+  # no reason not to enable more than one gadget driver module, but
-+  # for static linking that would make no sense since the usb model
-+  # has exactly one of these upstream connections and only one
-+  # lowest-level driver can control it.
-+  #
-+  # gadget drivers are compiled to work on specific hardware, since
-+  #
-+  # (a) gadget driver need hardware-specific configuration, like what
-+  #     endpoint names and numbers to use, maxpacket sizes, etc
-+  #
-+  # (b) specific hardware features like iso endpoints may be required
-+  #
-+  comment 'USB Gadget Drivers'
-+
-+  # FIXME when drivers all use #ifdef CONFIG_USB_GADGET_* tests,
-+  # just remove all this driver-specific define_bool logic
-+
-+  dep_tristate '  Gadget Zero (DEVELOPMENT)' CONFIG_USB_ZERO $CONFIG_USB_GADGET_CONTROLLER
-+  dep_tristate '  Ethernet Gadget (EXPERIMENTAL)' CONFIG_USB_ETH $CONFIG_USB_GADGET_CONTROLLER $CONFIG_NET
-+  if [ "$CONFIG_USB_ETH" = "y" -o "$CONFIG_USB_ETH" = "m" ] ; then
-+    bool       '    RNDIS support (EXPERIMENTAL)' CONFIG_USB_ETH_RNDIS
-+  fi
-+  dep_tristate '  Gadget Filesystem API (EXPERIMENTAL)' CONFIG_USB_GADGETFS $CONFIG_USB_GADGET_CONTROLLER
-+  dep_tristate '  File-backed Storage Gadget (DEVELOPMENT)' CONFIG_USB_FILE_STORAGE $CONFIG_USB_GADGET_CONTROLLER
-+  dep_mbool '    File-backed Storage Gadget test mode' CONFIG_USB_FILE_STORAGE_TEST $CONFIG_USB_FILE_STORAGE
-+  dep_tristate '  Serial Gadget (EXPERIMENTAL)' CONFIG_USB_G_SERIAL $CONFIG_USB_GADGET_CONTROLLER
-+  
-+
-+    # enforce the "only one statically linked gadget driver" rule
-+
-+    if [ "$CONFIG_USB_ZERO" = "y" ]; then
-+      # zero = y
-+      define_tristate CONFIG_USB_ETH n
-+      define_tristate CONFIG_USB_GADGETFS n
-+      define_tristate CONFIG_USB_FILE_STORAGE n
-+      define_tristate CONFIG_USB_G_SERIAL n
-+    fi
-+
-+    if [ "$CONFIG_USB_ETH" = "y" ]; then
-+      define_tristate CONFIG_USB_ZERO n
-+      # eth = y
-+      define_tristate CONFIG_USB_GADGETFS n
-+      define_tristate CONFIG_USB_FILE_STORAGE n
-+      define_tristate CONFIG_USB_G_SERIAL n
-+    fi
-+
-+    if [ "$CONFIG_USB_GADGETFS" = "y" ]; then
-+      define_tristate CONFIG_USB_ZERO n
-+      define_tristate CONFIG_USB_ETH n
-+      # gadgetfs = y
-+      define_tristate CONFIG_USB_FILE_STORAGE n
-+      define_tristate CONFIG_USB_G_SERIAL n
-+    fi
-+
-+    if [ "$CONFIG_USB_FILE_STORAGE" = "y" ]; then
-+      define_tristate CONFIG_USB_ZERO n
-+      define_tristate CONFIG_USB_ETH n
-+      define_tristate CONFIG_USB_GADGETFS n
-+      # file_storage = y
-+      define_tristate CONFIG_USB_G_SERIAL n
-+    fi
-+
-+    if [ "$CONFIG_USB_G_SERIAL" = "y" ]; then
-+      define_tristate CONFIG_USB_ZERO n
-+      define_tristate CONFIG_USB_ETH n
-+      define_tristate CONFIG_USB_GADGETFS n
-+      define_tristate CONFIG_USB_FILE_STORAGE n
-+      # g_serial = y
-+    fi
-+  fi
-+fi
-+endmenu
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/Makefile kernel/drivers/usb/gadget/Makefile
---- /tmp/kernel/drivers/usb/gadget/Makefile	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/Makefile	2005-04-22 17:53:19.405544237 +0200
-@@ -0,0 +1,58 @@
-+#
-+# Makefile for USB peripheral controller and gadget drivers
-+# for kbuild 2.4
-+#
-+
-+# for static linking
-+O_TARGET	:= built-in.o
-+
-+list-multi			:= g_zero.o g_ether.o gadgetfs.o g_file_storage.o g_serial.o
-+
-+obj-$(CONFIG_USB_NET2280)	+= net2280.o
-+obj-$(CONFIG_USB_PXA2XX)	+= pxa2xx_udc.o
-+obj-$(CONFIG_USB_GOKU)		+= goku_udc.o
-+obj-$(CONFIG_USB_SUPERH)	+= superh_udc.o
-+obj-$(CONFIG_USB_N9604)		+= n9604.o
-+
-+# only one of these may be statically linked ...
-+controller-$(CONFIG_USB_NET2280)	+= net2280.o
-+controller-$(CONFIG_USB_PXA2XX)		+= pxa2xx_udc.o
-+controller-$(CONFIG_USB_GOKU)		+= goku_udc.o
-+controller-$(CONFIG_USB_SUPERH)		+= superh_udc.o
-+controller-$(CONFIG_USB_N9604)		+= n9604.o
-+
-+# ... and only one of these, too; kbuild/kconfig don't help though.
-+g_zero-objs			:= zero.o usbstring.o config.o epautoconf.o
-+obj-$(CONFIG_USB_ZERO)		+= g_zero.o
-+
-+g_ether-objs			:= ether.o usbstring.o config.o epautoconf.o
-+obj-$(CONFIG_USB_ETH)		+= g_ether.o
-+
-+ifeq ($(CONFIG_USB_ETH_RNDIS),y)
-+	g_ether-objs		+= rndis.o
-+endif
-+
-+gadgetfs-objs			:= inode.o usbstring.o
-+obj-$(CONFIG_USB_GADGETFS)	+= gadgetfs.o
-+
-+g_file_storage-objs		:= file_storage.o usbstring.o config.o \
-+						epautoconf.o
-+obj-$(CONFIG_USB_FILE_STORAGE)	+= g_file_storage.o
-+
-+g_serial-objs			:= gserial.o usbstring.o epautoconf.o
-+obj-$(CONFIG_USB_G_SERIAL)	+= g_serial.o
-+
-+export-objs :=			$(controller-y) $(controller-m)
-+
-+include $(TOPDIR)/Rules.make
-+
-+g_zero.o: $(g_zero-objs)
-+	$(LD) -r -o $@ $(g_zero-objs)
-+g_ether.o: $(g_ether-objs)
-+	$(LD) -r -o $@ $(g_ether-objs)
-+gadgetfs.o: $(gadgetfs-objs)
-+	$(LD) -r -o $@ $(gadgetfs-objs)
-+g_file_storage.o: $(g_file_storage-objs)
-+	$(LD) -r -o $@ $(g_file_storage-objs)
-+g_serial.o: $(g_serial-objs)
-+	$(LD) -r -o $@ $(g_serial-objs)
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/config.c kernel/drivers/usb/gadget/config.c
---- /tmp/kernel/drivers/usb/gadget/config.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/config.c	2005-04-22 17:53:19.408543749 +0200
-@@ -0,0 +1,116 @@
-+/*
-+ * usb/gadget/config.c -- simplify building config descriptors
-+ *
-+ * 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
-+ */
-+
-+#include <linux/errno.h>
-+#include <linux/kernel.h>
-+#include <linux/list.h>
-+#include <linux/string.h>
-+#include <asm/byteorder.h>
-+
-+#include <linux/usb_ch9.h>
-+
-+
-+/**
-+ * usb_descriptor_fillbuf - fill buffer with descriptors
-+ * @buf: Buffer to be filled
-+ * @buflen: Size of buf
-+ * @src: Array of descriptor pointers, terminated by null pointer.
-+ *
-+ * Copies descriptors into the buffer, returning the length or a
-+ * negative error code if they can't all be copied.  Useful when
-+ * assembling descriptors for an associated set of interfaces used
-+ * as part of configuring a composite device; or in other cases where
-+ * sets of descriptors need to be marshaled.
-+ */
-+int
-+usb_descriptor_fillbuf(void *buf, unsigned buflen,
-+		const struct usb_descriptor_header **src)
-+{
-+	u8	*dest = buf;
-+
-+	if (!src)
-+		return -EINVAL;
-+
-+	/* fill buffer from src[] until null descriptor ptr */
-+	for (; 0 != *src; src++) {
-+		unsigned		len = (*src)->bLength;
-+
-+		if (len > buflen)
-+			return -EINVAL;
-+		memcpy(dest, *src, len);
-+		buflen -= len;
-+		dest += len;
-+	}
-+	return dest - (u8 *)buf;
-+}
-+
-+
-+/**
-+ * usb_gadget_config_buf - builts a complete configuration descriptor
-+ * @config: Header for the descriptor, including characteristics such
-+ *	as power requirements and number of interfaces.
-+ * @desc: Null-terminated vector of pointers to the descriptors (interface,
-+ *	endpoint, etc) defining all functions in this device configuration.
-+ * @buf: Buffer for the resulting configuration descriptor.
-+ * @length: Length of buffer.  If this is not big enough to hold the
-+ *	entire configuration descriptor, an error code will be returned.
-+ *
-+ * This copies descriptors into the response buffer, building a descriptor
-+ * for that configuration.  It returns the buffer length or a negative
-+ * status code.  The config.wTotalLength field is set to match the length
-+ * of the result, but other descriptor fields (including power usage and
-+ * interface count) must be set by the caller.
-+ *
-+ * Gadget drivers could use this when constructing a config descriptor
-+ * in response to USB_REQ_GET_DESCRIPTOR.  They will need to patch the
-+ * resulting bDescriptorType value if USB_DT_OTHER_SPEED_CONFIG is needed.
-+ */
-+int usb_gadget_config_buf(
-+	const struct usb_config_descriptor	*config,
-+	void					*buf,
-+	unsigned				length,
-+	const struct usb_descriptor_header	**desc
-+)
-+{
-+	struct usb_config_descriptor		*cp = buf;
-+	int					len;
-+
-+	/* config descriptor first */
-+	if (length < USB_DT_CONFIG_SIZE || !desc)
-+		return -EINVAL;
-+	*cp = *config; 
-+
-+	/* then interface/endpoint/class/vendor/... */
-+	len = usb_descriptor_fillbuf(USB_DT_CONFIG_SIZE + (u8*)buf,
-+			length - USB_DT_CONFIG_SIZE, desc);
-+	if (len < 0)
-+		return len;
-+	len += USB_DT_CONFIG_SIZE;
-+	if (len > 0xffff)
-+		return -EINVAL;
-+
-+	/* patch up the config descriptor */
-+	cp->bLength = USB_DT_CONFIG_SIZE;
-+	cp->bDescriptorType = USB_DT_CONFIG;
-+	cp->wTotalLength = cpu_to_le16(len);
-+	cp->bmAttributes |= USB_CONFIG_ATT_ONE;
-+	return len;
-+}
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/epautoconf.c kernel/drivers/usb/gadget/epautoconf.c
---- /tmp/kernel/drivers/usb/gadget/epautoconf.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/epautoconf.c	2005-04-22 17:53:19.410543423 +0200
-@@ -0,0 +1,311 @@
-+/*
-+ * epautoconf.c -- endpoint autoconfiguration for usb gadget drivers
-+ *
-+ * Copyright (C) 2004 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
-+ *
-+ */
-+
-+#include <linux/kernel.h>
-+#include <linux/init.h>
-+#include <linux/types.h>
-+#include <linux/list.h>
-+#include <linux/errno.h>
-+#include <linux/ctype.h>
-+#include <linux/string.h>
-+#include <linux/usb_ch9.h>
-+#include <linux/usb_gadget.h>
-+
-+#include <asm/byteorder.h>
-+
-+#include "gadget_chips.h"
-+
-+
-+/* we must assign addresses for configurable endpoints (like net2280) */
-+static __initdata unsigned epnum;
-+
-+// #define MANY_ENDPOINTS
-+#ifdef MANY_ENDPOINTS
-+/* more than 15 configurable endpoints */
-+static __initdata unsigned in_epnum;
-+#endif
-+
-+
-+/*
-+ * This should work with endpoints from controller drivers sharing the
-+ * same endpoint naming convention.  By example:
-+ *
-+ *	- ep1, ep2, ... address is fixed, not direction or type
-+ *	- ep1in, ep2out, ... address and direction are fixed, not type
-+ *	- ep1-bulk, ep2-bulk, ... address and type are fixed, not direction
-+ *	- ep1in-bulk, ep2out-iso, ... all three are fixed
-+ *	- ep-* ... no functionality restrictions
-+ *
-+ * Type suffixes are "-bulk", "-iso", or "-int".  Numbers are decimal.
-+ * Less common restrictions are implied by gadget_is_*().
-+ *
-+ * NOTE:  each endpoint is unidirectional, as specified by its USB
-+ * descriptor; and isn't specific to a configuration or altsetting.
-+ */
-+static int __init
-+ep_matches (
-+	struct usb_gadget		*gadget,
-+	struct usb_ep			*ep,
-+	struct usb_endpoint_descriptor	*desc
-+)
-+{
-+	u8		type;
-+	const char	*tmp;
-+	u16		max;
-+
-+	/* endpoint already claimed? */
-+	if (0 != ep->driver_data)
-+		return 0;
-+		
-+	/* only support ep0 for portable CONTROL traffic */
-+	type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
-+	if (USB_ENDPOINT_XFER_CONTROL == type)
-+		return 0;
-+
-+	/* some other naming convention */
-+	if ('e' != ep->name[0])
-+		return 0;
-+
-+	/* type-restriction:  "-iso", "-bulk", or "-int".
-+	 * direction-restriction:  "in", "out".
-+	 */
-+	if ('-' != ep->name[2]) {
-+		tmp = strrchr (ep->name, '-');
-+		if (tmp) {
-+			switch (type) {
-+			case USB_ENDPOINT_XFER_INT:
-+				/* bulk endpoints handle interrupt transfers,
-+				 * except the toggle-quirky iso-synch kind
-+				 */
-+				if ('s' == tmp[2])	// == "-iso"
-+					return 0;
-+				/* for now, avoid PXA "interrupt-in";
-+				 * it's documented as never using DATA1.
-+				 */
-+				if (gadget_is_pxa (gadget)
-+						&& 'i' == tmp [1])
-+					return 0;
-+				break;
-+			case USB_ENDPOINT_XFER_BULK:
-+				if ('b' != tmp[1])	// != "-bulk"
-+					return 0;
-+				break;
-+			case USB_ENDPOINT_XFER_ISOC:
-+				if ('s' != tmp[2])	// != "-iso"
-+					return 0;
-+			}
-+		} else {
-+			tmp = ep->name + strlen (ep->name);
-+		}
-+
-+		/* direction-restriction:  "..in-..", "out-.." */
-+		tmp--;
-+		if (!isdigit (*tmp)) {
-+			if (desc->bEndpointAddress & USB_DIR_IN) {
-+				if ('n' != *tmp)
-+					return 0;
-+			} else {
-+				if ('t' != *tmp)
-+					return 0;
-+			}
-+		}
-+	}
-+
-+	/* endpoint maxpacket size is an input parameter, except for bulk
-+	 * where it's an output parameter representing the full speed limit.
-+	 * the usb spec fixes high speed bulk maxpacket at 512 bytes.
-+	 */
-+	max = 0x7ff & le16_to_cpup (&desc->wMaxPacketSize);
-+	switch (type) {
-+	case USB_ENDPOINT_XFER_INT:
-+		/* INT:  limit 64 bytes full speed, 1024 high speed */
-+		if (!gadget->is_dualspeed && max > 64)
-+			return 0;
-+		/* FALLTHROUGH */
-+
-+	case USB_ENDPOINT_XFER_ISOC:
-+		/* ISO:  limit 1023 bytes full speed, 1024 high speed */
-+		if (ep->maxpacket < max)
-+			return 0;
-+		if (!gadget->is_dualspeed && max > 1023)
-+			return 0;
-+
-+		/* BOTH:  "high bandwidth" works only at high speed */
-+		if ((desc->wMaxPacketSize & __constant_cpu_to_le16(3<<11))) {
-+			if (!gadget->is_dualspeed)
-+				return 0;
-+			/* configure your hardware with enough buffering!! */
-+		}
-+		break;
-+	}
-+
-+	/* MATCH!! */
-+
-+	/* report address */
-+	if (isdigit (ep->name [2])) {
-+		u8	num = simple_strtol (&ep->name [2], NULL, 10);
-+		desc->bEndpointAddress |= num;
-+#ifdef	MANY_ENDPOINTS
-+	} else if (desc->bEndpointAddress & USB_DIR_IN) {
-+		if (++in_epnum > 15)
-+			return 0;
-+		desc->bEndpointAddress = USB_DIR_IN | in_epnum;
-+#endif
-+	} else {
-+		if (++epnum > 15)
-+			return 0;
-+		desc->bEndpointAddress |= epnum;
-+	}
-+
-+	/* report (variable) full speed bulk maxpacket */
-+	if (USB_ENDPOINT_XFER_BULK == type) {
-+		int size = ep->maxpacket;
-+
-+		/* min() doesn't work on bitfields with gcc-3.5 */
-+		if (size > 64)
-+			size = 64;
-+		desc->wMaxPacketSize = cpu_to_le16(size);
-+	}
-+	return 1;
-+}
-+
-+static struct usb_ep * __init
-+find_ep (struct usb_gadget *gadget, const char *name)
-+{
-+	struct usb_ep	*ep;
-+
-+	list_for_each_entry (ep, &gadget->ep_list, ep_list) {
-+		if (0 == strcmp (ep->name, name))
-+			return ep;
-+	}
-+	return NULL;
-+}
-+
-+/**
-+ * usb_ep_autoconfig - choose an endpoint matching the descriptor
-+ * @gadget: The device to which the endpoint must belong.
-+ * @desc: Endpoint descriptor, with endpoint direction and transfer mode
-+ *	initialized.  For periodic transfers, the maximum packet
-+ *	size must also be initialized.  This is modified on success.
-+ *
-+ * By choosing an endpoint to use with the specified descriptor, this
-+ * routine simplifies writing gadget drivers that work with multiple
-+ * USB device controllers.  The endpoint would be passed later to
-+ * usb_ep_enable(), along with some descriptor.
-+ *
-+ * That second descriptor won't always be the same as the first one.
-+ * For example, isochronous endpoints can be autoconfigured for high
-+ * bandwidth, and then used in several lower bandwidth altsettings.
-+ * Also, high and full speed descriptors will be different.
-+ *
-+ * Be sure to examine and test the results of autoconfiguration on your
-+ * hardware.  This code may not make the best choices about how to use the
-+ * USB controller, and it can't know all the restrictions that may apply.
-+ * Some combinations of driver and hardware won't be able to autoconfigure.
-+ *
-+ * On success, this returns an un-claimed usb_ep, and modifies the endpoint
-+ * descriptor bEndpointAddress.  For bulk endpoints, the wMaxPacket value
-+ * is initialized as if the endpoint were used at full speed.  To prevent
-+ * the endpoint from being returned by a later autoconfig call, claim it
-+ * by assigning ep->driver_data to some non-null value.
-+ *
-+ * On failure, this returns a null endpoint descriptor.
-+ */
-+struct usb_ep * __init usb_ep_autoconfig (
-+	struct usb_gadget		*gadget,
-+	struct usb_endpoint_descriptor	*desc
-+)
-+{
-+	struct usb_ep	*ep;
-+	u8		type;
-+
-+	type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
-+
-+	/* First, apply chip-specific "best usage" knowledge.
-+	 * This might make a good usb_gadget_ops hook ...
-+	 */
-+	if (gadget_is_net2280 (gadget) && type == USB_ENDPOINT_XFER_INT) {
-+		/* ep-e, ep-f are PIO with only 64 byte fifos */
-+		ep = find_ep (gadget, "ep-e");
-+		if (ep && ep_matches (gadget, ep, desc))
-+			return ep;
-+		ep = find_ep (gadget, "ep-f");
-+		if (ep && ep_matches (gadget, ep, desc))
-+			return ep;
-+
-+	} else if (gadget_is_goku (gadget)) {
-+		if (USB_ENDPOINT_XFER_INT == type) {
-+			/* single buffering is enough */
-+			ep = find_ep (gadget, "ep3-bulk");
-+			if (ep && ep_matches (gadget, ep, desc))
-+				return ep;
-+		} else if (USB_ENDPOINT_XFER_BULK == type
-+				&& (USB_DIR_IN & desc->bEndpointAddress)) {
-+			/* DMA may be available */
-+			ep = find_ep (gadget, "ep2-bulk");
-+			if (ep && ep_matches (gadget, ep, desc))
-+				return ep;
-+		}
-+
-+	} else if (gadget_is_sh (gadget) && USB_ENDPOINT_XFER_INT == type) {
-+		/* single buffering is enough; maybe 8 byte fifo is too */
-+		ep = find_ep (gadget, "ep3in-bulk");
-+		if (ep && ep_matches (gadget, ep, desc))
-+			return ep;
-+
-+	} else if (gadget_is_mq11xx (gadget) && USB_ENDPOINT_XFER_INT == type) {
-+		ep = find_ep (gadget, "ep1-bulk");
-+		if (ep && ep_matches (gadget, ep, desc))
-+			return ep;
-+	}
-+
-+	/* Second, look at endpoints until an unclaimed one looks usable */ 
-+	list_for_each_entry (ep, &gadget->ep_list, ep_list) {
-+		if (ep_matches (gadget, ep, desc))
-+			return ep;
-+	}
-+
-+	/* Fail */
-+	return NULL;
-+}
-+
-+/**
-+ * usb_ep_autoconfig_reset - reset endpoint autoconfig state
-+ * @gadget: device for which autoconfig state will be reset
-+ *
-+ * Use this for devices where one configuration may need to assign
-+ * endpoint resources very differently from the next one.  It clears
-+ * state such as ep->driver_data and the record of assigned endpoints
-+ * used by usb_ep_autoconfig().
-+ */
-+void __init usb_ep_autoconfig_reset (struct usb_gadget *gadget)
-+{
-+	struct usb_ep	*ep;
-+
-+	list_for_each_entry (ep, &gadget->ep_list, ep_list) {
-+		ep->driver_data = NULL;
-+	}
-+#ifdef	MANY_ENDPOINTS
-+	in_epnum = 0;
-+#endif
-+	epnum = 0;
-+}
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/ether.c kernel/drivers/usb/gadget/ether.c
---- /tmp/kernel/drivers/usb/gadget/ether.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/ether.c	2005-04-22 18:01:31.044861540 +0200
-@@ -0,0 +1,2734 @@
-+/*
-+ * ether.c -- Ethernet gadget driver, with CDC and non-CDC options
-+ *
-+ * Copyright (C) 2003-2005 David Brownell
-+ * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
-+ *
-+ * 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 DEBUG 1
-+// #define VERBOSE
-+
-+#include <linux/config.h>
-+#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/uts.h>
-+#include <linux/version.h>
-+#include <linux/moduleparam.h>
-+#include <linux/ctype.h>
-+
-+#include <asm/byteorder.h>
-+#include <asm/io.h>
-+#include <asm/irq.h>
-+#include <asm/system.h>
-+#include <asm/uaccess.h>
-+#include <asm/unaligned.h>
-+
-+#include <linux/usb_ch9.h>
-+#include <linux/usb_cdc.h>
-+#include <linux/usb_gadget.h>
-+
-+#include <linux/random.h>
-+#include <linux/netdevice.h>
-+#include <linux/etherdevice.h>
-+#include <linux/ethtool.h>
-+
-+#include "gadget_chips.h"
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ * Ethernet gadget driver -- with CDC and non-CDC options
-+ * Builds on hardware support for a full duplex link.
-+ *
-+ * CDC Ethernet is the standard USB solution for sending Ethernet frames
-+ * using USB.  Real hardware tends to use the same framing protocol but look
-+ * different for control features.  This driver strongly prefers to use
-+ * 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
-+ * implement a "minimalist" vendor-agnostic CDC core:  same framing, but
-+ * link-level setup only requires activating the configuration.
-+ * Linux supports it, but other host operating systems may not.
-+ * (This is a subset of CDC Ethernet.)
-+ *
-+ * 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.
-+ */
-+
-+#define DRIVER_DESC		"Ethernet Gadget"
-+#define DRIVER_VERSION		"Equinox 2004"
-+
-+static const char shortname [] = "ether";
-+static const char driver_desc [] = DRIVER_DESC;
-+
-+#define RX_EXTRA	20		/* guard against rx overflows */
-+
-+#ifdef	CONFIG_USB_ETH_RNDIS
-+#include "rndis.h"
-+#else
-+#define rndis_init() 0
-+#define rndis_exit() do{}while(0)
-+#endif
-+
-+/* 2.6-compat */
-+#ifndef container_of
-+#define container_of	list_entry
-+#endif
-+
-+/** PO: really needed? */
-+#include <linux/tqueue.h>
-+#define	work_struct		tq_struct
-+#define	INIT_WORK		INIT_TQUEUE
-+#define schedule_work		schedule_task
-+#define	flush_scheduled_work	flush_scheduled_tasks
-+
-+static void random_ether_addr (u8 *addr)
-+{
-+	get_random_bytes (addr, ETH_ALEN);
-+	addr [0] &= 0xfe;	// clear multicast bit
-+	addr [0] |= 0x02;	// set local assignment bit (IEEE802)
-+}
-+
-+/* CDC and RNDIS support the same host-chosen outgoing packet filters. */
-+#define	DEFAULT_FILTER	(USB_CDC_PACKET_TYPE_BROADCAST \
-+ 			|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;
-+	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.
-+ *
-+ * It also ASSUMES a self-powered device, without remote wakeup,
-+ * although remote wakeup support would make sense.
-+ */
-+static const char *EP_IN_NAME;
-+static const char *EP_OUT_NAME;
-+static const char *EP_STATUS_NAME;
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* 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 CDC Ethernet configurations.
-+ */
-+#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
-+ * with pxa250.  We're protocol-compatible, if the host-side drivers
-+ * use the endpoint descriptors.  bcdDevice (version) is nonzero, so
-+ * drivers that need to hard-wire endpoint numbers have a hook.
-+ *
-+ * The protocol is a minimal subset of CDC Ether, which works on any bulk
-+ * hardware that's not deeply broken ... even on hardware that can't talk
-+ * RNDIS (like SA-1100, with no interrupt endpoint, or anything that
-+ * doesn't handle control-OUT).
-+ */
-+#define	SIMPLE_VENDOR_NUM	0x049f
-+#define	SIMPLE_PRODUCT_NUM	0x505a
-+
-+/* For hardware that can talk RNDIS and either of the above protocols,
-+ * use this ID ... the windows INF files will know it.  Unless it's
-+ * used with CDC Ethernet, Linux 2.4 hosts will need updates to choose
-+ * the non-RNDIS configuration.
-+ */
-+#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 __initdata idVendor;
-+MODULE_PARM(idVendor, "h");
-+MODULE_PARM_DESC(idVendor, "USB Vendor ID");
-+
-+static ushort __initdata idProduct;
-+MODULE_PARM(idProduct, "h");
-+MODULE_PARM_DESC(idProduct, "USB Product ID");
-+
-+static ushort __initdata bcdDevice;
-+MODULE_PARM(bcdDevice, "h");
-+MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
-+
-+static char *__initdata iManufacturer;
-+MODULE_PARM(iManufacturer, "s");
-+MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
-+
-+static char *__initdata iProduct;
-+MODULE_PARM(iProduct, "s");
-+MODULE_PARM_DESC(iProduct, "USB Product string");
-+
-+/* initial value, changed by "ifconfig usb0 hw ether xx:xx:xx:xx:xx:xx" */
-+static char *__initdata dev_addr;
-+MODULE_PARM(dev_addr, "s");
-+MODULE_PARM_DESC(dev_addr, "Device Ethernet Address");
-+
-+/* this address is invisible to ifconfig */
-+static char *__initdata host_addr;
-+MODULE_PARM(host_addr, "s");
-+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_PXA27X
-+#define DEV_CONFIG_CDC
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_AT91
-+#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_SH
-+#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_S3C2410
-+#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
-+
-+static unsigned qmult = 5;
-+MODULE_PARM(qmult, "i");
-+
-+
-+/* for dual-speed hardware, use deeper queues at highspeed */
-+#define qlen(gadget) \
-+	(DEFAULT_QLEN*((gadget->speed == USB_SPEED_HIGH) ? qmult : 1))
-+
-+/* also defer IRQs on highspeed TX */
-+#define TX_DELAY	qmult
-+
-+#define	BITRATE(g)	(((g)->speed == USB_SPEED_HIGH) ? HS_BPS : FS_BPS)
-+
-+#else	/* full speed (low speed doesn't do bulk) */
-+#define qlen(gadget) DEFAULT_QLEN
-+
-+#define	BITRATE(g)	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
-+#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 USB_BUFSIZ	256		/* holds our biggest descriptor */
-+
-+/*
-+ * 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 = {
-+	.bLength =		sizeof device_desc,
-+	.bDescriptorType =	USB_DT_DEVICE,
-+
-+	.bcdUSB =		__constant_cpu_to_le16 (0x0200),
-+
-+	.bDeviceClass =		USB_CLASS_COMM,
-+	.bDeviceSubClass =	0,
-+	.bDeviceProtocol =	0,
-+
-+	.idVendor =		__constant_cpu_to_le16 (CDC_VENDOR_NUM),
-+	.idProduct =		__constant_cpu_to_le16 (CDC_PRODUCT_NUM),
-+	.iManufacturer =	STRING_MANUFACTURER,
-+	.iProduct =		STRING_PRODUCT,
-+	.bNumConfigurations =	1,
-+};
-+
-+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.
-+ */
-+
-+#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
-+
-+#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
-+
-+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),
-+};
-+
-+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 struct usb_cdc_acm_descriptor acm_descriptor = {
-+	.bLength =  		sizeof acm_descriptor,
-+	.bDescriptorType = 	USB_DT_CS_INTERFACE,
-+	.bDescriptorSubType = 	USB_CDC_ACM_TYPE,
-+
-+	.bmCapabilities = 	0x00,
-+};
-+
-+#endif
-+
-+#ifdef	DEV_CONFIG_CDC
-+
-+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,
-+};
-+
-+#endif
-+
-+#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 cancelation; 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.
-+ */
-+
-+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_VENDOR_SPEC,
-+	.bInterfaceSubClass =	0,
-+	.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,
-+};
-+
-+static const struct usb_descriptor_header *fs_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 *) &ether_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
-+	fs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
-+	fs_eth_function[2] = (struct usb_descriptor_header *) &fs_source_desc;
-+	fs_eth_function[3] = (struct usb_descriptor_header *) &fs_sink_desc;
-+	fs_eth_function[4] = 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
-+
-+#ifdef	CONFIG_USB_GADGET_DUALSPEED
-+
-+/*
-+ * 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),
-+};
-+
-+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_COMM,
-+
-+	.bNumConfigurations =	1,
-+};
-+
-+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 *) &ether_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 inline void __init hs_subset_descriptors(void)
-+{
-+#ifdef DEV_CONFIG_SUBSET
-+	hs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
-+	hs_eth_function[2] = (struct usb_descriptor_header *) &fs_source_desc;
-+	hs_eth_function[3] = (struct usb_descriptor_header *) &fs_sink_desc;
-+	hs_eth_function[4] = 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,
-+	NULL,
-+};
-+#endif
-+
-+
-+/* maxpacket and other transfer characteristics vary by speed. */
-+#define ep_desc(g,hs,fs) (((g)->speed==USB_SPEED_HIGH)?(hs):(fs))
-+
-+#else
-+
-+/* if there's no high speed support, maxpacket doesn't change. */
-+#define ep_desc(g,hs,fs) fs
-+
-+static inline void __init hs_subset_descriptors(void)
-+{
-+}
-+
-+#endif	/* !CONFIG_USB_GADGET_DUALSPEED */
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* descriptors that are built on-demand */
-+
-+static char				manufacturer [50];
-+static char				product_desc [40] = DRIVER_DESC;
-+
-+#ifdef	DEV_CONFIG_CDC
-+/* address that the host will use ... usually assigned at random */
-+static char				ethaddr [2 * ETH_ALEN + 1];
-+#endif
-+
-+/* static strings, in UTF-8 */
-+static struct usb_string		strings [] = {
-+	{ STRING_MANUFACTURER,	manufacturer, },
-+	{ STRING_PRODUCT,	product_desc, },
-+	{ STRING_DATA,		"Ethernet Data", },
-+#ifdef	DEV_CONFIG_CDC
-+	{ STRING_CDC,		"CDC Ethernet", },
-+	{ STRING_ETHADDR,	ethaddr, },
-+	{ 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 (enum usb_device_speed speed,
-+	u8 *buf, u8 type,
-+	unsigned index, int is_otg)
-+{
-+	int					len;
-+	const struct usb_config_descriptor	*config;
-+	const struct usb_descriptor_header	**function;
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+	int				hs = (speed == USB_SPEED_HIGH);
-+
-+	if (type == USB_DT_OTHER_SPEED_CONFIG)
-+		hs = !hs;
-+#define which_fn(t)	(hs ? hs_ ## t ## _function : fs_ ## t ## _function)
-+#else
-+#define	which_fn(t)	(fs_ ## t ## _function)
-+#endif
-+
-+	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 = &eth_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, int gfp_flags);
-+static int alloc_requests (struct eth_dev *dev, unsigned n, int gfp_flags);
-+
-+#ifdef	DEV_CONFIG_CDC
-+static inline int ether_alt_ep_setup (struct eth_dev *dev, struct usb_ep *ep)
-+{
-+	const struct usb_endpoint_descriptor	*d;
-+
-+	/* 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.
-+	 */
-+
-+	/* one endpoint writes data back IN to the host */
-+	if (strcmp (ep->name, EP_IN_NAME) == 0) {
-+		d = ep_desc (dev->gadget, &hs_source_desc, &fs_source_desc);
-+		ep->driver_data = dev;
-+		dev->in = d;
-+
-+	/* one endpoint just reads OUT packets */
-+	} else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
-+		d = ep_desc (dev->gadget, &hs_sink_desc, &fs_sink_desc);
-+		ep->driver_data = dev;
-+		dev->out = d;
-+
-+	/* optional status/notification endpoint */
-+	} else if (EP_STATUS_NAME &&
-+			strcmp (ep->name, EP_STATUS_NAME) == 0) {
-+		int			result;
-+
-+		d = ep_desc (dev->gadget, &hs_status_desc, &fs_status_desc);
-+		result = usb_ep_enable (ep, d);
-+		if (result < 0)
-+			return result;
-+
-+		ep->driver_data = dev;
-+		dev->status = d;
-+	}
-+	return 0;
-+}
-+#endif
-+
-+#if	defined(DEV_CONFIG_SUBSET) || defined(CONFIG_USB_ETH_RNDIS)
-+static inline int ether_ep_setup (struct eth_dev *dev, struct usb_ep *ep)
-+{
-+	int					result;
-+	const struct usb_endpoint_descriptor	*d;
-+
-+	/* CDC subset is simpler:  if the device is there,
-+	 * it's live with rx and tx endpoints.
-+	 *
-+	 * Do this as a shortcut for RNDIS too.
-+	 */
-+
-+	/* one endpoint writes data back IN to the host */
-+	if (strcmp (ep->name, EP_IN_NAME) == 0) {
-+		d = ep_desc (dev->gadget, &hs_source_desc, &fs_source_desc);
-+		result = usb_ep_enable (ep, d);
-+		if (result < 0)
-+			return result;
-+
-+		ep->driver_data = dev;
-+		dev->in = d;
-+
-+	/* one endpoint just reads OUT packets */
-+	} else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
-+		d = ep_desc (dev->gadget, &hs_sink_desc, &fs_sink_desc);
-+		result = usb_ep_enable (ep, d);
-+		if (result < 0)
-+			return result;
-+
-+		ep->driver_data = dev;
-+		dev->out = d;
-+	}
-+
-+	return 0;
-+}
-+#endif
-+
-+static int
-+set_ether_config (struct eth_dev *dev, int gfp_flags)
-+{
-+	int			result = 0;
-+	struct usb_ep		*ep;
-+	struct usb_gadget	*gadget = dev->gadget;
-+
-+	gadget_for_each_ep (ep, gadget) {
-+#ifdef	DEV_CONFIG_CDC
-+		if (!dev->rndis && dev->cdc) {
-+			result = ether_alt_ep_setup (dev, ep);
-+			if (result == 0)
-+				continue;
-+		}
-+#endif
-+
-+#ifdef	CONFIG_USB_ETH_RNDIS
-+		if (dev->rndis && strcmp (ep->name, EP_STATUS_NAME) == 0) {
-+			const struct usb_endpoint_descriptor	*d;
-+			d = ep_desc (gadget, &hs_status_desc, &fs_status_desc);
-+			result = usb_ep_enable (ep, d);
-+			if (result == 0) {
-+				ep->driver_data = dev;
-+				dev->status = d;
-+				continue;
-+			}
-+		} else
-+#endif
-+
-+		{
-+#if	defined(DEV_CONFIG_SUBSET) || defined(CONFIG_USB_ETH_RNDIS)
-+			result = ether_ep_setup (dev, ep);
-+			if (result == 0)
-+				continue;
-+#endif
-+		}
-+
-+		/* stop on error */
-+		ERROR (dev, "can't enable %s, result %d\n", ep->name, result);
-+		break;
-+	}
-+	if (!result && (!dev->in_ep || !dev->out_ep))
-+		result = -ENODEV;
-+
-+	if (result == 0)
-+		result = alloc_requests (dev, qlen (gadget), gfp_flags);
-+
-+	/* on error, disable any endpoints  */
-+	if (result < 0) {
-+#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
-+		if (dev->status)
-+			(void) usb_ep_disable (dev->status_ep);
-+#endif
-+		dev->status = NULL;
-+#if defined(DEV_CONFIG_SUBSET) || defined(CONFIG_USB_ETH_RNDIS)
-+		if (dev->rndis || !dev->cdc) {
-+			if (dev->in)
-+				(void) usb_ep_disable (dev->in_ep);
-+			if (dev->out)
-+				(void) usb_ep_disable (dev->out_ep);
-+		}
-+#endif
-+		dev->in = NULL;
-+		dev->out = NULL;
-+	} else
-+
-+	/* activate non-CDC configs right away
-+	 * this isn't strictly according to the RNDIS spec
-+	 */
-+#if defined(DEV_CONFIG_SUBSET) || defined(CONFIG_USB_ETH_RNDIS)
-+	if (dev->rndis || !dev->cdc) {
-+		netif_carrier_on (dev->net);
-+		if (netif_running (dev->net)) {
-+			spin_unlock (&dev->lock);
-+			eth_start (dev, GFP_ATOMIC);
-+			spin_lock (&dev->lock);
-+		}
-+	}
-+#endif
-+
-+	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", __FUNCTION__);
-+
-+	netif_stop_queue (dev->net);
-+	netif_carrier_off (dev->net);
-+
-+	/* disable endpoints, forcing (synchronous) completion of
-+	 * pending i/o.  then free the requests.
-+	 */
-+	if (dev->in) {
-+		usb_ep_disable (dev->in_ep);
-+		while (likely (!list_empty (&dev->tx_reqs))) {
-+			req = container_of (dev->tx_reqs.next,
-+						struct usb_request, list);
-+			list_del (&req->list);
-+			usb_ep_free_request (dev->in_ep, req);
-+		}
-+	}
-+	if (dev->out) {
-+		usb_ep_disable (dev->out_ep);
-+		while (likely (!list_empty (&dev->rx_reqs))) {
-+			req = container_of (dev->rx_reqs.next,
-+						struct usb_request, list);
-+			list_del (&req->list);
-+			usb_ep_free_request (dev->out_ep, req);
-+		}
-+	}
-+
-+	if (dev->status) {
-+		usb_ep_disable (dev->status_ep);
-+	}
-+	dev->config = 0;
-+}
-+
-+/* change our operational config.  must agree with the code
-+ * that returns config descriptors, and altsetting code.
-+ */
-+static int
-+eth_set_config (struct eth_dev *dev, unsigned number, int gfp_flags)
-+{
-+	int			result = 0;
-+	struct usb_gadget	*gadget = dev->gadget;
-+
-+	if (number == dev->config)
-+		return 0;
-+
-+	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);
-+
-+	/* default:  pass all packets, no multicast filtering */
-+	dev->cdc_filter = 0x000f;
-+
-+	switch (number) {
-+	case DEV_CONFIG_VALUE:
-+		dev->rndis = 0;
-+		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,
-+				dev->gadget->is_otg ? 8 : 100);
-+	} else {
-+		char *speed;
-+		unsigned power;
-+
-+		power = 2 * eth_config.bMaxPower;
-+		usb_gadget_vbus_draw(dev->gadget, power);
-+
-+		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,
-+				dev->rndis
-+					? "RNDIS"
-+					: (dev->cdc
-+						? "CDC Ethernet"
-+						: "CDC Ethernet Subset"));
-+	}
-+	return result;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#ifdef	DEV_CONFIG_CDC
-+
-+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);
-+	event->bmRequestType = 0xff;
-+}
-+
-+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", __FUNCTION__);
-+
-+	/* 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...
-+	 */
-+	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;
-+	value = usb_ep_queue (dev->status_ep, req, GFP_ATOMIC);
-+	if (value < 0)
-+		DEBUG (dev, "status buf queue --> %d\n", value);
-+}
-+
-+#endif
-+
-+/*-------------------------------------------------------------------------*/
-+
-+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", __FUNCTION__, 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
-+ */
-+static int
-+eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
-+{
-+	struct eth_dev		*dev = get_gadget_data (gadget);
-+	struct usb_request	*req = dev->req;
-+	int			value = -EOPNOTSUPP;
-+	u16			wIndex = ctrl->wIndex;
-+	u16			wValue = ctrl->wValue;
-+	u16			wLength = 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;
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+		case USB_DT_DEVICE_QUALIFIER:
-+			if (!gadget->is_dualspeed)
-+				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)
-+				break;
-+			// FALLTHROUGH
-+#endif /* CONFIG_USB_GADGET_DUALSPEED */
-+		case USB_DT_CONFIG:
-+			value = config_buf (gadget->speed, req->buf,
-+					wValue >> 8,
-+					wValue & 0xff,
-+					gadget->is_otg);
-+			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 (!dev->cdc && 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 clears filters etc.
-+			 */
-+			if (wValue == 1) {
-+				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 ...
-+		 */
-+		WARN(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 (!(dev->cdc || dev->rndis) && wIndex != 0)
-+			break;
-+
-+		/* for CDC, iff carrier is on, data interface is active. */
-+		if (dev->rndis || 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)
-+				|| !dev->cdc
-+				|| dev->rndis
-+				|| 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 */
-+
-+#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)
-+				|| !dev->rndis
-+				|| 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
-+				&& dev->rndis
-+				// && wLength >= 0x0400
-+				&& !wValue
-+				&& rndis_control_intf.bInterfaceNumber
-+					== wIndex) {
-+			u8 *buf;
-+
-+			/* return the result */
-+			buf = rndis_get_next_response (dev->rndis_config,
-+						       &value);
-+			if (buf) {
-+				memcpy (req->buf, buf, value);
-+				req->complete = rndis_response_complete;
-+				rndis_free_response(dev->rndis_config, buf);
-+			}
-+			/* 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);
-+	}
-+
-+	/* 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) */
-+
-+/* glue code: in more recent 2.4 kernels these functions are contained in netdev.h */
-+
-+#ifndef HAVE_NETDEV_PRIV
-+static inline void *netdev_priv(struct net_device *net)
-+{
-+   return net->priv;
-+}
-+#endif
-+
-+#ifndef HAVE_FREE_NETDEV
-+static inline void free_netdev(struct net_device *dev)
-+{
-+	kfree(dev);
-+}
-+#endif
-+
-+static int eth_change_mtu (struct net_device *net, int new_mtu)
-+{
-+	struct eth_dev	*dev = netdev_priv(net);
-+
-+	// FIXME if rndis, don't change while link's live
-+
-+	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 int eth_ethtool_ioctl (struct net_device *net, void *useraddr)
-+{
-+	struct eth_dev	*dev = (struct eth_dev *) net->priv;
-+	u32		cmd;
-+
-+	if (get_user (cmd, (u32 *)useraddr))
-+		return -EFAULT;
-+	switch (cmd) {
-+
-+	case ETHTOOL_GDRVINFO: {	/* get driver info */
-+		struct ethtool_drvinfo		info;
-+
-+		memset (&info, 0, sizeof info);
-+		info.cmd = ETHTOOL_GDRVINFO;
-+		strncpy (info.driver, shortname, sizeof info.driver);
-+		strncpy (info.version, DRIVER_VERSION, sizeof info.version);
-+		strncpy (info.fw_version, dev->gadget->name, sizeof info.fw_version);
-+		strncpy (info.bus_info, dev->gadget->dev.bus_id,
-+			sizeof info.bus_info);
-+		if (copy_to_user (useraddr, &info, sizeof (info)))
-+			return -EFAULT;
-+		return 0;
-+		}
-+
-+	case ETHTOOL_GLINK: {		/* get link status */
-+		struct ethtool_value	edata = { ETHTOOL_GLINK };
-+
-+		edata.data = (dev->gadget->speed != USB_SPEED_UNKNOWN);
-+		if (copy_to_user (useraddr, &edata, sizeof (edata)))
-+			return -EFAULT;
-+		return 0;
-+		}
-+
-+	}
-+	/* Note that the ethtool user space code requires EOPNOTSUPP */
-+	return -EOPNOTSUPP;
-+}
-+
-+static int eth_ioctl (struct net_device *net, struct ifreq *rq, int cmd)
-+{
-+	switch (cmd) {
-+	case SIOCETHTOOL:
-+		return eth_ethtool_ioctl (net, (void *)rq->ifr_data);
-+	default:
-+		return -EOPNOTSUPP;
-+	}
-+}
-+
-+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
-+		DEBUG (dev, "kevent %d scheduled\n", flag);
-+}
-+
-+static void rx_complete (struct usb_ep *ep, struct usb_request *req);
-+
-+#ifndef	NET_IP_ALIGN
-+/* this can be a cpu-specific value */
-+#define	NET_IP_ALIGN	2
-+#endif
-+
-+static int
-+rx_submit (struct eth_dev *dev, struct usb_request *req, int 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;
-+#ifdef CONFIG_USB_ETH_RNDIS
-+	if (dev->rndis)
-+		size += sizeof (struct rndis_packet_msg_type);
-+#endif	
-+	size -= size % dev->out_ep->maxpacket;
-+
-+	if ((skb = alloc_skb (size + NET_IP_ALIGN, gfp_flags)) == 0) {
-+		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:
-+	 * this doesn't account for variable-sized RNDIS headers.
-+	 */
-+	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);
-+		dev_kfree_skb_any (skb);
-+		spin_lock (&dev->lock);
-+		list_add (&req->list, &dev->rx_reqs);
-+		spin_unlock (&dev->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);
-+#ifdef CONFIG_USB_ETH_RNDIS
-+		/* we know MaxPacketsPerTransfer == 1 here */
-+		if (dev->rndis)
-+			rndis_rm_hdr (req->buf, &(skb->len));
-+#endif
-+		if (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->dev = dev->net;
-+		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:
-+		/* nobody reading rx_reqs, so no dev->lock */
-+		list_add (&req->list, &dev->rx_reqs);
-+		req = NULL;
-+	}
-+	if (req)
-+		rx_submit (dev, req, GFP_ATOMIC);
-+}
-+
-+static int prealloc (struct list_head *list, struct usb_ep *ep,
-+			unsigned n, int 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, int gfp_flags)
-+{
-+	int status;
-+
-+	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;
-+	return 0;
-+fail:
-+	DEBUG (dev, "can't alloc requests\n");
-+	return status;
-+}
-+
-+static void rx_fill (struct eth_dev *dev, int gfp_flags)
-+{
-+	struct usb_request	*req;
-+	unsigned long		flags;
-+
-+	clear_bit (WORK_RX_MEMORY, &dev->todo);
-+
-+	/* fill unused rxq slots with some skb */
-+	spin_lock_irqsave (&dev->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->lock, flags);
-+
-+		if (rx_submit (dev, req, gfp_flags) < 0) {
-+			defer_kevent (dev, WORK_RX_MEMORY);
-+			return;
-+		}
-+
-+		spin_lock_irqsave (&dev->lock, flags);
-+	}
-+	spin_unlock_irqrestore (&dev->lock, flags);
-+}
-+
-+static void eth_work (void *_dev)
-+{
-+	struct eth_dev		*dev = _dev;
-+
-+	if (test_bit (WORK_RX_MEMORY, &dev->todo)) {
-+		if (netif_running (dev->net))
-+			rx_fill (dev, GFP_KERNEL);
-+		else
-+			clear_bit (WORK_RX_MEMORY, &dev->todo);
-+	}
-+
-+	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->lock);
-+	list_add (&req->list, &dev->tx_reqs);
-+	spin_unlock (&dev->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 (dest [0] & 0x01) {
-+			u16	type;
-+
-+			/* ignores USB_CDC_PACKET_TYPE_MULTICAST and host
-+			 * SET_ETHERNET_MULTICAST_FILTERS requests
-+			 */
-+			if (memcmp (dest, net->broadcast, ETH_ALEN) == 0)
-+				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->lock, flags);
-+	req = container_of (dev->tx_reqs.next, struct usb_request, list);
-+	list_del (&req->list);
-+	if (list_empty (&dev->tx_reqs))
-+		netif_stop_queue (net);
-+	spin_unlock_irqrestore (&dev->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
-+	 */
-+#ifdef CONFIG_USB_ETH_RNDIS
-+	if (dev->rndis) {
-+		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;
-+	}
-+#endif
-+	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;
-+
-+#ifdef	CONFIG_USB_GADGET_DUALSPEED
-+	/* throttle highspeed IRQ rate back slightly */
-+	req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
-+		? ((atomic_read (&dev->tx_qlen) % TX_DELAY) != 0)
-+		: 0;
-+#endif
-+
-+	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) {
-+#ifdef CONFIG_USB_ETH_RNDIS
-+drop:
-+#endif
-+		dev->stats.tx_dropped++;
-+		dev_kfree_skb_any (skb);
-+		spin_lock_irqsave (&dev->lock, flags);
-+		if (list_empty (&dev->tx_reqs))
-+			netif_start_queue (net);
-+		list_add (&req->list, &dev->tx_reqs);
-+		spin_unlock_irqrestore (&dev->lock, flags);
-+	}
-+	return 0;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#ifdef CONFIG_USB_ETH_RNDIS
-+
-+static void rndis_send_media_state (struct eth_dev *dev, int connect)
-+{
-+	if (!dev)
-+		return;
-+	
-+	if (connect) {
-+		if (rndis_signal_connect (dev->rndis_config))
-+			return;
-+	} else {
-+		if (rndis_signal_disconnect (dev->rndis_config))
-+			return;
-+	}
-+}
-+
-+static void
-+rndis_control_ack_complete (struct usb_ep *ep, struct usb_request *req)
-+{
-+	if (req->status || req->actual != req->length)
-+		DEBUG ((struct eth_dev *) ep->driver_data,
-+			"rndis control ack complete --> %d, %d/%d\n",
-+			req->status, req->actual, req->length);
-+
-+	usb_ep_free_buffer(ep, req->buf, req->dma, 8);
-+	usb_ep_free_request(ep, req);
-+}
-+
-+static int rndis_control_ack (struct net_device *net)
-+{
-+	struct eth_dev          *dev = netdev_priv(net);
-+	u32                     length;
-+	struct usb_request      *resp;
-+	
-+	/* in case RNDIS calls this after disconnect */
-+	if (!dev->status_ep) {
-+		DEBUG (dev, "status ENODEV\n");
-+		return -ENODEV;
-+	}
-+
-+	/* Allocate memory for notification ie. ACK */
-+	resp = usb_ep_alloc_request (dev->status_ep, GFP_ATOMIC);
-+	if (!resp) {
-+		DEBUG (dev, "status ENOMEM\n");
-+		return -ENOMEM;
-+	}
-+	
-+	resp->buf = usb_ep_alloc_buffer (dev->status_ep, 8,
-+					 &resp->dma, GFP_ATOMIC);
-+	if (!resp->buf) {
-+		DEBUG (dev, "status buf ENOMEM\n");
-+		usb_ep_free_request (dev->status_ep, 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;
-+	
-+	*((__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;
-+}
-+
-+#endif	/* RNDIS */
-+
-+static void eth_start (struct eth_dev *dev, int gfp_flags)
-+{
-+	DEBUG (dev, "%s\n", __FUNCTION__);
-+
-+	/* 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);
-+#ifdef CONFIG_USB_ETH_RNDIS
-+	if (dev->rndis) {
-+		rndis_set_param_medium (dev->rndis_config,
-+					NDIS_MEDIUM_802_3,
-+					BITRATE(dev->gadget));
-+		rndis_send_media_state (dev, 1);
-+	}
-+#endif	
-+}
-+
-+static int eth_open (struct net_device *net)
-+{
-+	struct eth_dev		*dev = netdev_priv(net);
-+
-+	DEBUG (dev, "%s\n", __FUNCTION__);
-+	if (netif_carrier_ok (dev->net))
-+		eth_start (dev, GFP_KERNEL);
-+	return 0;
-+}
-+
-+static int eth_stop (struct net_device *net)
-+{
-+	struct eth_dev		*dev = netdev_priv(net);
-+
-+	VDEBUG (dev, "%s\n", __FUNCTION__);
-+	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);
-+		}
-+	}
-+	
-+#ifdef	CONFIG_USB_ETH_RNDIS
-+	if (dev->rndis) {
-+		rndis_set_param_medium (dev->rndis_config,
-+					NDIS_MEDIUM_802_3, 0);
-+		rndis_send_media_state (dev, 0);
-+	}
-+#endif
-+
-+	return 0;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static struct usb_request *eth_req_alloc (struct usb_ep *ep, unsigned size)
-+{
-+	struct usb_request	*req;
-+
-+	req = usb_ep_alloc_request (ep, GFP_KERNEL);
-+	if (!req)
-+		return NULL;
-+
-+	req->buf = kmalloc (size, GFP_KERNEL);
-+	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
-+eth_unbind (struct usb_gadget *gadget)
-+{
-+	struct eth_dev		*dev = get_gadget_data (gadget);
-+
-+	DEBUG (dev, "unbind\n");
-+#ifdef CONFIG_USB_ETH_RNDIS
-+	rndis_deregister (dev->rndis_config);
-+	rndis_exit ();
-+#endif
-+
-+	/* 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;
-+}
-+
-+static void __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;
-+	}
-+	random_ether_addr(dev_addr);
-+}
-+
-+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;
-+
-+	/* 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_net2280 (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0201);
-+	} else if (gadget_is_dummy (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0202);
-+	} else if (gadget_is_pxa (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0203);
-+		/* pxa doesn't support altsettings */
-+		cdc = 0;
-+	} else if (gadget_is_sh(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0204);
-+		/* sh doesn't support multiple interfaces or configs */
-+		cdc = 0;
-+		rndis = 0;
-+	} else if (gadget_is_sa1100 (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0205);
-+		/* 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;
-+	} else if (gadget_is_goku (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0206);
-+	} else if (gadget_is_mq11xx (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0207);
-+	} else if (gadget_is_omap (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0208);
-+	} else if (gadget_is_lh7a40x(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0209);
-+	} else if (gadget_is_n9604(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0210);
-+	} else if (gadget_is_pxa27x(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0211);
-+	} else if (gadget_is_s3c2410(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0212);
-+	} else if (gadget_is_at91(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0213);
-+	} 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.
-+		 */
-+		printk (KERN_ERR "%s: "
-+			"controller '%s' not recognized\n",
-+			shortname, gadget->name);
-+		return -ENODEV;
-+	}
-+	snprintf (manufacturer, sizeof manufacturer,
-+		UTS_SYSNAME " " UTS_RELEASE "/%s",
-+		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.
-+	 */
-+	} else if (!cdc) {
-+		device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC;
-+		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) {
-+			printk (KERN_ERR "%s: idVendor needs idProduct!\n",
-+				shortname);
-+			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)
-+		strncpy (manufacturer, iManufacturer, sizeof manufacturer);
-+	if (iProduct)
-+		strncpy (product_desc, iProduct, sizeof product_desc);
-+
-+	/* 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:
-+		printk (KERN_ERR "%s: can't autoconfigure on %s\n",
-+			shortname, gadget->name);
-+		return -ENODEV;
-+	}
-+	EP_IN_NAME = in_ep->name;
-+	in_ep->driver_data = in_ep;	/* claim */
-+	
-+	out_ep = usb_ep_autoconfig (gadget, &fs_sink_desc);
-+	if (!out_ep)
-+		goto autoconf_fail;
-+	EP_OUT_NAME = out_ep->name;
-+	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) {
-+			EP_STATUS_NAME = status_ep->name;
-+			status_ep->driver_data = status_ep;	/* claim */
-+		} else if (rndis) {
-+			printk (KERN_ERR "%s: "
-+				"can't run RNDIS on %s\n",
-+				shortname, 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;
-+		fs_subset_descriptors();
-+		hs_subset_descriptors();
-+	}
-+
-+	/* For now RNDIS is always a second config */
-+	if (rndis)
-+		device_desc.bNumConfigurations = 2;
-+
-+#ifdef	CONFIG_USB_GADGET_DUALSPEED
-+	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 (EP_STATUS_NAME)
-+		hs_status_desc.bEndpointAddress =
-+				fs_status_desc.bEndpointAddress;
-+#endif
-+#endif	/* DUALSPEED */
-+
-+	device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
-+	usb_gadget_set_selfpowered (gadget);
-+
-+	if (gadget->is_otg) {
-+		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);
-+	INIT_WORK (&dev->work, eth_work, dev);
-+	INIT_LIST_HEAD (&dev->tx_reqs);
-+	INIT_LIST_HEAD (&dev->rx_reqs);
-+
-+	/* network device setup */
-+	dev->net = net;
-+	SET_MODULE_OWNER (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.
-+	 */
-+	get_ether_addr(dev_addr, net->dev_addr);
-+	if (cdc || rndis) {
-+		get_ether_addr(host_addr, dev->host_mac);
-+#ifdef	DEV_CONFIG_CDC
-+		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]);
-+#endif
-+	}
-+
-+	if (rndis) {
-+		status = rndis_init();
-+		if (status < 0) {
-+			printk (KERN_ERR "%s: can't init RNDIS, %d\n",
-+				shortname, 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
-+	net->do_ioctl = eth_ioctl;
-+
-+	/* preallocate control message data and buffer */
-+	dev->req = eth_req_alloc (gadget->ep0, USB_BUFSIZ);
-+	if (!dev->req)
-+		goto fail;
-+	dev->req->complete = eth_setup_complete;
-+
-+	/* PO: this code my be reached with STATUS_BYTECOUNT undefined
-+		Don't allocate stat_req then?!
-+	 */
-+#ifdef STATUS_BYTECOUNT
-+	/* ... and maybe likewise for status transfer */
-+	if (dev->status_ep) {
-+		dev->stat_req = eth_req_alloc (dev->status_ep,
-+					STATUS_BYTECOUNT);
-+		if (!dev->stat_req) {
-+			eth_req_free (gadget->ep0, dev->req);
-+			goto fail;
-+		}
-+	}
-+#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);
-+	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,
-+		EP_OUT_NAME, EP_IN_NAME,
-+		EP_STATUS_NAME ? " STATUS " : "",
-+		EP_STATUS_NAME ? EP_STATUS_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]);
-+
-+#ifdef	CONFIG_USB_ETH_RNDIS
-+	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;
-+		}
-+		
-+		/* 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))
-+			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");
-+	}
-+#endif	
-+
-+	return status;
-+
-+fail1:
-+	DEBUG (dev, "register_netdev failed, %d\n", status);
-+fail:
-+	eth_unbind (gadget);
-+	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)
-+{
-+	struct eth_dev		*dev = get_gadget_data (gadget);
-+
-+	DEBUG (dev, "resume\n");
-+	dev->suspended = 0;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static struct usb_gadget_driver eth_driver = {
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+	.speed		= USB_SPEED_HIGH,
-+#else
-+	.speed		= USB_SPEED_FULL,
-+#endif
-+	.function	= (char *) driver_desc,
-+	.bind		= eth_bind,
-+	.unbind		= eth_unbind,
-+
-+	.setup		= eth_setup,
-+	.disconnect	= eth_disconnect,
-+
-+	/* PO: is this available? */
-+	.suspend	= eth_suspend,
-+	.resume		= eth_resume,
-+
-+	.driver 	= {
-+		.name		= (char *) shortname,
-+		// .shutdown = ...
-+		// .suspend = ...
-+		// .resume = ...
-+	},
-+};
-+
-+MODULE_DESCRIPTION (DRIVER_DESC);
-+MODULE_AUTHOR ("David Brownell, Benedikt Spanger");
-+MODULE_LICENSE ("GPL");
-+
-+
-+static int __init init (void)
-+{
-+	return usb_gadget_register_driver (&eth_driver);
-+}
-+module_init (init);
-+
-+static void __exit cleanup (void)
-+{
-+	usb_gadget_unregister_driver (&eth_driver);
-+}
-+module_exit (cleanup);
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/file_storage.c kernel/drivers/usb/gadget/file_storage.c
---- /tmp/kernel/drivers/usb/gadget/file_storage.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/file_storage.c	2005-04-22 17:53:19.431540004 +0200
-@@ -0,0 +1,3939 @@
-+/*
-+ * file_storage.c -- File-backed USB Storage Gadget, for USB development
-+ *
-+ * Copyright (C) 2003, 2004 Alan Stern
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions
-+ * are met:
-+ * 1. Redistributions of source code must retain the above copyright
-+ *    notice, this list of conditions, and the following disclaimer,
-+ *    without modification.
-+ * 2. Redistributions in binary form must reproduce the above copyright
-+ *    notice, this list of conditions and the following disclaimer in the
-+ *    documentation and/or other materials provided with the distribution.
-+ * 3. The names of the above-listed copyright holders may not be used
-+ *    to endorse or promote products derived from this software without
-+ *    specific prior written permission.
-+ *
-+ * ALTERNATIVELY, this software may be 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.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+
-+/*
-+ * The File-backed Storage Gadget acts as a USB Mass Storage device,
-+ * appearing to the host as a disk drive.  In addition to providing an
-+ * example of a genuinely useful gadget driver for a USB device, it also
-+ * illustrates a technique of double-buffering for increased throughput.
-+ * Last but not least, it gives an easy way to probe the behavior of the
-+ * Mass Storage drivers in a USB host.
-+ *
-+ * Backing storage is provided by a regular file or a block device, specified
-+ * by the "file" module parameter.  Access can be limited to read-only by
-+ * setting the optional "ro" module parameter.
-+ *
-+ * The gadget supports the Control-Bulk (CB), Control-Bulk-Interrupt (CBI),
-+ * and Bulk-Only (also known as Bulk-Bulk-Bulk or BBB) transports, selected
-+ * by the optional "transport" module parameter.  It also supports the
-+ * following protocols: RBC (0x01), ATAPI or SFF-8020i (0x02), QIC-157 (0c03),
-+ * UFI (0x04), SFF-8070i (0x05), and transparent SCSI (0x06), selected by
-+ * the optional "protocol" module parameter.  For testing purposes the
-+ * gadget will indicate that it has removable media if the optional
-+ * "removable" module parameter is set.  In addition, the default Vendor ID,
-+ * Product ID, and release number can be overridden.
-+ *
-+ * There is support for multiple logical units (LUNs), each of which has
-+ * its own backing file.  The number of LUNs can be set using the optional
-+ * "luns" module parameter (anywhere from 1 to 8), and the corresponding
-+ * files are specified using comma-separated lists for "file" and "ro".
-+ * The default number of LUNs is taken from the number of "file" elements;
-+ * it is 1 if "file" is not given.  If "removable" is not set then a backing
-+ * file must be specified for each LUN.  If it is set, then an unspecified
-+ * or empty backing filename means the LUN's medium is not loaded.
-+ *
-+ * Requirements are modest; only a bulk-in and a bulk-out endpoint are
-+ * needed (an interrupt-out endpoint is also needed for CBI).  The memory
-+ * requirement amounts to two 16K buffers, size configurable by a parameter.
-+ * Support is included for both full-speed and high-speed operation.
-+ *
-+ * Module options:
-+ *
-+ *	file=filename[,filename...]
-+ *				Required if "removable" is not set, names of
-+ *					the files or block devices used for
-+ *					backing storage
-+ *	ro=b[,b...]		Default false, booleans for read-only access
-+ *	luns=N			Default N = number of filenames, number of
-+ *					LUNs to support
-+ *	transport=XXX		Default BBB, transport name (CB, CBI, or BBB)
-+ *	protocol=YYY		Default SCSI, protocol name (RBC, 8020 or
-+ *					ATAPI, QIC, UFI, 8070, or SCSI;
-+ *					also 1 - 6)
-+ *	removable		Default false, boolean for removable media
-+ *	vendor=0xVVVV		Default 0x0525 (NetChip), USB Vendor ID
-+ *	product=0xPPPP		Default 0xa4a5 (FSG), USB Product ID
-+ *	release=0xRRRR		Override the USB release number (bcdDevice)
-+ *	buflen=N		Default N=16384, buffer size used (will be
-+ *					rounded down to a multiple of
-+ *					PAGE_CACHE_SIZE)
-+ *	stall			Default determined according to the type of
-+ *					USB device controller (usually true),
-+ *					boolean to permit the driver to halt
-+ *					bulk endpoints
-+ *
-+ * If CONFIG_USB_FILE_STORAGE_TEST is not set, only the "file" and "ro"
-+ * options are available; default values are used for everything else.
-+ *
-+ * This gadget driver is heavily based on "Gadget Zero" by David Brownell.
-+ */
-+
-+
-+/*
-+ *				Driver Design
-+ *
-+ * The FSG driver is fairly straightforward.  There is a main kernel
-+ * thread that handles most of the work.  Interrupt routines field
-+ * callbacks from the controller driver: bulk- and interrupt-request
-+ * completion notifications, endpoint-0 events, and disconnect events.
-+ * Completion events are passed to the main thread by wakeup calls.  Many
-+ * ep0 requests are handled at interrupt time, but SetInterface,
-+ * SetConfiguration, and device reset requests are forwarded to the
-+ * thread in the form of "exceptions" using SIGUSR1 signals (since they
-+ * should interrupt any ongoing file I/O operations).
-+ *
-+ * The thread's main routine implements the standard command/data/status
-+ * parts of a SCSI interaction.  It and its subroutines are full of tests
-+ * for pending signals/exceptions -- all this polling is necessary since
-+ * the kernel has no setjmp/longjmp equivalents.  (Maybe this is an
-+ * indication that the driver really wants to be running in userspace.)
-+ * An important point is that so long as the thread is alive it keeps an
-+ * open reference to the backing file.  This will prevent unmounting
-+ * the backing file's underlying filesystem and could cause problems
-+ * during system shutdown, for example.  To prevent such problems, the
-+ * thread catches INT, TERM, and KILL signals and converts them into
-+ * an EXIT exception.
-+ *
-+ * In normal operation the main thread is started during the gadget's
-+ * fsg_bind() callback and stopped during fsg_unbind().  But it can also
-+ * exit when it receives a signal, and there's no point leaving the
-+ * gadget running when the thread is dead.  So just before the thread
-+ * exits, it deregisters the gadget driver.  This makes things a little
-+ * tricky: The driver is deregistered at two places, and the exiting
-+ * thread can indirectly call fsg_unbind() which in turn can tell the
-+ * thread to exit.  The first problem is resolved through the use of the
-+ * REGISTERED atomic bitflag; the driver will only be deregistered once.
-+ * The second problem is resolved by having fsg_unbind() check
-+ * fsg->state; it won't try to stop the thread if the state is already
-+ * FSG_STATE_TERMINATED.
-+ *
-+ * To provide maximum throughput, the driver uses a circular pipeline of
-+ * buffer heads (struct fsg_buffhd).  In principle the pipeline can be
-+ * arbitrarily long; in practice the benefits don't justify having more
-+ * than 2 stages (i.e., double buffering).  But it helps to think of the
-+ * pipeline as being a long one.  Each buffer head contains a bulk-in and
-+ * a bulk-out request pointer (since the buffer can be used for both
-+ * output and input -- directions always are given from the host's
-+ * point of view) as well as a pointer to the buffer and various state
-+ * variables.
-+ *
-+ * Use of the pipeline follows a simple protocol.  There is a variable
-+ * (fsg->next_buffhd_to_fill) that points to the next buffer head to use.
-+ * At any time that buffer head may still be in use from an earlier
-+ * request, so each buffer head has a state variable indicating whether
-+ * it is EMPTY, FULL, or BUSY.  Typical use involves waiting for the
-+ * buffer head to be EMPTY, filling the buffer either by file I/O or by
-+ * USB I/O (during which the buffer head is BUSY), and marking the buffer
-+ * head FULL when the I/O is complete.  Then the buffer will be emptied
-+ * (again possibly by USB I/O, during which it is marked BUSY) and
-+ * finally marked EMPTY again (possibly by a completion routine).
-+ *
-+ * A module parameter tells the driver to avoid stalling the bulk
-+ * endpoints wherever the transport specification allows.  This is
-+ * necessary for some UDCs like the SuperH, which cannot reliably clear a
-+ * halt on a bulk endpoint.  However, under certain circumstances the
-+ * Bulk-only specification requires a stall.  In such cases the driver
-+ * will halt the endpoint and set a flag indicating that it should clear
-+ * the halt in software during the next device reset.  Hopefully this
-+ * will permit everything to work correctly.
-+ *
-+ * One subtle point concerns sending status-stage responses for ep0
-+ * requests.  Some of these requests, such as device reset, can involve
-+ * interrupting an ongoing file I/O operation, which might take an
-+ * arbitrarily long time.  During that delay the host might give up on
-+ * the original ep0 request and issue a new one.  When that happens the
-+ * driver should not notify the host about completion of the original
-+ * request, as the host will no longer be waiting for it.  So the driver
-+ * assigns to each ep0 request a unique tag, and it keeps track of the
-+ * tag value of the request associated with a long-running exception
-+ * (device-reset, interface-change, or configuration-change).  When the
-+ * exception handler is finished, the status-stage response is submitted
-+ * only if the current ep0 request tag is equal to the exception request
-+ * tag.  Thus only the most recently received ep0 request will get a
-+ * status-stage response.
-+ *
-+ * Warning: This driver source file is too long.  It ought to be split up
-+ * into a header file plus about 3 separate .c files, to handle the details
-+ * of the Gadget, USB Mass Storage, and SCSI protocols.
-+ */
-+
-+
-+#undef DEBUG
-+#undef VERBOSE
-+#undef DUMP_MSGS
-+
-+#include <linux/config.h>
-+
-+#include <asm/system.h>
-+#include <asm/uaccess.h>
-+
-+#include <linux/bitops.h>
-+#include <linux/blkdev.h>
-+#include <linux/compiler.h>
-+#include <linux/completion.h>
-+#include <linux/dcache.h>
-+#include <linux/fcntl.h>
-+#include <linux/file.h>
-+#include <linux/fs.h>
-+#include <linux/init.h>
-+#include <linux/kernel.h>
-+#include <linux/limits.h>
-+#include <linux/list.h>
-+#include <linux/module.h>
-+#include <linux/pagemap.h>
-+#include <linux/rwsem.h>
-+#include <linux/sched.h>
-+#include <linux/signal.h>
-+#include <linux/slab.h>
-+#include <linux/spinlock.h>
-+#include <linux/string.h>
-+#include <linux/uts.h>
-+#include <linux/version.h>
-+#include <linux/wait.h>
-+
-+#include <linux/usb_ch9.h>
-+#include <linux/usb_gadget.h>
-+
-+#include "gadget_chips.h"
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#define DRIVER_DESC		"File-backed Storage Gadget"
-+#define DRIVER_NAME		"g_file_storage"
-+#define DRIVER_VERSION		"05 June 2004"
-+
-+static const char longname[] = DRIVER_DESC;
-+static const char shortname[] = DRIVER_NAME;
-+
-+MODULE_DESCRIPTION(DRIVER_DESC);
-+MODULE_AUTHOR("Alan Stern");
-+MODULE_LICENSE("Dual BSD/GPL");
-+
-+/* Thanks to NetChip Technologies for donating this product ID.
-+ *
-+ * DO NOT REUSE THESE IDs with any other driver!!  Ever!!
-+ * Instead:  allocate your own, using normal USB-IF procedures. */
-+#define DRIVER_VENDOR_ID	0x0525	// NetChip
-+#define DRIVER_PRODUCT_ID	0xa4a5	// Linux-USB File-backed Storage Gadget
-+
-+
-+/*
-+ * This driver assumes self-powered hardware and has no way for users to
-+ * trigger remote wakeup.  It uses autoconfiguration to select endpoints
-+ * and endpoint addresses.
-+ */
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#define fakedev_printk(level, dev, format, args...) \
-+	printk(level "%s %s: " format , DRIVER_NAME , (dev)->name , ## args)
-+
-+#define xprintk(f,level,fmt,args...) \
-+	fakedev_printk(level , (f)->gadget , fmt , ## args)
-+#define yprintk(l,level,fmt,args...) \
-+	fakedev_printk(level , &(l)->dev , fmt , ## args)
-+
-+#ifdef DEBUG
-+#define DBG(fsg,fmt,args...) \
-+	xprintk(fsg , KERN_DEBUG , fmt , ## args)
-+#define LDBG(lun,fmt,args...) \
-+	yprintk(lun , KERN_DEBUG , fmt , ## args)
-+#define MDBG(fmt,args...) \
-+	printk(KERN_DEBUG DRIVER_NAME ": " fmt , ## args)
-+#else
-+#define DBG(fsg,fmt,args...) \
-+	do { } while (0)
-+#define LDBG(lun,fmt,args...) \
-+	do { } while (0)
-+#define MDBG(fmt,args...) \
-+	do { } while (0)
-+#undef VERBOSE
-+#undef DUMP_MSGS
-+#endif /* DEBUG */
-+
-+#ifdef VERBOSE
-+#define VDBG	DBG
-+#define VLDBG	LDBG
-+#else
-+#define VDBG(fsg,fmt,args...) \
-+	do { } while (0)
-+#define VLDBG(lun,fmt,args...) \
-+	do { } while (0)
-+#endif /* VERBOSE */
-+
-+#define ERROR(fsg,fmt,args...) \
-+	xprintk(fsg , KERN_ERR , fmt , ## args)
-+#define LERROR(lun,fmt,args...) \
-+	yprintk(lun , KERN_ERR , fmt , ## args)
-+
-+#define WARN(fsg,fmt,args...) \
-+	xprintk(fsg , KERN_WARNING , fmt , ## args)
-+#define LWARN(lun,fmt,args...) \
-+	yprintk(lun , KERN_WARNING , fmt , ## args)
-+
-+#define INFO(fsg,fmt,args...) \
-+	xprintk(fsg , KERN_INFO , fmt , ## args)
-+#define LINFO(lun,fmt,args...) \
-+	yprintk(lun , KERN_INFO , fmt , ## args)
-+
-+#define MINFO(fmt,args...) \
-+	printk(KERN_INFO DRIVER_NAME ": " fmt , ## args)
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* Encapsulate the module parameter settings */
-+
-+#define MAX_LUNS	8
-+
-+static char		*file[MAX_LUNS] = {NULL, };
-+static int		ro[MAX_LUNS] = {0, };
-+static unsigned int	luns = 0;
-+						// Default values
-+static char 		*transport = "BBB";
-+static char 		*protocol = "SCSI";
-+static int 		removable = 0;
-+static unsigned short	vendor = DRIVER_VENDOR_ID;
-+static unsigned short	product = DRIVER_PRODUCT_ID;
-+static unsigned short	release = 0xffff;	// Use controller chip type
-+static unsigned int	buflen = 16384;
-+static int		stall = 1;
-+
-+static struct {
-+	unsigned int	nluns;
-+
-+	char		*transport_parm;
-+	char		*protocol_parm;
-+	int		removable;
-+	unsigned short	vendor;
-+	unsigned short	product;
-+	unsigned short	release;
-+	unsigned int	buflen;
-+	int		can_stall;
-+
-+	int		transport_type;
-+	char		*transport_name;
-+	int		protocol_type;
-+	char		*protocol_name;
-+
-+} mod_data;
-+
-+
-+MODULE_PARM(file, "1-8s");
-+MODULE_PARM_DESC(file, "names of backing files or devices");
-+
-+MODULE_PARM(ro, "1-8b");
-+MODULE_PARM_DESC(ro, "true to force read-only");
-+
-+
-+/* In the non-TEST version, only the file and ro module parameters
-+ * are available. */
-+#ifdef CONFIG_USB_FILE_STORAGE_TEST
-+
-+MODULE_PARM(luns, "i");
-+MODULE_PARM_DESC(luns, "number of LUNs");
-+
-+MODULE_PARM(transport, "s");
-+MODULE_PARM_DESC(transport, "type of transport (BBB, CBI, or CB)");
-+
-+MODULE_PARM(protocol, "s");
-+MODULE_PARM_DESC(protocol, "type of protocol (RBC, 8020, QIC, UFI, "
-+		"8070, or SCSI)");
-+
-+MODULE_PARM(removable, "b");
-+MODULE_PARM_DESC(removable, "true to simulate removable media");
-+
-+MODULE_PARM(vendor, "h");
-+MODULE_PARM_DESC(vendor, "USB Vendor ID");
-+
-+MODULE_PARM(product, "h");
-+MODULE_PARM_DESC(product, "USB Product ID");
-+
-+MODULE_PARM(release, "h");
-+MODULE_PARM_DESC(release, "USB release number");
-+
-+MODULE_PARM(buflen, "i");
-+MODULE_PARM_DESC(buflen, "I/O buffer size");
-+
-+MODULE_PARM(stall, "i");
-+MODULE_PARM_DESC(stall, "false to prevent bulk stalls");
-+
-+#endif /* CONFIG_USB_FILE_STORAGE_TEST */
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* USB protocol value = the transport method */
-+#define USB_PR_CBI	0x00		// Control/Bulk/Interrupt
-+#define USB_PR_CB	0x01		// Control/Bulk w/o interrupt
-+#define USB_PR_BULK	0x50		// Bulk-only
-+
-+/* USB subclass value = the protocol encapsulation */
-+#define USB_SC_RBC	0x01		// Reduced Block Commands (flash)
-+#define USB_SC_8020	0x02		// SFF-8020i, MMC-2, ATAPI (CD-ROM)
-+#define USB_SC_QIC	0x03		// QIC-157 (tape)
-+#define USB_SC_UFI	0x04		// UFI (floppy)
-+#define USB_SC_8070	0x05		// SFF-8070i (removable)
-+#define USB_SC_SCSI	0x06		// Transparent SCSI
-+
-+/* Bulk-only data structures */
-+
-+/* Command Block Wrapper */
-+struct bulk_cb_wrap {
-+	u32	Signature;		// Contains 'USBC'
-+	u32	Tag;			// Unique per command id
-+	u32	DataTransferLength;	// Size of the data
-+	u8	Flags;			// Direction in bit 7
-+	u8	Lun;			// LUN (normally 0)
-+	u8	Length;			// Of the CDB, <= MAX_COMMAND_SIZE
-+	u8	CDB[16];		// Command Data Block
-+};
-+
-+#define USB_BULK_CB_WRAP_LEN	31
-+#define USB_BULK_CB_SIG		0x43425355	// Spells out USBC
-+#define USB_BULK_IN_FLAG	0x80
-+
-+/* Command Status Wrapper */
-+struct bulk_cs_wrap {
-+	u32	Signature;		// Should = 'USBS'
-+	u32	Tag;			// Same as original command
-+	u32	Residue;		// Amount not transferred
-+	u8	Status;			// See below
-+};
-+
-+#define USB_BULK_CS_WRAP_LEN	13
-+#define USB_BULK_CS_SIG		0x53425355	// Spells out 'USBS'
-+#define USB_STATUS_PASS		0
-+#define USB_STATUS_FAIL		1
-+#define USB_STATUS_PHASE_ERROR	2
-+
-+/* Bulk-only class specific requests */
-+#define USB_BULK_RESET_REQUEST		0xff
-+#define USB_BULK_GET_MAX_LUN_REQUEST	0xfe
-+
-+
-+/* CBI Interrupt data structure */
-+struct interrupt_data {
-+	u8	bType;
-+	u8	bValue;
-+};
-+
-+#define CBI_INTERRUPT_DATA_LEN		2
-+
-+/* CBI Accept Device-Specific Command request */
-+#define USB_CBI_ADSC_REQUEST		0x00
-+
-+
-+#define MAX_COMMAND_SIZE	16	// Length of a SCSI Command Data Block
-+
-+/* SCSI commands that we recognize */
-+#define SC_FORMAT_UNIT			0x04
-+#define SC_INQUIRY			0x12
-+#define SC_MODE_SELECT_6		0x15
-+#define SC_MODE_SELECT_10		0x55
-+#define SC_MODE_SENSE_6			0x1a
-+#define SC_MODE_SENSE_10		0x5a
-+#define SC_PREVENT_ALLOW_MEDIUM_REMOVAL	0x1e
-+#define SC_READ_6			0x08
-+#define SC_READ_10			0x28
-+#define SC_READ_12			0xa8
-+#define SC_READ_CAPACITY		0x25
-+#define SC_READ_FORMAT_CAPACITIES	0x23
-+#define SC_RELEASE			0x17
-+#define SC_REQUEST_SENSE		0x03
-+#define SC_RESERVE			0x16
-+#define SC_SEND_DIAGNOSTIC		0x1d
-+#define SC_START_STOP_UNIT		0x1b
-+#define SC_SYNCHRONIZE_CACHE		0x35
-+#define SC_TEST_UNIT_READY		0x00
-+#define SC_VERIFY			0x2f
-+#define SC_WRITE_6			0x0a
-+#define SC_WRITE_10			0x2a
-+#define SC_WRITE_12			0xaa
-+
-+/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
-+#define SS_NO_SENSE				0
-+#define SS_COMMUNICATION_FAILURE		0x040800
-+#define SS_INVALID_COMMAND			0x052000
-+#define SS_INVALID_FIELD_IN_CDB			0x052400
-+#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE	0x052100
-+#define SS_LOGICAL_UNIT_NOT_SUPPORTED		0x052500
-+#define SS_MEDIUM_NOT_PRESENT			0x023a00
-+#define SS_MEDIUM_REMOVAL_PREVENTED		0x055302
-+#define SS_NOT_READY_TO_READY_TRANSITION	0x062800
-+#define SS_RESET_OCCURRED			0x062900
-+#define SS_SAVING_PARAMETERS_NOT_SUPPORTED	0x053900
-+#define SS_UNRECOVERED_READ_ERROR		0x031100
-+#define SS_WRITE_ERROR				0x030c02
-+#define SS_WRITE_PROTECTED			0x072700
-+
-+#define SK(x)		((u8) ((x) >> 16))	// Sense Key byte, etc.
-+#define ASC(x)		((u8) ((x) >> 8))
-+#define ASCQ(x)		((u8) (x))
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ * These definitions will permit the compiler to avoid generating code for
-+ * parts of the driver that aren't used in the non-TEST version.  Even gcc
-+ * can recognize when a test of a constant expression yields a dead code
-+ * path.
-+ *
-+ * Also, in the non-TEST version, open_backing_file() is only used during
-+ * initialization and the sysfs attribute store_xxx routines aren't used
-+ * at all.  We will define NORMALLY_INIT to mark them as __init so they
-+ * don't occupy kernel code space unnecessarily.
-+ */
-+
-+#ifdef CONFIG_USB_FILE_STORAGE_TEST
-+
-+#define transport_is_bbb()	(mod_data.transport_type == USB_PR_BULK)
-+#define transport_is_cbi()	(mod_data.transport_type == USB_PR_CBI)
-+#define protocol_is_scsi()	(mod_data.protocol_type == USB_SC_SCSI)
-+#define backing_file_is_open(curlun)	((curlun)->filp != NULL)
-+#define NORMALLY_INIT
-+
-+#else
-+
-+#define transport_is_bbb()	1
-+#define transport_is_cbi()	0
-+#define protocol_is_scsi()	1
-+#define backing_file_is_open(curlun)	1
-+#define NORMALLY_INIT		__init
-+
-+#endif /* CONFIG_USB_FILE_STORAGE_TEST */
-+
-+
-+struct lun {
-+	struct file	*filp;
-+	loff_t		file_length;
-+	loff_t		num_sectors;
-+
-+	unsigned int	ro : 1;
-+	unsigned int	prevent_medium_removal : 1;
-+	unsigned int	registered : 1;
-+
-+	u32		sense_data;
-+	u32		sense_data_info;
-+	u32		unit_attention_data;
-+
-+#define BUS_ID_SIZE	20
-+	struct __lun_device {
-+		char	name[BUS_ID_SIZE];
-+		void	*driver_data;
-+	} dev;
-+};
-+
-+
-+/* Big enough to hold our biggest descriptor */
-+#define EP0_BUFSIZE	256
-+#define DELAYED_STATUS	(EP0_BUFSIZE + 999)	// An impossibly large value
-+
-+/* Number of buffers we will use.  2 is enough for double-buffering */
-+#define NUM_BUFFERS	2
-+
-+enum fsg_buffer_state {
-+	BUF_STATE_EMPTY = 0,
-+	BUF_STATE_FULL,
-+	BUF_STATE_BUSY
-+};
-+
-+struct fsg_buffhd {
-+	void				*buf;
-+	dma_addr_t			dma;
-+	volatile enum fsg_buffer_state	state;
-+	struct fsg_buffhd		*next;
-+
-+	/* The NetChip 2280 is faster, and handles some protocol faults
-+	 * better, if we don't submit any short bulk-out read requests.
-+	 * So we will record the intended request length here. */
-+	unsigned int			bulk_out_intended_length;
-+
-+	struct usb_request		*inreq;
-+	volatile int			inreq_busy;
-+	struct usb_request		*outreq;
-+	volatile int			outreq_busy;
-+};
-+
-+enum fsg_state {
-+	FSG_STATE_COMMAND_PHASE = -10,		// This one isn't used anywhere
-+	FSG_STATE_DATA_PHASE,
-+	FSG_STATE_STATUS_PHASE,
-+
-+	FSG_STATE_IDLE = 0,
-+	FSG_STATE_ABORT_BULK_OUT,
-+	FSG_STATE_RESET,
-+	FSG_STATE_INTERFACE_CHANGE,
-+	FSG_STATE_CONFIG_CHANGE,
-+	FSG_STATE_DISCONNECT,
-+	FSG_STATE_EXIT,
-+	FSG_STATE_TERMINATED
-+};
-+
-+enum data_direction {
-+	DATA_DIR_UNKNOWN = 0,
-+	DATA_DIR_FROM_HOST,
-+	DATA_DIR_TO_HOST,
-+	DATA_DIR_NONE
-+};
-+
-+struct fsg_dev {
-+	/* lock protects: state, all the req_busy's, and cbbuf_cmnd */
-+	spinlock_t		lock;
-+	struct usb_gadget	*gadget;
-+
-+	/* filesem protects: backing files in use */
-+	struct rw_semaphore	filesem;
-+
-+	struct usb_ep		*ep0;		// Handy copy of gadget->ep0
-+	struct usb_request	*ep0req;	// For control responses
-+	volatile unsigned int	ep0_req_tag;
-+	const char		*ep0req_name;
-+
-+	struct usb_request	*intreq;	// For interrupt responses
-+	volatile int		intreq_busy;
-+	struct fsg_buffhd	*intr_buffhd;
-+
-+ 	unsigned int		bulk_out_maxpacket;
-+	enum fsg_state		state;		// For exception handling
-+	unsigned int		exception_req_tag;
-+
-+	u8			config, new_config;
-+
-+	unsigned int		running : 1;
-+	unsigned int		bulk_in_enabled : 1;
-+	unsigned int		bulk_out_enabled : 1;
-+	unsigned int		intr_in_enabled : 1;
-+	unsigned int		phase_error : 1;
-+	unsigned int		short_packet_received : 1;
-+	unsigned int		bad_lun_okay : 1;
-+
-+	unsigned long		atomic_bitflags;
-+#define REGISTERED		0
-+#define CLEAR_BULK_HALTS	1
-+
-+	struct usb_ep		*bulk_in;
-+	struct usb_ep		*bulk_out;
-+	struct usb_ep		*intr_in;
-+
-+	struct fsg_buffhd	*next_buffhd_to_fill;
-+	struct fsg_buffhd	*next_buffhd_to_drain;
-+	struct fsg_buffhd	buffhds[NUM_BUFFERS];
-+
-+	wait_queue_head_t	thread_wqh;
-+	int			thread_wakeup_needed;
-+	struct completion	thread_notifier;
-+	int			thread_pid;
-+	struct task_struct	*thread_task;
-+	sigset_t		thread_signal_mask;
-+
-+	int			cmnd_size;
-+	u8			cmnd[MAX_COMMAND_SIZE];
-+	enum data_direction	data_dir;
-+	u32			data_size;
-+	u32			data_size_from_cmnd;
-+	u32			tag;
-+	unsigned int		lun;
-+	u32			residue;
-+	u32			usb_amount_left;
-+
-+	/* The CB protocol offers no way for a host to know when a command
-+	 * has completed.  As a result the next command may arrive early,
-+	 * and we will still have to handle it.  For that reason we need
-+	 * a buffer to store new commands when using CB (or CBI, which
-+	 * does not oblige a host to wait for command completion either). */
-+	int			cbbuf_cmnd_size;
-+	u8			cbbuf_cmnd[MAX_COMMAND_SIZE];
-+
-+	unsigned int		nluns;
-+	struct lun		*luns;
-+	struct lun		*curlun;
-+};
-+
-+typedef void (*fsg_routine_t)(struct fsg_dev *);
-+
-+static int inline exception_in_progress(struct fsg_dev *fsg)
-+{
-+	return (fsg->state > FSG_STATE_IDLE);
-+}
-+
-+/* Make bulk-out requests be divisible by the maxpacket size */
-+static void inline set_bulk_out_req_length(struct fsg_dev *fsg,
-+		struct fsg_buffhd *bh, unsigned int length)
-+{
-+	unsigned int	rem;
-+
-+	bh->bulk_out_intended_length = length;
-+	rem = length % fsg->bulk_out_maxpacket;
-+	if (rem > 0)
-+		length += fsg->bulk_out_maxpacket - rem;
-+	bh->outreq->length = length;
-+}
-+
-+static struct fsg_dev			*the_fsg;
-+static struct usb_gadget_driver		fsg_driver;
-+
-+static void	close_backing_file(struct lun *curlun);
-+static void	close_all_backing_files(struct fsg_dev *fsg);
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#ifdef DUMP_MSGS
-+
-+static void dump_msg(struct fsg_dev *fsg, const char *label,
-+		const u8 *buf, unsigned int length)
-+{
-+	unsigned int	start, num, i;
-+	char		line[52], *p;
-+
-+	if (length >= 512)
-+		return;
-+	DBG(fsg, "%s, length %u:\n", label, length);
-+
-+	start = 0;
-+	while (length > 0) {
-+		num = min(length, 16u);
-+		p = line;
-+		for (i = 0; i < num; ++i) {
-+			if (i == 8)
-+				*p++ = ' ';
-+			sprintf(p, " %02x", buf[i]);
-+			p += 3;
-+		}
-+		*p = 0;
-+		printk(KERN_DEBUG "%6x: %s\n", start, line);
-+		buf += num;
-+		start += num;
-+		length -= num;
-+	}
-+}
-+
-+static void inline dump_cdb(struct fsg_dev *fsg)
-+{}
-+
-+#else
-+
-+static void inline dump_msg(struct fsg_dev *fsg, const char *label,
-+		const u8 *buf, unsigned int length)
-+{}
-+
-+static void inline dump_cdb(struct fsg_dev *fsg)
-+{
-+	int	i;
-+	char	cmdbuf[3*MAX_COMMAND_SIZE + 1];
-+
-+	for (i = 0; i < fsg->cmnd_size; ++i)
-+		sprintf(cmdbuf + i*3, " %02x", fsg->cmnd[i]);
-+	VDBG(fsg, "SCSI CDB: %s\n", cmdbuf);
-+}
-+
-+#endif /* DUMP_MSGS */
-+
-+
-+static int fsg_set_halt(struct fsg_dev *fsg, struct usb_ep *ep)
-+{
-+	const char	*name;
-+
-+	if (ep == fsg->bulk_in)
-+		name = "bulk-in";
-+	else if (ep == fsg->bulk_out)
-+		name = "bulk-out";
-+	else
-+		name = ep->name;
-+	DBG(fsg, "%s set halt\n", name);
-+	return usb_ep_set_halt(ep);
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* Routines for unaligned data access */
-+
-+static u16 inline get_be16(u8 *buf)
-+{
-+	return ((u16) buf[0] << 8) | ((u16) buf[1]);
-+}
-+
-+static u32 inline get_be32(u8 *buf)
-+{
-+	return ((u32) buf[0] << 24) | ((u32) buf[1] << 16) |
-+			((u32) buf[2] << 8) | ((u32) buf[3]);
-+}
-+
-+static void inline put_be16(u8 *buf, u16 val)
-+{
-+	buf[0] = val >> 8;
-+	buf[1] = val;
-+}
-+
-+static void inline put_be32(u8 *buf, u32 val)
-+{
-+	buf[0] = val >> 24;
-+	buf[1] = val >> 16;
-+	buf[2] = val >> 8;
-+	buf[3] = val;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ * DESCRIPTORS ... most are static, but strings and (full) configuration
-+ * descriptors are built on demand.  Also the (static) config and interface
-+ * descriptors are adjusted during fsg_bind().
-+ */
-+#define STRING_MANUFACTURER	1
-+#define STRING_PRODUCT		2
-+#define STRING_SERIAL		3
-+
-+/* There is only one configuration. */
-+#define	CONFIG_VALUE		1
-+
-+static struct usb_device_descriptor
-+device_desc = {
-+	.bLength =		sizeof device_desc,
-+	.bDescriptorType =	USB_DT_DEVICE,
-+
-+	.bcdUSB =		__constant_cpu_to_le16(0x0200),
-+	.bDeviceClass =		USB_CLASS_PER_INTERFACE,
-+
-+	/* The next three values can be overridden by module parameters */
-+	.idVendor =		__constant_cpu_to_le16(DRIVER_VENDOR_ID),
-+	.idProduct =		__constant_cpu_to_le16(DRIVER_PRODUCT_ID),
-+	.bcdDevice =		__constant_cpu_to_le16(0xffff),
-+
-+	.iManufacturer =	STRING_MANUFACTURER,
-+	.iProduct =		STRING_PRODUCT,
-+	.iSerialNumber =	STRING_SERIAL,
-+	.bNumConfigurations =	1,
-+};
-+
-+static struct usb_config_descriptor
-+config_desc = {
-+	.bLength =		sizeof config_desc,
-+	.bDescriptorType =	USB_DT_CONFIG,
-+
-+	/* wTotalLength computed by usb_gadget_config_buf() */
-+	.bNumInterfaces =	1,
-+	.bConfigurationValue =	CONFIG_VALUE,
-+	.bmAttributes =		USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
-+	.bMaxPower =		1,	// self-powered
-+};
-+
-+/* There is only one interface. */
-+
-+static struct usb_interface_descriptor
-+intf_desc = {
-+	.bLength =		sizeof intf_desc,
-+	.bDescriptorType =	USB_DT_INTERFACE,
-+
-+	.bNumEndpoints =	2,		// Adjusted during fsg_bind()
-+	.bInterfaceClass =	USB_CLASS_MASS_STORAGE,
-+	.bInterfaceSubClass =	USB_SC_SCSI,	// Adjusted during fsg_bind()
-+	.bInterfaceProtocol =	USB_PR_BULK,	// Adjusted during fsg_bind()
-+};
-+
-+/* Three full-speed endpoint descriptors: bulk-in, bulk-out,
-+ * and interrupt-in. */
-+
-+static struct usb_endpoint_descriptor
-+fs_bulk_in_desc = {
-+	.bLength =		USB_DT_ENDPOINT_SIZE,
-+	.bDescriptorType =	USB_DT_ENDPOINT,
-+
-+	.bEndpointAddress =	USB_DIR_IN,
-+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
-+	/* wMaxPacketSize set by autoconfiguration */
-+};
-+
-+static struct usb_endpoint_descriptor
-+fs_bulk_out_desc = {
-+	.bLength =		USB_DT_ENDPOINT_SIZE,
-+	.bDescriptorType =	USB_DT_ENDPOINT,
-+
-+	.bEndpointAddress =	USB_DIR_OUT,
-+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
-+	/* wMaxPacketSize set by autoconfiguration */
-+};
-+
-+static struct usb_endpoint_descriptor
-+fs_intr_in_desc = {
-+	.bLength =		USB_DT_ENDPOINT_SIZE,
-+	.bDescriptorType =	USB_DT_ENDPOINT,
-+
-+	.bEndpointAddress =	USB_DIR_IN,
-+	.bmAttributes =		USB_ENDPOINT_XFER_INT,
-+	.wMaxPacketSize =	__constant_cpu_to_le16(2),
-+	.bInterval =		32,	// frames -> 32 ms
-+};
-+
-+static const struct usb_descriptor_header *fs_function[] = {
-+	(struct usb_descriptor_header *) &intf_desc,
-+	(struct usb_descriptor_header *) &fs_bulk_in_desc,
-+	(struct usb_descriptor_header *) &fs_bulk_out_desc,
-+	(struct usb_descriptor_header *) &fs_intr_in_desc,
-+	NULL,
-+};
-+
-+
-+#ifdef	CONFIG_USB_GADGET_DUALSPEED
-+
-+/*
-+ * 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_qualifier_descriptor
-+dev_qualifier = {
-+	.bLength =		sizeof dev_qualifier,
-+	.bDescriptorType =	USB_DT_DEVICE_QUALIFIER,
-+
-+	.bcdUSB =		__constant_cpu_to_le16(0x0200),
-+	.bDeviceClass =		USB_CLASS_PER_INTERFACE,
-+
-+	.bNumConfigurations =	1,
-+};
-+
-+static struct usb_endpoint_descriptor
-+hs_bulk_in_desc = {
-+	.bLength =		USB_DT_ENDPOINT_SIZE,
-+	.bDescriptorType =	USB_DT_ENDPOINT,
-+
-+	/* bEndpointAddress copied from fs_bulk_in_desc during fsg_bind() */
-+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
-+	.wMaxPacketSize =	__constant_cpu_to_le16(512),
-+};
-+
-+static struct usb_endpoint_descriptor
-+hs_bulk_out_desc = {
-+	.bLength =		USB_DT_ENDPOINT_SIZE,
-+	.bDescriptorType =	USB_DT_ENDPOINT,
-+
-+	/* bEndpointAddress copied from fs_bulk_out_desc during fsg_bind() */
-+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
-+	.wMaxPacketSize =	__constant_cpu_to_le16(512),
-+	.bInterval =		1,	// NAK every 1 uframe
-+};
-+
-+static struct usb_endpoint_descriptor
-+hs_intr_in_desc = {
-+	.bLength =		USB_DT_ENDPOINT_SIZE,
-+	.bDescriptorType =	USB_DT_ENDPOINT,
-+
-+	/* bEndpointAddress copied from fs_intr_in_desc during fsg_bind() */
-+	.bmAttributes =		USB_ENDPOINT_XFER_INT,
-+	.wMaxPacketSize =	__constant_cpu_to_le16(2),
-+	.bInterval =		9,	// 2**(9-1) = 256 uframes -> 32 ms
-+};
-+
-+static const struct usb_descriptor_header *hs_function[] = {
-+	(struct usb_descriptor_header *) &intf_desc,
-+	(struct usb_descriptor_header *) &hs_bulk_in_desc,
-+	(struct usb_descriptor_header *) &hs_bulk_out_desc,
-+	(struct usb_descriptor_header *) &hs_intr_in_desc,
-+	NULL,
-+};
-+
-+/* Maxpacket and other transfer characteristics vary by speed. */
-+#define ep_desc(g,fs,hs)	(((g)->speed==USB_SPEED_HIGH) ? (hs) : (fs))
-+
-+#else
-+
-+/* If there's no high speed support, always use the full-speed descriptor. */
-+#define ep_desc(g,fs,hs)	fs
-+
-+#endif	/* !CONFIG_USB_GADGET_DUALSPEED */
-+
-+
-+/* The CBI specification limits the serial string to 12 uppercase hexadecimal
-+ * characters. */
-+static char				manufacturer[40];
-+static char				serial[13];
-+
-+/* Static strings, in UTF-8 (for simplicity we use only ASCII characters) */
-+static struct usb_string		strings[] = {
-+	{STRING_MANUFACTURER,	manufacturer},
-+	{STRING_PRODUCT,	longname},
-+	{STRING_SERIAL,		serial},
-+	{}
-+};
-+
-+static struct usb_gadget_strings	stringtab = {
-+	.language	= 0x0409,		// en-us
-+	.strings	= strings,
-+};
-+
-+
-+/*
-+ * Config descriptors must agree with the code that sets configurations
-+ * and with code managing interfaces and their altsettings.  They must
-+ * also handle different speeds and other-speed requests.
-+ */
-+static int populate_config_buf(enum usb_device_speed speed,
-+		u8 *buf, u8 type, unsigned index)
-+{
-+	int					len;
-+	const struct usb_descriptor_header	**function;
-+
-+	if (index > 0)
-+		return -EINVAL;
-+
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+	if (type == USB_DT_OTHER_SPEED_CONFIG)
-+		speed = (USB_SPEED_FULL + USB_SPEED_HIGH) - speed;
-+	if (speed == USB_SPEED_HIGH)
-+		function = hs_function;
-+	else
-+#endif
-+		function = fs_function;
-+
-+	len = usb_gadget_config_buf(&config_desc, buf, EP0_BUFSIZE, function);
-+	if (len < 0)
-+		return len;
-+	((struct usb_config_descriptor *) buf)->bDescriptorType = type;
-+	return len;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* These routines may be called in process context or in_irq */
-+
-+static void wakeup_thread(struct fsg_dev *fsg)
-+{
-+	/* Tell the main thread that something has happened */
-+	fsg->thread_wakeup_needed = 1;
-+	wake_up_all(&fsg->thread_wqh);
-+}
-+
-+
-+static void raise_exception(struct fsg_dev *fsg, enum fsg_state new_state)
-+{
-+	unsigned long		flags;
-+	struct task_struct	*thread_task;
-+
-+	/* Do nothing if a higher-priority exception is already in progress.
-+	 * If a lower-or-equal priority exception is in progress, preempt it
-+	 * and notify the main thread by sending it a signal. */
-+	spin_lock_irqsave(&fsg->lock, flags);
-+	if (fsg->state <= new_state) {
-+		fsg->exception_req_tag = fsg->ep0_req_tag;
-+		fsg->state = new_state;
-+		thread_task = fsg->thread_task;
-+		if (thread_task)
-+			send_sig_info(SIGUSR1, (void *) 1L, thread_task);
-+	}
-+	spin_unlock_irqrestore(&fsg->lock, flags);
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* The disconnect callback and ep0 routines.  These always run in_irq,
-+ * except that ep0_queue() is called in the main thread to acknowledge
-+ * completion of various requests: set config, set interface, and
-+ * Bulk-only device reset. */
-+
-+static void fsg_disconnect(struct usb_gadget *gadget)
-+{
-+	struct fsg_dev		*fsg = get_gadget_data(gadget);
-+
-+	DBG(fsg, "disconnect or port reset\n");
-+	raise_exception(fsg, FSG_STATE_DISCONNECT);
-+}
-+
-+
-+static int ep0_queue(struct fsg_dev *fsg)
-+{
-+	int	rc;
-+
-+	rc = usb_ep_queue(fsg->ep0, fsg->ep0req, GFP_ATOMIC);
-+	if (rc != 0 && rc != -ESHUTDOWN) {
-+
-+		/* We can't do much more than wait for a reset */
-+		WARN(fsg, "error in submission: %s --> %d\n",
-+				fsg->ep0->name, rc);
-+	}
-+	return rc;
-+}
-+
-+static void ep0_complete(struct usb_ep *ep, struct usb_request *req)
-+{
-+	struct fsg_dev		*fsg = (struct fsg_dev *) ep->driver_data;
-+
-+	if (req->actual > 0)
-+		dump_msg(fsg, fsg->ep0req_name, req->buf, req->actual);
-+	if (req->status || req->actual != req->length)
-+		DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
-+				req->status, req->actual, req->length);
-+	if (req->status == -ECONNRESET)		// Request was cancelled
-+		usb_ep_fifo_flush(ep);
-+
-+	if (req->status == 0 && req->context)
-+		((fsg_routine_t) (req->context))(fsg);
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* Bulk and interrupt endpoint completion handlers.
-+ * These always run in_irq. */
-+
-+static void bulk_in_complete(struct usb_ep *ep, struct usb_request *req)
-+{
-+	struct fsg_dev		*fsg = (struct fsg_dev *) ep->driver_data;
-+	struct fsg_buffhd	*bh = (struct fsg_buffhd *) req->context;
-+
-+	if (req->status || req->actual != req->length)
-+		DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
-+				req->status, req->actual, req->length);
-+	if (req->status == -ECONNRESET)		// Request was cancelled
-+		usb_ep_fifo_flush(ep);
-+
-+	/* Hold the lock while we update the request and buffer states */
-+	spin_lock(&fsg->lock);
-+	bh->inreq_busy = 0;
-+	bh->state = BUF_STATE_EMPTY;
-+	spin_unlock(&fsg->lock);
-+	wakeup_thread(fsg);
-+}
-+
-+static void bulk_out_complete(struct usb_ep *ep, struct usb_request *req)
-+{
-+	struct fsg_dev		*fsg = (struct fsg_dev *) ep->driver_data;
-+	struct fsg_buffhd	*bh = (struct fsg_buffhd *) req->context;
-+
-+	dump_msg(fsg, "bulk-out", req->buf, req->actual);
-+	if (req->status || req->actual != bh->bulk_out_intended_length)
-+		DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
-+				req->status, req->actual,
-+				bh->bulk_out_intended_length);
-+	if (req->status == -ECONNRESET)		// Request was cancelled
-+		usb_ep_fifo_flush(ep);
-+
-+	/* Hold the lock while we update the request and buffer states */
-+	spin_lock(&fsg->lock);
-+	bh->outreq_busy = 0;
-+	bh->state = BUF_STATE_FULL;
-+	spin_unlock(&fsg->lock);
-+	wakeup_thread(fsg);
-+}
-+
-+static void intr_in_complete(struct usb_ep *ep, struct usb_request *req)
-+{
-+#ifdef CONFIG_USB_FILE_STORAGE_TEST
-+	struct fsg_dev		*fsg = (struct fsg_dev *) ep->driver_data;
-+	struct fsg_buffhd	*bh = (struct fsg_buffhd *) req->context;
-+
-+	if (req->status || req->actual != req->length)
-+		DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
-+				req->status, req->actual, req->length);
-+	if (req->status == -ECONNRESET)		// Request was cancelled
-+		usb_ep_fifo_flush(ep);
-+
-+	/* Hold the lock while we update the request and buffer states */
-+	spin_lock(&fsg->lock);
-+	fsg->intreq_busy = 0;
-+	bh->state = BUF_STATE_EMPTY;
-+	spin_unlock(&fsg->lock);
-+	wakeup_thread(fsg);
-+#endif /* CONFIG_USB_FILE_STORAGE_TEST */
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* Ep0 class-specific handlers.  These always run in_irq. */
-+
-+static void received_cbi_adsc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
-+{
-+#ifdef CONFIG_USB_FILE_STORAGE_TEST
-+	struct usb_request	*req = fsg->ep0req;
-+	static u8		cbi_reset_cmnd[6] = {
-+			SC_SEND_DIAGNOSTIC, 4, 0xff, 0xff, 0xff, 0xff};
-+
-+	/* Error in command transfer? */
-+	if (req->status || req->length != req->actual ||
-+			req->actual < 6 || req->actual > MAX_COMMAND_SIZE) {
-+
-+		/* Not all controllers allow a protocol stall after
-+		 * receiving control-out data, but we'll try anyway. */
-+		fsg_set_halt(fsg, fsg->ep0);
-+		return;			// Wait for reset
-+	}
-+
-+	/* Is it the special reset command? */
-+	if (req->actual >= sizeof cbi_reset_cmnd &&
-+			memcmp(req->buf, cbi_reset_cmnd,
-+				sizeof cbi_reset_cmnd) == 0) {
-+
-+		/* Raise an exception to stop the current operation
-+		 * and reinitialize our state. */
-+		DBG(fsg, "cbi reset request\n");
-+		raise_exception(fsg, FSG_STATE_RESET);
-+		return;
-+	}
-+
-+	VDBG(fsg, "CB[I] accept device-specific command\n");
-+	spin_lock(&fsg->lock);
-+
-+	/* Save the command for later */
-+	if (fsg->cbbuf_cmnd_size)
-+		WARN(fsg, "CB[I] overwriting previous command\n");
-+	fsg->cbbuf_cmnd_size = req->actual;
-+	memcpy(fsg->cbbuf_cmnd, req->buf, fsg->cbbuf_cmnd_size);
-+
-+	spin_unlock(&fsg->lock);
-+	wakeup_thread(fsg);
-+#endif /* CONFIG_USB_FILE_STORAGE_TEST */
-+}
-+
-+
-+static int class_setup_req(struct fsg_dev *fsg,
-+		const struct usb_ctrlrequest *ctrl)
-+{
-+	struct usb_request	*req = fsg->ep0req;
-+	int			value = -EOPNOTSUPP;
-+
-+	if (!fsg->config)
-+		return value;
-+
-+	/* Handle Bulk-only class-specific requests */
-+	if (transport_is_bbb()) {
-+		switch (ctrl->bRequest) {
-+
-+		case USB_BULK_RESET_REQUEST:
-+			if (ctrl->bRequestType != (USB_DIR_OUT |
-+					USB_TYPE_CLASS | USB_RECIP_INTERFACE))
-+				break;
-+			if (ctrl->wIndex != 0) {
-+				value = -EDOM;
-+				break;
-+			}
-+
-+			/* Raise an exception to stop the current operation
-+			 * and reinitialize our state. */
-+			DBG(fsg, "bulk reset request\n");
-+			raise_exception(fsg, FSG_STATE_RESET);
-+			value = DELAYED_STATUS;
-+			break;
-+
-+		case USB_BULK_GET_MAX_LUN_REQUEST:
-+			if (ctrl->bRequestType != (USB_DIR_IN |
-+					USB_TYPE_CLASS | USB_RECIP_INTERFACE))
-+				break;
-+			if (ctrl->wIndex != 0) {
-+				value = -EDOM;
-+				break;
-+			}
-+			VDBG(fsg, "get max LUN\n");
-+			*(u8 *) req->buf = fsg->nluns - 1;
-+			value = min(ctrl->wLength, (u16) 1);
-+			break;
-+		}
-+	}
-+
-+	/* Handle CBI class-specific requests */
-+	else {
-+		switch (ctrl->bRequest) {
-+
-+		case USB_CBI_ADSC_REQUEST:
-+			if (ctrl->bRequestType != (USB_DIR_OUT |
-+					USB_TYPE_CLASS | USB_RECIP_INTERFACE))
-+				break;
-+			if (ctrl->wIndex != 0) {
-+				value = -EDOM;
-+				break;
-+			}
-+			if (ctrl->wLength > MAX_COMMAND_SIZE) {
-+				value = -EOVERFLOW;
-+				break;
-+			}
-+			value = ctrl->wLength;
-+			fsg->ep0req->context = received_cbi_adsc;
-+			break;
-+		}
-+	}
-+
-+	if (value == -EOPNOTSUPP)
-+		VDBG(fsg,
-+			"unknown class-specific control req "
-+			"%02x.%02x v%04x i%04x l%u\n",
-+			ctrl->bRequestType, ctrl->bRequest,
-+			ctrl->wValue, ctrl->wIndex, ctrl->wLength);
-+	return value;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* Ep0 standard request handlers.  These always run in_irq. */
-+
-+static int standard_setup_req(struct fsg_dev *fsg,
-+		const struct usb_ctrlrequest *ctrl)
-+{
-+	struct usb_request	*req = fsg->ep0req;
-+	int			value = -EOPNOTSUPP;
-+
-+	/* Usually this just stores reply data in the pre-allocated ep0 buffer,
-+	 * but config change events will also reconfigure hardware. */
-+	switch (ctrl->bRequest) {
-+
-+	case USB_REQ_GET_DESCRIPTOR:
-+		if (ctrl->bRequestType != (USB_DIR_IN | USB_TYPE_STANDARD |
-+				USB_RECIP_DEVICE))
-+			break;
-+		switch (ctrl->wValue >> 8) {
-+
-+		case USB_DT_DEVICE:
-+			VDBG(fsg, "get device descriptor\n");
-+			value = min(ctrl->wLength, (u16) sizeof device_desc);
-+			memcpy(req->buf, &device_desc, value);
-+			break;
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+		case USB_DT_DEVICE_QUALIFIER:
-+			VDBG(fsg, "get device qualifier\n");
-+			if (!fsg->gadget->is_dualspeed)
-+				break;
-+			value = min(ctrl->wLength, (u16) sizeof dev_qualifier);
-+			memcpy(req->buf, &dev_qualifier, value);
-+			break;
-+
-+		case USB_DT_OTHER_SPEED_CONFIG:
-+			VDBG(fsg, "get other-speed config descriptor\n");
-+			if (!fsg->gadget->is_dualspeed)
-+				break;
-+			goto get_config;
-+#endif
-+		case USB_DT_CONFIG:
-+			VDBG(fsg, "get configuration descriptor\n");
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+		get_config:
-+#endif
-+			value = populate_config_buf(fsg->gadget->speed,
-+					req->buf,
-+					ctrl->wValue >> 8,
-+					ctrl->wValue & 0xff);
-+			if (value >= 0)
-+				value = min(ctrl->wLength, (u16) value);
-+			break;
-+
-+		case USB_DT_STRING:
-+			VDBG(fsg, "get string descriptor\n");
-+
-+			/* wIndex == language code */
-+			value = usb_gadget_get_string(&stringtab,
-+					ctrl->wValue & 0xff, req->buf);
-+			if (value >= 0)
-+				value = min(ctrl->wLength, (u16) value);
-+			break;
-+		}
-+		break;
-+
-+	/* One config, two speeds */
-+	case USB_REQ_SET_CONFIGURATION:
-+		if (ctrl->bRequestType != (USB_DIR_OUT | USB_TYPE_STANDARD |
-+				USB_RECIP_DEVICE))
-+			break;
-+		VDBG(fsg, "set configuration\n");
-+		if (ctrl->wValue == CONFIG_VALUE || ctrl->wValue == 0) {
-+			fsg->new_config = ctrl->wValue;
-+
-+			/* Raise an exception to wipe out previous transaction
-+			 * state (queued bufs, etc) and set the new config. */
-+			raise_exception(fsg, FSG_STATE_CONFIG_CHANGE);
-+			value = DELAYED_STATUS;
-+		}
-+		break;
-+	case USB_REQ_GET_CONFIGURATION:
-+		if (ctrl->bRequestType != (USB_DIR_IN | USB_TYPE_STANDARD |
-+				USB_RECIP_DEVICE))
-+			break;
-+		VDBG(fsg, "get configuration\n");
-+		*(u8 *) req->buf = fsg->config;
-+		value = min(ctrl->wLength, (u16) 1);
-+		break;
-+
-+	case USB_REQ_SET_INTERFACE:
-+		if (ctrl->bRequestType != (USB_DIR_OUT| USB_TYPE_STANDARD |
-+				USB_RECIP_INTERFACE))
-+			break;
-+		if (fsg->config && ctrl->wIndex == 0) {
-+
-+			/* Raise an exception to wipe out previous transaction
-+			 * state (queued bufs, etc) and install the new
-+			 * interface altsetting. */
-+			raise_exception(fsg, FSG_STATE_INTERFACE_CHANGE);
-+			value = DELAYED_STATUS;
-+		}
-+		break;
-+	case USB_REQ_GET_INTERFACE:
-+		if (ctrl->bRequestType != (USB_DIR_IN | USB_TYPE_STANDARD |
-+				USB_RECIP_INTERFACE))
-+			break;
-+		if (!fsg->config)
-+			break;
-+		if (ctrl->wIndex != 0) {
-+			value = -EDOM;
-+			break;
-+		}
-+		VDBG(fsg, "get interface\n");
-+		*(u8 *) req->buf = 0;
-+		value = min(ctrl->wLength, (u16) 1);
-+		break;
-+
-+	default:
-+		VDBG(fsg,
-+			"unknown control req %02x.%02x v%04x i%04x l%u\n",
-+			ctrl->bRequestType, ctrl->bRequest,
-+			ctrl->wValue, ctrl->wIndex, ctrl->wLength);
-+	}
-+
-+	return value;
-+}
-+
-+
-+static int fsg_setup(struct usb_gadget *gadget,
-+		const struct usb_ctrlrequest *ctrl)
-+{
-+	struct fsg_dev		*fsg = get_gadget_data(gadget);
-+	int			rc;
-+
-+	++fsg->ep0_req_tag;		// Record arrival of a new request
-+	fsg->ep0req->context = NULL;
-+	fsg->ep0req->length = 0;
-+	dump_msg(fsg, "ep0-setup", (u8 *) ctrl, sizeof(*ctrl));
-+
-+	if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_CLASS)
-+		rc = class_setup_req(fsg, ctrl);
-+	else
-+		rc = standard_setup_req(fsg, ctrl);
-+
-+	/* Respond with data/status or defer until later? */
-+	if (rc >= 0 && rc != DELAYED_STATUS) {
-+		fsg->ep0req->length = rc;
-+		fsg->ep0req_name = (ctrl->bRequestType & USB_DIR_IN ?
-+				"ep0-in" : "ep0-out");
-+		rc = ep0_queue(fsg);
-+	}
-+
-+	/* Device either stalls (rc < 0) or reports success */
-+	return rc;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* All the following routines run in process context */
-+
-+
-+/* Use this for bulk or interrupt transfers, not ep0 */
-+static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
-+		struct usb_request *req, volatile int *pbusy,
-+		volatile enum fsg_buffer_state *state)
-+{
-+	int	rc;
-+
-+	if (ep == fsg->bulk_in)
-+		dump_msg(fsg, "bulk-in", req->buf, req->length);
-+	else if (ep == fsg->intr_in)
-+		dump_msg(fsg, "intr-in", req->buf, req->length);
-+	*pbusy = 1;
-+	*state = BUF_STATE_BUSY;
-+	rc = usb_ep_queue(ep, req, GFP_KERNEL);
-+	if (rc != 0) {
-+		*pbusy = 0;
-+		*state = BUF_STATE_EMPTY;
-+
-+		/* We can't do much more than wait for a reset */
-+
-+		/* Note: currently the net2280 driver fails zero-length
-+		 * submissions if DMA is enabled. */
-+		if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP &&
-+						req->length == 0))
-+			WARN(fsg, "error in submission: %s --> %d\n",
-+					ep->name, rc);
-+	}
-+}
-+
-+
-+static int sleep_thread(struct fsg_dev *fsg)
-+{
-+	int	rc;
-+
-+	/* Wait until a signal arrives or we are woken up */
-+	rc = wait_event_interruptible(fsg->thread_wqh,
-+			fsg->thread_wakeup_needed);
-+	fsg->thread_wakeup_needed = 0;
-+	return (rc ? -EINTR : 0);
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int do_read(struct fsg_dev *fsg)
-+{
-+	struct lun		*curlun = fsg->curlun;
-+	u32			lba;
-+	struct fsg_buffhd	*bh;
-+	int			rc;
-+	u32			amount_left;
-+	loff_t			file_offset, file_offset_tmp;
-+	unsigned int		amount;
-+	unsigned int		partial_page;
-+	ssize_t			nread;
-+
-+	/* Get the starting Logical Block Address and check that it's
-+	 * not too big */
-+	if (fsg->cmnd[0] == SC_READ_6)
-+		lba = (fsg->cmnd[1] << 16) | get_be16(&fsg->cmnd[2]);
-+	else {
-+		lba = get_be32(&fsg->cmnd[2]);
-+
-+		/* We allow DPO (Disable Page Out = don't save data in the
-+		 * cache) and FUA (Force Unit Access = don't read from the
-+		 * cache), but we don't implement them. */
-+		if ((fsg->cmnd[1] & ~0x18) != 0) {
-+			curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
-+			return -EINVAL;
-+		}
-+	}
-+	if (lba >= curlun->num_sectors) {
-+		curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
-+		return -EINVAL;
-+	}
-+	file_offset = ((loff_t) lba) << 9;
-+
-+	/* Carry out the file reads */
-+	amount_left = fsg->data_size_from_cmnd;
-+	if (unlikely(amount_left == 0))
-+		return -EIO;		// No default reply
-+
-+	for (;;) {
-+
-+		/* Figure out how much we need to read:
-+		 * Try to read the remaining amount.
-+		 * But don't read more than the buffer size.
-+		 * And don't try to read past the end of the file.
-+		 * Finally, if we're not at a page boundary, don't read past
-+		 *	the next page.
-+		 * If this means reading 0 then we were asked to read past
-+		 *	the end of file. */
-+		amount = min((unsigned int) amount_left, mod_data.buflen);
-+		amount = min((loff_t) amount,
-+				curlun->file_length - file_offset);
-+		partial_page = file_offset & (PAGE_CACHE_SIZE - 1);
-+		if (partial_page > 0)
-+			amount = min(amount, (unsigned int) PAGE_CACHE_SIZE -
-+					partial_page);
-+
-+		/* Wait for the next buffer to become available */
-+		bh = fsg->next_buffhd_to_fill;
-+		while (bh->state != BUF_STATE_EMPTY) {
-+			if ((rc = sleep_thread(fsg)) != 0)
-+				return rc;
-+		}
-+
-+		/* If we were asked to read past the end of file,
-+		 * end with an empty buffer. */
-+		if (amount == 0) {
-+			curlun->sense_data =
-+					SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
-+			curlun->sense_data_info = file_offset >> 9;
-+			bh->inreq->length = 0;
-+			bh->state = BUF_STATE_FULL;
-+			break;
-+		}
-+
-+		/* Perform the read */
-+		file_offset_tmp = file_offset;
-+		nread = curlun->filp->f_op->read(curlun->filp,
-+				(char *) bh->buf,
-+				amount, &file_offset_tmp);
-+		VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
-+				(unsigned long long) file_offset,
-+				(int) nread);
-+		if (signal_pending(current))
-+			return -EINTR;
-+
-+		if (nread < 0) {
-+			LDBG(curlun, "error in file read: %d\n",
-+					(int) nread);
-+			nread = 0;
-+		} else if (nread < amount) {
-+			LDBG(curlun, "partial file read: %d/%u\n",
-+					(int) nread, amount);
-+			nread -= (nread & 511);	// Round down to a block
-+		}
-+		file_offset  += nread;
-+		amount_left  -= nread;
-+		fsg->residue -= nread;
-+		bh->inreq->length = nread;
-+		bh->state = BUF_STATE_FULL;
-+
-+		/* If an error occurred, report it and its position */
-+		if (nread < amount) {
-+			curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
-+			curlun->sense_data_info = file_offset >> 9;
-+			break;
-+		}
-+
-+		if (amount_left == 0)
-+			break;		// No more left to read
-+
-+		/* Send this buffer and go read some more */
-+		bh->inreq->zero = 0;
-+		start_transfer(fsg, fsg->bulk_in, bh->inreq,
-+				&bh->inreq_busy, &bh->state);
-+		fsg->next_buffhd_to_fill = bh->next;
-+	}
-+
-+	return -EIO;		// No default reply
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int do_write(struct fsg_dev *fsg)
-+{
-+	struct lun		*curlun = fsg->curlun;
-+	u32			lba;
-+	struct fsg_buffhd	*bh;
-+	int			get_some_more;
-+	u32			amount_left_to_req, amount_left_to_write;
-+	loff_t			usb_offset, file_offset, file_offset_tmp;
-+	unsigned int		amount;
-+	unsigned int		partial_page;
-+	ssize_t			nwritten;
-+	int			rc;
-+
-+	if (curlun->ro) {
-+		curlun->sense_data = SS_WRITE_PROTECTED;
-+		return -EINVAL;
-+	}
-+	curlun->filp->f_flags &= ~O_SYNC;	// Default is not to wait
-+
-+	/* Get the starting Logical Block Address and check that it's
-+	 * not too big */
-+	if (fsg->cmnd[0] == SC_WRITE_6)
-+		lba = (fsg->cmnd[1] << 16) | get_be16(&fsg->cmnd[2]);
-+	else {
-+		lba = get_be32(&fsg->cmnd[2]);
-+
-+		/* We allow DPO (Disable Page Out = don't save data in the
-+		 * cache) and FUA (Force Unit Access = write directly to the
-+		 * medium).  We don't implement DPO; we implement FUA by
-+		 * performing synchronous output. */
-+		if ((fsg->cmnd[1] & ~0x18) != 0) {
-+			curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
-+			return -EINVAL;
-+		}
-+		if (fsg->cmnd[1] & 0x08)	// FUA
-+			curlun->filp->f_flags |= O_SYNC;
-+	}
-+	if (lba >= curlun->num_sectors) {
-+		curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
-+		return -EINVAL;
-+	}
-+
-+	/* Carry out the file writes */
-+	get_some_more = 1;
-+	file_offset = usb_offset = ((loff_t) lba) << 9;
-+	amount_left_to_req = amount_left_to_write = fsg->data_size_from_cmnd;
-+
-+	while (amount_left_to_write > 0) {
-+
-+		/* Queue a request for more data from the host */
-+		bh = fsg->next_buffhd_to_fill;
-+		if (bh->state == BUF_STATE_EMPTY && get_some_more) {
-+
-+			/* Figure out how much we want to get:
-+			 * Try to get the remaining amount.
-+			 * But don't get more than the buffer size.
-+			 * And don't try to go past the end of the file.
-+			 * If we're not at a page boundary,
-+			 *	don't go past the next page.
-+			 * If this means getting 0, then we were asked
-+			 *	to write past the end of file.
-+			 * Finally, round down to a block boundary. */
-+			amount = min(amount_left_to_req, mod_data.buflen);
-+			amount = min((loff_t) amount, curlun->file_length -
-+					usb_offset);
-+			partial_page = usb_offset & (PAGE_CACHE_SIZE - 1);
-+			if (partial_page > 0)
-+				amount = min(amount,
-+	(unsigned int) PAGE_CACHE_SIZE - partial_page);
-+
-+			if (amount == 0) {
-+				get_some_more = 0;
-+				curlun->sense_data =
-+					SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
-+				curlun->sense_data_info = usb_offset >> 9;
-+				continue;
-+			}
-+			amount -= (amount & 511);
-+			if (amount == 0) {
-+
-+				/* Why were we were asked to transfer a
-+				 * partial block? */
-+				get_some_more = 0;
-+				continue;
-+			}
-+
-+			/* Get the next buffer */
-+			usb_offset += amount;
-+			fsg->usb_amount_left -= amount;
-+			amount_left_to_req -= amount;
-+			if (amount_left_to_req == 0)
-+				get_some_more = 0;
-+
-+			/* amount is always divisible by 512, hence by
-+			 * the bulk-out maxpacket size */
-+			bh->outreq->length = bh->bulk_out_intended_length =
-+					amount;
-+			start_transfer(fsg, fsg->bulk_out, bh->outreq,
-+					&bh->outreq_busy, &bh->state);
-+			fsg->next_buffhd_to_fill = bh->next;
-+			continue;
-+		}
-+
-+		/* Write the received data to the backing file */
-+		bh = fsg->next_buffhd_to_drain;
-+		if (bh->state == BUF_STATE_EMPTY && !get_some_more)
-+			break;			// We stopped early
-+		if (bh->state == BUF_STATE_FULL) {
-+			fsg->next_buffhd_to_drain = bh->next;
-+			bh->state = BUF_STATE_EMPTY;
-+
-+			/* Did something go wrong with the transfer? */
-+			if (bh->outreq->status != 0) {
-+				curlun->sense_data = SS_COMMUNICATION_FAILURE;
-+				curlun->sense_data_info = file_offset >> 9;
-+				break;
-+			}
-+
-+			amount = bh->outreq->actual;
-+			if (curlun->file_length - file_offset < amount) {
-+				LERROR(curlun,
-+	"write %u @ %llu beyond end %llu\n",
-+	amount, (unsigned long long) file_offset,
-+	(unsigned long long) curlun->file_length);
-+				amount = curlun->file_length - file_offset;
-+			}
-+
-+			/* Perform the write */
-+			file_offset_tmp = file_offset;
-+			nwritten = curlun->filp->f_op->write(curlun->filp,
-+					(char *) bh->buf,
-+					amount, &file_offset_tmp);
-+			VLDBG(curlun, "file write %u @ %llu -> %d\n", amount,
-+					(unsigned long long) file_offset,
-+					(int) nwritten);
-+			if (signal_pending(current))
-+				return -EINTR;		// Interrupted!
-+
-+			if (nwritten < 0) {
-+				LDBG(curlun, "error in file write: %d\n",
-+						(int) nwritten);
-+				nwritten = 0;
-+			} else if (nwritten < amount) {
-+				LDBG(curlun, "partial file write: %d/%u\n",
-+						(int) nwritten, amount);
-+				nwritten -= (nwritten & 511);
-+						// Round down to a block
-+			}
-+			file_offset += nwritten;
-+			amount_left_to_write -= nwritten;
-+			fsg->residue -= nwritten;
-+
-+			/* If an error occurred, report it and its position */
-+			if (nwritten < amount) {
-+				curlun->sense_data = SS_WRITE_ERROR;
-+				curlun->sense_data_info = file_offset >> 9;
-+				break;
-+			}
-+
-+			/* Did the host decide to stop early? */
-+			if (bh->outreq->actual != bh->outreq->length) {
-+				fsg->short_packet_received = 1;
-+				break;
-+			}
-+			continue;
-+		}
-+
-+		/* Wait for something to happen */
-+		if ((rc = sleep_thread(fsg)) != 0)
-+			return rc;
-+	}
-+
-+	return -EIO;		// No default reply
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* Sync the file data, don't bother with the metadata.
-+ * This code was copied from fs/buffer.c:sys_fdatasync(). */
-+static int fsync_sub(struct lun *curlun)
-+{
-+	struct file	*filp = curlun->filp;
-+	struct inode	*inode;
-+	int		rc, err;
-+
-+	if (curlun->ro || !filp)
-+		return 0;
-+	if (!filp->f_op->fsync)
-+		return -EINVAL;
-+
-+	inode = filp->f_dentry->d_inode;
-+	down(&inode->i_sem);
-+	rc = filemap_fdatasync(inode->i_mapping);
-+	err = filp->f_op->fsync(filp, filp->f_dentry, 1);
-+	if (!rc)
-+		rc = err;
-+	err = filemap_fdatawait(inode->i_mapping);
-+	if (!rc)
-+		rc = err;
-+	up(&inode->i_sem);
-+	VLDBG(curlun, "fdatasync -> %d\n", rc);
-+	return rc;
-+}
-+
-+static void fsync_all(struct fsg_dev *fsg)
-+{
-+	int	i;
-+
-+	for (i = 0; i < fsg->nluns; ++i)
-+		fsync_sub(&fsg->luns[i]);
-+}
-+
-+static int do_synchronize_cache(struct fsg_dev *fsg)
-+{
-+	struct lun	*curlun = fsg->curlun;
-+	int		rc;
-+
-+	/* We ignore the requested LBA and write out all file's
-+	 * dirty data buffers. */
-+	rc = fsync_sub(curlun);
-+	if (rc)
-+		curlun->sense_data = SS_WRITE_ERROR;
-+	return 0;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void invalidate_sub(struct lun *curlun)
-+{
-+	struct file	*filp = curlun->filp;
-+	struct inode	*inode = filp->f_dentry->d_inode;
-+
-+	invalidate_inode_pages(inode);
-+}
-+
-+static int do_verify(struct fsg_dev *fsg)
-+{
-+	struct lun		*curlun = fsg->curlun;
-+	u32			lba;
-+	u32			verification_length;
-+	struct fsg_buffhd	*bh = fsg->next_buffhd_to_fill;
-+	loff_t			file_offset, file_offset_tmp;
-+	u32			amount_left;
-+	unsigned int		amount;
-+	ssize_t			nread;
-+
-+	/* Get the starting Logical Block Address and check that it's
-+	 * not too big */
-+	lba = get_be32(&fsg->cmnd[2]);
-+	if (lba >= curlun->num_sectors) {
-+		curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
-+		return -EINVAL;
-+	}
-+
-+	/* We allow DPO (Disable Page Out = don't save data in the
-+	 * cache) but we don't implement it. */
-+	if ((fsg->cmnd[1] & ~0x10) != 0) {
-+		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
-+		return -EINVAL;
-+	}
-+
-+	verification_length = get_be16(&fsg->cmnd[7]);
-+	if (unlikely(verification_length == 0))
-+		return -EIO;		// No default reply
-+
-+	/* Prepare to carry out the file verify */
-+	amount_left = verification_length << 9;
-+	file_offset = ((loff_t) lba) << 9;
-+
-+	/* Write out all the dirty buffers before invalidating them */
-+	fsync_sub(curlun);
-+	if (signal_pending(current))
-+		return -EINTR;
-+
-+	invalidate_sub(curlun);
-+	if (signal_pending(current))
-+		return -EINTR;
-+
-+	/* Just try to read the requested blocks */
-+	while (amount_left > 0) {
-+
-+		/* Figure out how much we need to read:
-+		 * Try to read the remaining amount, but not more than
-+		 * the buffer size.
-+		 * And don't try to read past the end of the file.
-+		 * If this means reading 0 then we were asked to read
-+		 * past the end of file. */
-+		amount = min((unsigned int) amount_left, mod_data.buflen);
-+		amount = min((loff_t) amount,
-+				curlun->file_length - file_offset);
-+		if (amount == 0) {
-+			curlun->sense_data =
-+					SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
-+			curlun->sense_data_info = file_offset >> 9;
-+			break;
-+		}
-+
-+		/* Perform the read */
-+		file_offset_tmp = file_offset;
-+		nread = curlun->filp->f_op->read(curlun->filp,
-+				(char *) bh->buf,
-+				amount, &file_offset_tmp);
-+		VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
-+				(unsigned long long) file_offset,
-+				(int) nread);
-+		if (signal_pending(current))
-+			return -EINTR;
-+
-+		if (nread < 0) {
-+			LDBG(curlun, "error in file verify: %d\n",
-+					(int) nread);
-+			nread = 0;
-+		} else if (nread < amount) {
-+			LDBG(curlun, "partial file verify: %d/%u\n",
-+					(int) nread, amount);
-+			nread -= (nread & 511);	// Round down to a sector
-+		}
-+		if (nread == 0) {
-+			curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
-+			curlun->sense_data_info = file_offset >> 9;
-+			break;
-+		}
-+		file_offset += nread;
-+		amount_left -= nread;
-+	}
-+	return 0;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int do_inquiry(struct fsg_dev *fsg, struct fsg_buffhd *bh)
-+{
-+	u8	*buf = (u8 *) bh->buf;
-+
-+	static char vendor_id[] = "Linux   ";
-+	static char product_id[] = "File-Stor Gadget";
-+
-+	if (!fsg->curlun) {		// Unsupported LUNs are okay
-+		fsg->bad_lun_okay = 1;
-+		memset(buf, 0, 36);
-+		buf[0] = 0x7f;		// Unsupported, no device-type
-+		return 36;
-+	}
-+
-+	memset(buf, 0, 8);	// Non-removable, direct-access device
-+	if (mod_data.removable)
-+		buf[1] = 0x80;
-+	buf[2] = 2;		// ANSI SCSI level 2
-+	buf[3] = 2;		// SCSI-2 INQUIRY data format
-+	buf[4] = 31;		// Additional length
-+				// No special options
-+	sprintf(buf + 8, "%-8s%-16s%04x", vendor_id, product_id,
-+			mod_data.release);
-+	return 36;
-+}
-+
-+
-+static int do_request_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
-+{
-+	struct lun	*curlun = fsg->curlun;
-+	u8		*buf = (u8 *) bh->buf;
-+	u32		sd, sdinfo;
-+
-+	/*
-+	 * From the SCSI-2 spec., section 7.9 (Unit attention condition):
-+	 *
-+	 * If a REQUEST SENSE command is received from an initiator
-+	 * with a pending unit attention condition (before the target
-+	 * generates the contingent allegiance condition), then the
-+	 * target shall either:
-+	 *   a) report any pending sense data and preserve the unit
-+	 *	attention condition on the logical unit, or,
-+	 *   b) report the unit attention condition, may discard any
-+	 *	pending sense data, and clear the unit attention
-+	 *	condition on the logical unit for that initiator.
-+	 *
-+	 * FSG normally uses option a); enable this code to use option b).
-+	 */
-+#if 0
-+	if (curlun && curlun->unit_attention_data != SS_NO_SENSE) {
-+		curlun->sense_data = curlun->unit_attention_data;
-+		curlun->unit_attention_data = SS_NO_SENSE;
-+	}
-+#endif
-+
-+	if (!curlun) {		// Unsupported LUNs are okay
-+		fsg->bad_lun_okay = 1;
-+		sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
-+		sdinfo = 0;
-+	} else {
-+		sd = curlun->sense_data;
-+		sdinfo = curlun->sense_data_info;
-+		curlun->sense_data = SS_NO_SENSE;
-+		curlun->sense_data_info = 0;
-+	}
-+
-+	memset(buf, 0, 18);
-+	buf[0] = 0x80 | 0x70;			// Valid, current error
-+	buf[2] = SK(sd);
-+	put_be32(&buf[3], sdinfo);		// Sense information
-+	buf[7] = 18 - 8;			// Additional sense length
-+	buf[12] = ASC(sd);
-+	buf[13] = ASCQ(sd);
-+	return 18;
-+}
-+
-+
-+static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh)
-+{
-+	struct lun	*curlun = fsg->curlun;
-+	u32		lba = get_be32(&fsg->cmnd[2]);
-+	int		pmi = fsg->cmnd[8];
-+	u8		*buf = (u8 *) bh->buf;
-+
-+	/* Check the PMI and LBA fields */
-+	if (pmi > 1 || (pmi == 0 && lba != 0)) {
-+		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
-+		return -EINVAL;
-+	}
-+
-+	put_be32(&buf[0], curlun->num_sectors - 1);	// Max logical block
-+	put_be32(&buf[4], 512);				// Block length
-+	return 8;
-+}
-+
-+
-+static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
-+{
-+	struct lun	*curlun = fsg->curlun;
-+	int		mscmnd = fsg->cmnd[0];
-+	u8		*buf = (u8 *) bh->buf;
-+	u8		*buf0 = buf;
-+	int		pc, page_code;
-+	int		changeable_values, all_pages;
-+	int		valid_page = 0;
-+	int		len, limit;
-+
-+	if ((fsg->cmnd[1] & ~0x08) != 0) {		// Mask away DBD
-+		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
-+		return -EINVAL;
-+	}
-+	pc = fsg->cmnd[2] >> 6;
-+	page_code = fsg->cmnd[2] & 0x3f;
-+	if (pc == 3) {
-+		curlun->sense_data = SS_SAVING_PARAMETERS_NOT_SUPPORTED;
-+		return -EINVAL;
-+	}
-+	changeable_values = (pc == 1);
-+	all_pages = (page_code == 0x3f);
-+
-+	/* Write the mode parameter header.  Fixed values are: default
-+	 * medium type, no cache control (DPOFUA), and no block descriptors.
-+	 * The only variable value is the WriteProtect bit.  We will fill in
-+	 * the mode data length later. */
-+	memset(buf, 0, 8);
-+	if (mscmnd == SC_MODE_SENSE_6) {
-+		buf[2] = (curlun->ro ? 0x80 : 0x00);		// WP, DPOFUA
-+		buf += 4;
-+		limit = 255;
-+	} else {			// SC_MODE_SENSE_10
-+		buf[3] = (curlun->ro ? 0x80 : 0x00);		// WP, DPOFUA
-+		buf += 8;
-+		limit = 65535;		// Should really be mod_data.buflen
-+	}
-+
-+	/* No block descriptors */
-+
-+	/* The mode pages, in numerical order.  The only page we support
-+	 * is the Caching page. */
-+	if (page_code == 0x08 || all_pages) {
-+		valid_page = 1;
-+		buf[0] = 0x08;		// Page code
-+		buf[1] = 10;		// Page length
-+		memset(buf+2, 0, 10);	// None of the fields are changeable
-+
-+		if (!changeable_values) {
-+			buf[2] = 0x04;	// Write cache enable,
-+					// Read cache not disabled
-+					// No cache retention priorities
-+			put_be16(&buf[4], 0xffff);  // Don't disable prefetch
-+					// Minimum prefetch = 0
-+			put_be16(&buf[8], 0xffff);  // Maximum prefetch
-+			put_be16(&buf[10], 0xffff); // Maximum prefetch ceiling
-+		}
-+		buf += 12;
-+	}
-+
-+	/* Check that a valid page was requested and the mode data length
-+	 * isn't too long. */
-+	len = buf - buf0;
-+	if (!valid_page || len > limit) {
-+		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
-+		return -EINVAL;
-+	}
-+
-+	/*  Store the mode data length */
-+	if (mscmnd == SC_MODE_SENSE_6)
-+		buf0[0] = len - 1;
-+	else
-+		put_be16(buf0, len - 2);
-+	return len;
-+}
-+
-+
-+static int do_start_stop(struct fsg_dev *fsg)
-+{
-+	struct lun	*curlun = fsg->curlun;
-+	int		loej, start;
-+
-+	if (!mod_data.removable) {
-+		curlun->sense_data = SS_INVALID_COMMAND;
-+		return -EINVAL;
-+	}
-+
-+	// int immed = fsg->cmnd[1] & 0x01;
-+	loej = fsg->cmnd[4] & 0x02;
-+	start = fsg->cmnd[4] & 0x01;
-+
-+#ifdef CONFIG_USB_FILE_STORAGE_TEST
-+	if ((fsg->cmnd[1] & ~0x01) != 0 ||		// Mask away Immed
-+			(fsg->cmnd[4] & ~0x03) != 0) {	// Mask LoEj, Start
-+		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
-+		return -EINVAL;
-+	}
-+
-+	if (!start) {
-+
-+		/* Are we allowed to unload the media? */
-+		if (curlun->prevent_medium_removal) {
-+			LDBG(curlun, "unload attempt prevented\n");
-+			curlun->sense_data = SS_MEDIUM_REMOVAL_PREVENTED;
-+			return -EINVAL;
-+		}
-+		if (loej) {		// Simulate an unload/eject
-+			up_read(&fsg->filesem);
-+			down_write(&fsg->filesem);
-+			close_backing_file(curlun);
-+			up_write(&fsg->filesem);
-+			down_read(&fsg->filesem);
-+		}
-+	} else {
-+
-+		/* Our emulation doesn't support mounting; the medium is
-+		 * available for use as soon as it is loaded. */
-+		if (!backing_file_is_open(curlun)) {
-+			curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
-+			return -EINVAL;
-+		}
-+	}
-+#endif
-+	return 0;
-+}
-+
-+
-+static int do_prevent_allow(struct fsg_dev *fsg)
-+{
-+	struct lun	*curlun = fsg->curlun;
-+	int		prevent;
-+
-+	if (!mod_data.removable) {
-+		curlun->sense_data = SS_INVALID_COMMAND;
-+		return -EINVAL;
-+	}
-+
-+	prevent = fsg->cmnd[4] & 0x01;
-+	if ((fsg->cmnd[4] & ~0x01) != 0) {		// Mask away Prevent
-+		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
-+		return -EINVAL;
-+	}
-+
-+	if (curlun->prevent_medium_removal && !prevent)
-+		fsync_sub(curlun);
-+	curlun->prevent_medium_removal = prevent;
-+	return 0;
-+}
-+
-+
-+static int do_read_format_capacities(struct fsg_dev *fsg,
-+			struct fsg_buffhd *bh)
-+{
-+	struct lun	*curlun = fsg->curlun;
-+	u8		*buf = (u8 *) bh->buf;
-+
-+	buf[0] = buf[1] = buf[2] = 0;
-+	buf[3] = 8;		// Only the Current/Maximum Capacity Descriptor
-+	buf += 4;
-+
-+	put_be32(&buf[0], curlun->num_sectors);		// Number of blocks
-+	put_be32(&buf[4], 512);				// Block length
-+	buf[4] = 0x02;					// Current capacity
-+	return 12;
-+}
-+
-+
-+static int do_mode_select(struct fsg_dev *fsg, struct fsg_buffhd *bh)
-+{
-+	struct lun	*curlun = fsg->curlun;
-+
-+	/* We don't support MODE SELECT */
-+	curlun->sense_data = SS_INVALID_COMMAND;
-+	return -EINVAL;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int halt_bulk_in_endpoint(struct fsg_dev *fsg)
-+{
-+	int	rc;
-+
-+	rc = fsg_set_halt(fsg, fsg->bulk_in);
-+	if (rc == -EAGAIN)
-+		VDBG(fsg, "delayed bulk-in endpoint halt\n");
-+	while (rc != 0) {
-+		if (rc != -EAGAIN) {
-+			WARN(fsg, "usb_ep_set_halt -> %d\n", rc);
-+			rc = 0;
-+			break;
-+		}
-+
-+		/* Wait for a short time and then try again */
-+		set_current_state(TASK_INTERRUPTIBLE);
-+		if (schedule_timeout(HZ / 10) != 0)
-+			return -EINTR;
-+		rc = usb_ep_set_halt(fsg->bulk_in);
-+	}
-+	return rc;
-+}
-+
-+static int pad_with_zeros(struct fsg_dev *fsg)
-+{
-+	struct fsg_buffhd	*bh = fsg->next_buffhd_to_fill;
-+	u32			nkeep = bh->inreq->length;
-+	u32			nsend;
-+	int			rc;
-+
-+	bh->state = BUF_STATE_EMPTY;		// For the first iteration
-+	fsg->usb_amount_left = nkeep + fsg->residue;
-+	while (fsg->usb_amount_left > 0) {
-+
-+		/* Wait for the next buffer to be free */
-+		while (bh->state != BUF_STATE_EMPTY) {
-+			if ((rc = sleep_thread(fsg)) != 0)
-+				return rc;
-+		}
-+
-+		nsend = min(fsg->usb_amount_left, (u32) mod_data.buflen);
-+		memset(bh->buf + nkeep, 0, nsend - nkeep);
-+		bh->inreq->length = nsend;
-+		bh->inreq->zero = 0;
-+		start_transfer(fsg, fsg->bulk_in, bh->inreq,
-+				&bh->inreq_busy, &bh->state);
-+		bh = fsg->next_buffhd_to_fill = bh->next;
-+		fsg->usb_amount_left -= nsend;
-+		nkeep = 0;
-+	}
-+	return 0;
-+}
-+
-+static int throw_away_data(struct fsg_dev *fsg)
-+{
-+	struct fsg_buffhd	*bh;
-+	u32			amount;
-+	int			rc;
-+
-+	while ((bh = fsg->next_buffhd_to_drain)->state != BUF_STATE_EMPTY ||
-+			fsg->usb_amount_left > 0) {
-+
-+		/* Throw away the data in a filled buffer */
-+		if (bh->state == BUF_STATE_FULL) {
-+			bh->state = BUF_STATE_EMPTY;
-+			fsg->next_buffhd_to_drain = bh->next;
-+
-+			/* A short packet or an error ends everything */
-+			if (bh->outreq->actual != bh->outreq->length ||
-+					bh->outreq->status != 0) {
-+				raise_exception(fsg, FSG_STATE_ABORT_BULK_OUT);
-+				return -EINTR;
-+			}
-+			continue;
-+		}
-+
-+		/* Try to submit another request if we need one */
-+		bh = fsg->next_buffhd_to_fill;
-+		if (bh->state == BUF_STATE_EMPTY && fsg->usb_amount_left > 0) {
-+			amount = min(fsg->usb_amount_left,
-+					(u32) mod_data.buflen);
-+
-+			/* amount is always divisible by 512, hence by
-+			 * the bulk-out maxpacket size */
-+			bh->outreq->length = bh->bulk_out_intended_length =
-+					amount;
-+			start_transfer(fsg, fsg->bulk_out, bh->outreq,
-+					&bh->outreq_busy, &bh->state);
-+			fsg->next_buffhd_to_fill = bh->next;
-+			fsg->usb_amount_left -= amount;
-+			continue;
-+		}
-+
-+		/* Otherwise wait for something to happen */
-+		if ((rc = sleep_thread(fsg)) != 0)
-+			return rc;
-+	}
-+	return 0;
-+}
-+
-+
-+static int finish_reply(struct fsg_dev *fsg)
-+{
-+	struct fsg_buffhd	*bh = fsg->next_buffhd_to_fill;
-+	int			rc = 0;
-+
-+	switch (fsg->data_dir) {
-+	case DATA_DIR_NONE:
-+		break;			// Nothing to send
-+
-+	/* If we don't know whether the host wants to read or write,
-+	 * this must be CB or CBI with an unknown command.  We mustn't
-+	 * try to send or receive any data.  So stall both bulk pipes
-+	 * if we can and wait for a reset. */
-+	case DATA_DIR_UNKNOWN:
-+		if (mod_data.can_stall) {
-+			fsg_set_halt(fsg, fsg->bulk_out);
-+			rc = halt_bulk_in_endpoint(fsg);
-+		}
-+		break;
-+
-+	/* All but the last buffer of data must have already been sent */
-+	case DATA_DIR_TO_HOST:
-+		if (fsg->data_size == 0)
-+			;		// Nothing to send
-+
-+		/* If there's no residue, simply send the last buffer */
-+		else if (fsg->residue == 0) {
-+			bh->inreq->zero = 0;
-+			start_transfer(fsg, fsg->bulk_in, bh->inreq,
-+					&bh->inreq_busy, &bh->state);
-+			fsg->next_buffhd_to_fill = bh->next;
-+		}
-+
-+		/* There is a residue.  For CB and CBI, simply mark the end
-+		 * of the data with a short packet.  However, if we are
-+		 * allowed to stall, there was no data at all (residue ==
-+		 * data_size), and the command failed (invalid LUN or
-+		 * sense data is set), then halt the bulk-in endpoint
-+		 * instead. */
-+		else if (!transport_is_bbb()) {
-+			if (mod_data.can_stall &&
-+					fsg->residue == fsg->data_size &&
-+	(!fsg->curlun || fsg->curlun->sense_data != SS_NO_SENSE)) {
-+				bh->state = BUF_STATE_EMPTY;
-+				rc = halt_bulk_in_endpoint(fsg);
-+			} else {
-+				bh->inreq->zero = 1;
-+				start_transfer(fsg, fsg->bulk_in, bh->inreq,
-+						&bh->inreq_busy, &bh->state);
-+				fsg->next_buffhd_to_fill = bh->next;
-+			}
-+		}
-+
-+		/* For Bulk-only, if we're allowed to stall then send the
-+		 * short packet and halt the bulk-in endpoint.  If we can't
-+		 * stall, pad out the remaining data with 0's. */
-+		else {
-+			if (mod_data.can_stall) {
-+				bh->inreq->zero = 1;
-+				start_transfer(fsg, fsg->bulk_in, bh->inreq,
-+						&bh->inreq_busy, &bh->state);
-+				fsg->next_buffhd_to_fill = bh->next;
-+				rc = halt_bulk_in_endpoint(fsg);
-+			} else
-+				rc = pad_with_zeros(fsg);
-+		}
-+		break;
-+
-+	/* We have processed all we want from the data the host has sent.
-+	 * There may still be outstanding bulk-out requests. */
-+	case DATA_DIR_FROM_HOST:
-+		if (fsg->residue == 0)
-+			;		// Nothing to receive
-+
-+		/* Did the host stop sending unexpectedly early? */
-+		else if (fsg->short_packet_received) {
-+			raise_exception(fsg, FSG_STATE_ABORT_BULK_OUT);
-+			rc = -EINTR;
-+		}
-+
-+		/* We haven't processed all the incoming data.  If we are
-+		 * allowed to stall, halt the bulk-out endpoint and cancel
-+		 * any outstanding requests. */
-+		else if (mod_data.can_stall) {
-+			fsg_set_halt(fsg, fsg->bulk_out);
-+			raise_exception(fsg, FSG_STATE_ABORT_BULK_OUT);
-+			rc = -EINTR;
-+		}
-+
-+		/* We can't stall.  Read in the excess data and throw it
-+		 * all away. */
-+		else
-+			rc = throw_away_data(fsg);
-+		break;
-+	}
-+	return rc;
-+}
-+
-+
-+static int send_status(struct fsg_dev *fsg)
-+{
-+	struct lun		*curlun = fsg->curlun;
-+	struct fsg_buffhd	*bh;
-+	int			rc;
-+	u8			status = USB_STATUS_PASS;
-+	u32			sd, sdinfo = 0;
-+
-+	/* Wait for the next buffer to become available */
-+	bh = fsg->next_buffhd_to_fill;
-+	while (bh->state != BUF_STATE_EMPTY) {
-+		if ((rc = sleep_thread(fsg)) != 0)
-+			return rc;
-+	}
-+
-+	if (curlun) {
-+		sd = curlun->sense_data;
-+		sdinfo = curlun->sense_data_info;
-+	} else if (fsg->bad_lun_okay)
-+		sd = SS_NO_SENSE;
-+	else
-+		sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
-+
-+	if (fsg->phase_error) {
-+		DBG(fsg, "sending phase-error status\n");
-+		status = USB_STATUS_PHASE_ERROR;
-+		sd = SS_INVALID_COMMAND;
-+	} else if (sd != SS_NO_SENSE) {
-+		DBG(fsg, "sending command-failure status\n");
-+		status = USB_STATUS_FAIL;
-+		VDBG(fsg, "  sense data: SK x%02x, ASC x%02x, ASCQ x%02x;"
-+				"  info x%x\n",
-+				SK(sd), ASC(sd), ASCQ(sd), sdinfo);
-+	}
-+
-+	if (transport_is_bbb()) {
-+		struct bulk_cs_wrap	*csw = (struct bulk_cs_wrap *) bh->buf;
-+
-+		/* Store and send the Bulk-only CSW */
-+		csw->Signature = __constant_cpu_to_le32(USB_BULK_CS_SIG);
-+		csw->Tag = fsg->tag;
-+		csw->Residue = cpu_to_le32(fsg->residue);
-+		csw->Status = status;
-+
-+		bh->inreq->length = USB_BULK_CS_WRAP_LEN;
-+		bh->inreq->zero = 0;
-+		start_transfer(fsg, fsg->bulk_in, bh->inreq,
-+				&bh->inreq_busy, &bh->state);
-+
-+	} else if (mod_data.transport_type == USB_PR_CB) {
-+
-+		/* Control-Bulk transport has no status stage! */
-+		return 0;
-+
-+	} else {			// USB_PR_CBI
-+		struct interrupt_data	*buf = (struct interrupt_data *)
-+						bh->buf;
-+
-+		/* Store and send the Interrupt data.  UFI sends the ASC
-+		 * and ASCQ bytes.  Everything else sends a Type (which
-+		 * is always 0) and the status Value. */
-+		if (mod_data.protocol_type == USB_SC_UFI) {
-+			buf->bType = ASC(sd);
-+			buf->bValue = ASCQ(sd);
-+		} else {
-+			buf->bType = 0;
-+			buf->bValue = status;
-+		}
-+		fsg->intreq->length = CBI_INTERRUPT_DATA_LEN;
-+
-+		fsg->intr_buffhd = bh;		// Point to the right buffhd
-+		fsg->intreq->buf = bh->inreq->buf;
-+		fsg->intreq->dma = bh->inreq->dma;
-+		fsg->intreq->context = bh;
-+		start_transfer(fsg, fsg->intr_in, fsg->intreq,
-+				&fsg->intreq_busy, &bh->state);
-+	}
-+
-+	fsg->next_buffhd_to_fill = bh->next;
-+	return 0;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* Check whether the command is properly formed and whether its data size
-+ * and direction agree with the values we already have. */
-+static int check_command(struct fsg_dev *fsg, int cmnd_size,
-+		enum data_direction data_dir, unsigned int mask,
-+		int needs_medium, const char *name)
-+{
-+	int			i;
-+	int			lun = fsg->cmnd[1] >> 5;
-+	static const char	dirletter[4] = {'u', 'o', 'i', 'n'};
-+	char			hdlen[20];
-+	struct lun		*curlun;
-+
-+	/* Adjust the expected cmnd_size for protocol encapsulation padding.
-+	 * Transparent SCSI doesn't pad. */
-+	if (protocol_is_scsi())
-+		;
-+
-+	/* There's some disagreement as to whether RBC pads commands or not.
-+	 * We'll play it safe and accept either form. */
-+	else if (mod_data.protocol_type == USB_SC_RBC) {
-+		if (fsg->cmnd_size == 12)
-+			cmnd_size = 12;
-+
-+	/* All the other protocols pad to 12 bytes */
-+	} else
-+		cmnd_size = 12;
-+
-+	hdlen[0] = 0;
-+	if (fsg->data_dir != DATA_DIR_UNKNOWN)
-+		sprintf(hdlen, ", H%c=%u", dirletter[(int) fsg->data_dir],
-+				fsg->data_size);
-+	VDBG(fsg, "SCSI command: %s;  Dc=%d, D%c=%u;  Hc=%d%s\n",
-+			name, cmnd_size, dirletter[(int) data_dir],
-+			fsg->data_size_from_cmnd, fsg->cmnd_size, hdlen);
-+
-+	/* We can't reply at all until we know the correct data direction
-+	 * and size. */
-+	if (fsg->data_size_from_cmnd == 0)
-+		data_dir = DATA_DIR_NONE;
-+	if (fsg->data_dir == DATA_DIR_UNKNOWN) {	// CB or CBI
-+		fsg->data_dir = data_dir;
-+		fsg->data_size = fsg->data_size_from_cmnd;
-+
-+	} else {					// Bulk-only
-+		if (fsg->data_size < fsg->data_size_from_cmnd) {
-+
-+			/* Host data size < Device data size is a phase error.
-+			 * Carry out the command, but only transfer as much
-+			 * as we are allowed. */
-+			fsg->data_size_from_cmnd = fsg->data_size;
-+			fsg->phase_error = 1;
-+		}
-+	}
-+	fsg->residue = fsg->usb_amount_left = fsg->data_size;
-+
-+	/* Conflicting data directions is a phase error */
-+	if (fsg->data_dir != data_dir && fsg->data_size_from_cmnd > 0)
-+		goto phase_error;
-+
-+	/* Verify the length of the command itself */
-+	if (cmnd_size != fsg->cmnd_size) {
-+
-+		/* Special case workaround: MS-Windows issues REQUEST SENSE
-+		 * with cbw->Length == 12 (it should be 6). */
-+		if (fsg->cmnd[0] == SC_REQUEST_SENSE && fsg->cmnd_size == 12)
-+			cmnd_size = fsg->cmnd_size;
-+		else
-+			goto phase_error;
-+	}
-+
-+	/* Check that the LUN values are oonsistent */
-+	if (transport_is_bbb()) {
-+		if (fsg->lun != lun)
-+			DBG(fsg, "using LUN %d from CBW, "
-+					"not LUN %d from CDB\n",
-+					fsg->lun, lun);
-+	} else
-+		fsg->lun = lun;		// Use LUN from the command
-+
-+	/* Check the LUN */
-+	if (fsg->lun >= 0 && fsg->lun < fsg->nluns) {
-+		fsg->curlun = curlun = &fsg->luns[fsg->lun];
-+		if (fsg->cmnd[0] != SC_REQUEST_SENSE) {
-+			curlun->sense_data = SS_NO_SENSE;
-+			curlun->sense_data_info = 0;
-+		}
-+	} else {
-+		fsg->curlun = curlun = NULL;
-+		fsg->bad_lun_okay = 0;
-+
-+		/* INQUIRY and REQUEST SENSE commands are explicitly allowed
-+		 * to use unsupported LUNs; all others may not. */
-+		if (fsg->cmnd[0] != SC_INQUIRY &&
-+				fsg->cmnd[0] != SC_REQUEST_SENSE) {
-+			DBG(fsg, "unsupported LUN %d\n", fsg->lun);
-+			return -EINVAL;
-+		}
-+	}
-+
-+	/* If a unit attention condition exists, only INQUIRY and
-+	 * REQUEST SENSE commands are allowed; anything else must fail. */
-+	if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
-+			fsg->cmnd[0] != SC_INQUIRY &&
-+			fsg->cmnd[0] != SC_REQUEST_SENSE) {
-+		curlun->sense_data = curlun->unit_attention_data;
-+		curlun->unit_attention_data = SS_NO_SENSE;
-+		return -EINVAL;
-+	}
-+
-+	/* Check that only command bytes listed in the mask are non-zero */
-+	fsg->cmnd[1] &= 0x1f;			// Mask away the LUN
-+	for (i = 1; i < cmnd_size; ++i) {
-+		if (fsg->cmnd[i] && !(mask & (1 << i))) {
-+			if (curlun)
-+				curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
-+			return -EINVAL;
-+		}
-+	}
-+
-+	/* If the medium isn't mounted and the command needs to access
-+	 * it, return an error. */
-+	if (curlun && !backing_file_is_open(curlun) && needs_medium) {
-+		curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
-+		return -EINVAL;
-+	}
-+
-+	return 0;
-+
-+phase_error:
-+	fsg->phase_error = 1;
-+	return -EINVAL;
-+}
-+
-+
-+static int do_scsi_command(struct fsg_dev *fsg)
-+{
-+	struct fsg_buffhd	*bh;
-+	int			rc;
-+	int			reply = -EINVAL;
-+	int			i;
-+	static char		unknown[16];
-+
-+	dump_cdb(fsg);
-+
-+	/* Wait for the next buffer to become available for data or status */
-+	bh = fsg->next_buffhd_to_drain = fsg->next_buffhd_to_fill;
-+	while (bh->state != BUF_STATE_EMPTY) {
-+		if ((rc = sleep_thread(fsg)) != 0)
-+			return rc;
-+		}
-+	fsg->phase_error = 0;
-+	fsg->short_packet_received = 0;
-+
-+	down_read(&fsg->filesem);	// We're using the backing file
-+	switch (fsg->cmnd[0]) {
-+
-+	case SC_INQUIRY:
-+		fsg->data_size_from_cmnd = fsg->cmnd[4];
-+		if ((reply = check_command(fsg, 6, DATA_DIR_TO_HOST,
-+				(1<<4), 0,
-+				"INQUIRY")) == 0)
-+			reply = do_inquiry(fsg, bh);
-+		break;
-+
-+	case SC_MODE_SELECT_6:
-+		fsg->data_size_from_cmnd = fsg->cmnd[4];
-+		if ((reply = check_command(fsg, 6, DATA_DIR_FROM_HOST,
-+				(1<<1) | (1<<4), 0,
-+				"MODE SELECT(6)")) == 0)
-+			reply = do_mode_select(fsg, bh);
-+		break;
-+
-+	case SC_MODE_SELECT_10:
-+		fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]);
-+		if ((reply = check_command(fsg, 10, DATA_DIR_FROM_HOST,
-+				(1<<1) | (3<<7), 0,
-+				"MODE SELECT(10)")) == 0)
-+			reply = do_mode_select(fsg, bh);
-+		break;
-+
-+	case SC_MODE_SENSE_6:
-+		fsg->data_size_from_cmnd = fsg->cmnd[4];
-+		if ((reply = check_command(fsg, 6, DATA_DIR_TO_HOST,
-+				(1<<1) | (1<<2) | (1<<4), 0,
-+				"MODE SENSE(6)")) == 0)
-+			reply = do_mode_sense(fsg, bh);
-+		break;
-+
-+	case SC_MODE_SENSE_10:
-+		fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]);
-+		if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
-+				(1<<1) | (1<<2) | (3<<7), 0,
-+				"MODE SENSE(10)")) == 0)
-+			reply = do_mode_sense(fsg, bh);
-+		break;
-+
-+	case SC_PREVENT_ALLOW_MEDIUM_REMOVAL:
-+		fsg->data_size_from_cmnd = 0;
-+		if ((reply = check_command(fsg, 6, DATA_DIR_NONE,
-+				(1<<4), 0,
-+				"PREVENT-ALLOW MEDIUM REMOVAL")) == 0)
-+			reply = do_prevent_allow(fsg);
-+		break;
-+
-+	case SC_READ_6:
-+		i = fsg->cmnd[4];
-+		fsg->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
-+		if ((reply = check_command(fsg, 6, DATA_DIR_TO_HOST,
-+				(7<<1) | (1<<4), 1,
-+				"READ(6)")) == 0)
-+			reply = do_read(fsg);
-+		break;
-+
-+	case SC_READ_10:
-+		fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]) << 9;
-+		if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
-+				(1<<1) | (0xf<<2) | (3<<7), 1,
-+				"READ(10)")) == 0)
-+			reply = do_read(fsg);
-+		break;
-+
-+	case SC_READ_12:
-+		fsg->data_size_from_cmnd = get_be32(&fsg->cmnd[6]) << 9;
-+		if ((reply = check_command(fsg, 12, DATA_DIR_TO_HOST,
-+				(1<<1) | (0xf<<2) | (0xf<<6), 1,
-+				"READ(12)")) == 0)
-+			reply = do_read(fsg);
-+		break;
-+
-+	case SC_READ_CAPACITY:
-+		fsg->data_size_from_cmnd = 8;
-+		if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
-+				(0xf<<2) | (1<<8), 1,
-+				"READ CAPACITY")) == 0)
-+			reply = do_read_capacity(fsg, bh);
-+		break;
-+
-+	case SC_READ_FORMAT_CAPACITIES:
-+		fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]);
-+		if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
-+				(3<<7), 1,
-+				"READ FORMAT CAPACITIES")) == 0)
-+			reply = do_read_format_capacities(fsg, bh);
-+		break;
-+
-+	case SC_REQUEST_SENSE:
-+		fsg->data_size_from_cmnd = fsg->cmnd[4];
-+		if ((reply = check_command(fsg, 6, DATA_DIR_TO_HOST,
-+				(1<<4), 0,
-+				"REQUEST SENSE")) == 0)
-+			reply = do_request_sense(fsg, bh);
-+		break;
-+
-+	case SC_START_STOP_UNIT:
-+		fsg->data_size_from_cmnd = 0;
-+		if ((reply = check_command(fsg, 6, DATA_DIR_NONE,
-+				(1<<1) | (1<<4), 0,
-+				"START-STOP UNIT")) == 0)
-+			reply = do_start_stop(fsg);
-+		break;
-+
-+	case SC_SYNCHRONIZE_CACHE:
-+		fsg->data_size_from_cmnd = 0;
-+		if ((reply = check_command(fsg, 10, DATA_DIR_NONE,
-+				(0xf<<2) | (3<<7), 1,
-+				"SYNCHRONIZE CACHE")) == 0)
-+			reply = do_synchronize_cache(fsg);
-+		break;
-+
-+	case SC_TEST_UNIT_READY:
-+		fsg->data_size_from_cmnd = 0;
-+		reply = check_command(fsg, 6, DATA_DIR_NONE,
-+				0, 1,
-+				"TEST UNIT READY");
-+		break;
-+
-+	/* Although optional, this command is used by MS-Windows.  We
-+	 * support a minimal version: BytChk must be 0. */
-+	case SC_VERIFY:
-+		fsg->data_size_from_cmnd = 0;
-+		if ((reply = check_command(fsg, 10, DATA_DIR_NONE,
-+				(1<<1) | (0xf<<2) | (3<<7), 1,
-+				"VERIFY")) == 0)
-+			reply = do_verify(fsg);
-+		break;
-+
-+	case SC_WRITE_6:
-+		i = fsg->cmnd[4];
-+		fsg->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
-+		if ((reply = check_command(fsg, 6, DATA_DIR_FROM_HOST,
-+				(7<<1) | (1<<4), 1,
-+				"WRITE(6)")) == 0)
-+			reply = do_write(fsg);
-+		break;
-+
-+	case SC_WRITE_10:
-+		fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]) << 9;
-+		if ((reply = check_command(fsg, 10, DATA_DIR_FROM_HOST,
-+				(1<<1) | (0xf<<2) | (3<<7), 1,
-+				"WRITE(10)")) == 0)
-+			reply = do_write(fsg);
-+		break;
-+
-+	case SC_WRITE_12:
-+		fsg->data_size_from_cmnd = get_be32(&fsg->cmnd[6]) << 9;
-+		if ((reply = check_command(fsg, 12, DATA_DIR_FROM_HOST,
-+				(1<<1) | (0xf<<2) | (0xf<<6), 1,
-+				"WRITE(12)")) == 0)
-+			reply = do_write(fsg);
-+		break;
-+
-+	/* Some mandatory commands that we recognize but don't implement.
-+	 * They don't mean much in this setting.  It's left as an exercise
-+	 * for anyone interested to implement RESERVE and RELEASE in terms
-+	 * of Posix locks. */
-+	case SC_FORMAT_UNIT:
-+	case SC_RELEASE:
-+	case SC_RESERVE:
-+	case SC_SEND_DIAGNOSTIC:
-+		// Fall through
-+
-+	default:
-+		fsg->data_size_from_cmnd = 0;
-+		sprintf(unknown, "Unknown x%02x", fsg->cmnd[0]);
-+		if ((reply = check_command(fsg, fsg->cmnd_size,
-+				DATA_DIR_UNKNOWN, 0xff, 0, unknown)) == 0) {
-+			fsg->curlun->sense_data = SS_INVALID_COMMAND;
-+			reply = -EINVAL;
-+		}
-+		break;
-+	}
-+	up_read(&fsg->filesem);
-+
-+	if (reply == -EINTR || signal_pending(current))
-+		return -EINTR;
-+
-+	/* Set up the single reply buffer for finish_reply() */
-+	if (reply == -EINVAL)
-+		reply = 0;		// Error reply length
-+	if (reply >= 0 && fsg->data_dir == DATA_DIR_TO_HOST) {
-+		reply = min((u32) reply, fsg->data_size_from_cmnd);
-+		bh->inreq->length = reply;
-+		bh->state = BUF_STATE_FULL;
-+		fsg->residue -= reply;
-+	}				// Otherwise it's already set
-+
-+	return 0;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
-+{
-+	struct usb_request	*req = bh->outreq;
-+	struct bulk_cb_wrap	*cbw = (struct bulk_cb_wrap *) req->buf;
-+
-+	/* Was this a real packet? */
-+	if (req->status)
-+		return -EINVAL;
-+
-+	/* Is the CBW valid? */
-+	if (req->actual != USB_BULK_CB_WRAP_LEN ||
-+			cbw->Signature != __constant_cpu_to_le32(
-+				USB_BULK_CB_SIG)) {
-+		DBG(fsg, "invalid CBW: len %u sig 0x%x\n",
-+				req->actual,
-+				le32_to_cpu(cbw->Signature));
-+
-+		/* The Bulk-only spec says we MUST stall the bulk pipes!
-+		 * If we want to avoid stalls, set a flag so that we will
-+		 * clear the endpoint halts at the next reset. */
-+		if (!mod_data.can_stall)
-+			set_bit(CLEAR_BULK_HALTS, &fsg->atomic_bitflags);
-+		fsg_set_halt(fsg, fsg->bulk_out);
-+		halt_bulk_in_endpoint(fsg);
-+		return -EINVAL;
-+	}
-+
-+	/* Is the CBW meaningful? */
-+	if (cbw->Lun >= MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG ||
-+			cbw->Length < 6 || cbw->Length > MAX_COMMAND_SIZE) {
-+		DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
-+				"cmdlen %u\n",
-+				cbw->Lun, cbw->Flags, cbw->Length);
-+
-+		/* We can do anything we want here, so let's stall the
-+		 * bulk pipes if we are allowed to. */
-+		if (mod_data.can_stall) {
-+			fsg_set_halt(fsg, fsg->bulk_out);
-+			halt_bulk_in_endpoint(fsg);
-+		}
-+		return -EINVAL;
-+	}
-+
-+	/* Save the command for later */
-+	fsg->cmnd_size = cbw->Length;
-+	memcpy(fsg->cmnd, cbw->CDB, fsg->cmnd_size);
-+	if (cbw->Flags & USB_BULK_IN_FLAG)
-+		fsg->data_dir = DATA_DIR_TO_HOST;
-+	else
-+		fsg->data_dir = DATA_DIR_FROM_HOST;
-+	fsg->data_size = le32_to_cpu(cbw->DataTransferLength);
-+	if (fsg->data_size == 0)
-+		fsg->data_dir = DATA_DIR_NONE;
-+	fsg->lun = cbw->Lun;
-+	fsg->tag = cbw->Tag;
-+	return 0;
-+}
-+
-+
-+static int get_next_command(struct fsg_dev *fsg)
-+{
-+	struct fsg_buffhd	*bh;
-+	int			rc = 0;
-+
-+	if (transport_is_bbb()) {
-+
-+		/* Wait for the next buffer to become available */
-+		bh = fsg->next_buffhd_to_fill;
-+		while (bh->state != BUF_STATE_EMPTY) {
-+			if ((rc = sleep_thread(fsg)) != 0)
-+				return rc;
-+			}
-+
-+		/* Queue a request to read a Bulk-only CBW */
-+		set_bulk_out_req_length(fsg, bh, USB_BULK_CB_WRAP_LEN);
-+		start_transfer(fsg, fsg->bulk_out, bh->outreq,
-+				&bh->outreq_busy, &bh->state);
-+
-+		/* We will drain the buffer in software, which means we
-+		 * can reuse it for the next filling.  No need to advance
-+		 * next_buffhd_to_fill. */
-+
-+		/* Wait for the CBW to arrive */
-+		while (bh->state != BUF_STATE_FULL) {
-+			if ((rc = sleep_thread(fsg)) != 0)
-+				return rc;
-+			}
-+		rc = received_cbw(fsg, bh);
-+		bh->state = BUF_STATE_EMPTY;
-+
-+	} else {		// USB_PR_CB or USB_PR_CBI
-+
-+		/* Wait for the next command to arrive */
-+		while (fsg->cbbuf_cmnd_size == 0) {
-+			if ((rc = sleep_thread(fsg)) != 0)
-+				return rc;
-+			}
-+
-+		/* Is the previous status interrupt request still busy?
-+		 * The host is allowed to skip reading the status,
-+		 * so we must cancel it. */
-+		if (fsg->intreq_busy)
-+			usb_ep_dequeue(fsg->intr_in, fsg->intreq);
-+
-+		/* Copy the command and mark the buffer empty */
-+		fsg->data_dir = DATA_DIR_UNKNOWN;
-+		spin_lock_irq(&fsg->lock);
-+		fsg->cmnd_size = fsg->cbbuf_cmnd_size;
-+		memcpy(fsg->cmnd, fsg->cbbuf_cmnd, fsg->cmnd_size);
-+		fsg->cbbuf_cmnd_size = 0;
-+		spin_unlock_irq(&fsg->lock);
-+	}
-+	return rc;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int enable_endpoint(struct fsg_dev *fsg, struct usb_ep *ep,
-+		const struct usb_endpoint_descriptor *d)
-+{
-+	int	rc;
-+
-+	ep->driver_data = fsg;
-+	rc = usb_ep_enable(ep, d);
-+	if (rc)
-+		ERROR(fsg, "can't enable %s, result %d\n", ep->name, rc);
-+	return rc;
-+}
-+
-+static int alloc_request(struct fsg_dev *fsg, struct usb_ep *ep,
-+		struct usb_request **preq)
-+{
-+	*preq = usb_ep_alloc_request(ep, GFP_ATOMIC);
-+	if (*preq)
-+		return 0;
-+	ERROR(fsg, "can't allocate request for %s\n", ep->name);
-+	return -ENOMEM;
-+}
-+
-+/*
-+ * Reset interface setting and re-init endpoint state (toggle etc).
-+ * Call with altsetting < 0 to disable the interface.  The only other
-+ * available altsetting is 0, which enables the interface.
-+ */
-+static int do_set_interface(struct fsg_dev *fsg, int altsetting)
-+{
-+	int	rc = 0;
-+	int	i;
-+	const struct usb_endpoint_descriptor	*d;
-+
-+	if (fsg->running)
-+		DBG(fsg, "reset interface\n");
-+
-+reset:
-+	/* Deallocate the requests */
-+	for (i = 0; i < NUM_BUFFERS; ++i) {
-+		struct fsg_buffhd *bh = &fsg->buffhds[i];
-+
-+		if (bh->inreq) {
-+			usb_ep_free_request(fsg->bulk_in, bh->inreq);
-+			bh->inreq = NULL;
-+		}
-+		if (bh->outreq) {
-+			usb_ep_free_request(fsg->bulk_out, bh->outreq);
-+			bh->outreq = NULL;
-+		}
-+	}
-+	if (fsg->intreq) {
-+		usb_ep_free_request(fsg->intr_in, fsg->intreq);
-+		fsg->intreq = NULL;
-+	}
-+
-+	/* Disable the endpoints */
-+	if (fsg->bulk_in_enabled) {
-+		usb_ep_disable(fsg->bulk_in);
-+		fsg->bulk_in_enabled = 0;
-+	}
-+	if (fsg->bulk_out_enabled) {
-+		usb_ep_disable(fsg->bulk_out);
-+		fsg->bulk_out_enabled = 0;
-+	}
-+	if (fsg->intr_in_enabled) {
-+		usb_ep_disable(fsg->intr_in);
-+		fsg->intr_in_enabled = 0;
-+	}
-+
-+	fsg->running = 0;
-+	if (altsetting < 0 || rc != 0)
-+		return rc;
-+
-+	DBG(fsg, "set interface %d\n", altsetting);
-+
-+	/* Enable the endpoints */
-+	d = ep_desc(fsg->gadget, &fs_bulk_in_desc, &hs_bulk_in_desc);
-+	if ((rc = enable_endpoint(fsg, fsg->bulk_in, d)) != 0)
-+		goto reset;
-+	fsg->bulk_in_enabled = 1;
-+
-+	d = ep_desc(fsg->gadget, &fs_bulk_out_desc, &hs_bulk_out_desc);
-+	if ((rc = enable_endpoint(fsg, fsg->bulk_out, d)) != 0)
-+		goto reset;
-+	fsg->bulk_out_enabled = 1;
-+	fsg->bulk_out_maxpacket = d->wMaxPacketSize;
-+
-+	if (transport_is_cbi()) {
-+		d = ep_desc(fsg->gadget, &fs_intr_in_desc, &hs_intr_in_desc);
-+		if ((rc = enable_endpoint(fsg, fsg->intr_in, d)) != 0)
-+			goto reset;
-+		fsg->intr_in_enabled = 1;
-+	}
-+
-+	/* Allocate the requests */
-+	for (i = 0; i < NUM_BUFFERS; ++i) {
-+		struct fsg_buffhd	*bh = &fsg->buffhds[i];
-+
-+		if ((rc = alloc_request(fsg, fsg->bulk_in, &bh->inreq)) != 0)
-+			goto reset;
-+		if ((rc = alloc_request(fsg, fsg->bulk_out, &bh->outreq)) != 0)
-+			goto reset;
-+		bh->inreq->buf = bh->outreq->buf = bh->buf;
-+		bh->inreq->dma = bh->outreq->dma = bh->dma;
-+		bh->inreq->context = bh->outreq->context = bh;
-+		bh->inreq->complete = bulk_in_complete;
-+		bh->outreq->complete = bulk_out_complete;
-+	}
-+	if (transport_is_cbi()) {
-+		if ((rc = alloc_request(fsg, fsg->intr_in, &fsg->intreq)) != 0)
-+			goto reset;
-+		fsg->intreq->complete = intr_in_complete;
-+	}
-+
-+	fsg->running = 1;
-+	for (i = 0; i < fsg->nluns; ++i)
-+		fsg->luns[i].unit_attention_data = SS_RESET_OCCURRED;
-+	return rc;
-+}
-+
-+
-+/*
-+ * Change our operational configuration.  This code must agree with the code
-+ * that returns config descriptors, and with interface altsetting code.
-+ *
-+ * It's also responsible for power management interactions.  Some
-+ * configurations might not work with our current power sources.
-+ * For now we just assume the gadget is always self-powered.
-+ */
-+static int do_set_config(struct fsg_dev *fsg, u8 new_config)
-+{
-+	int	rc = 0;
-+
-+	/* Disable the single interface */
-+	if (fsg->config != 0) {
-+		DBG(fsg, "reset config\n");
-+		fsg->config = 0;
-+		rc = do_set_interface(fsg, -1);
-+	}
-+
-+	/* Enable the interface */
-+	if (new_config != 0) {
-+		fsg->config = new_config;
-+		if ((rc = do_set_interface(fsg, 0)) != 0)
-+			fsg->config = 0;	// Reset on errors
-+		else {
-+			char *speed;
-+
-+			switch (fsg->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;
-+			}
-+			INFO(fsg, "%s speed config #%d\n", speed, fsg->config);
-+		}
-+	}
-+	return rc;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void handle_exception(struct fsg_dev *fsg)
-+{
-+	siginfo_t		info;
-+	int			sig;
-+	int			i;
-+	int			num_active;
-+	struct fsg_buffhd	*bh;
-+	enum fsg_state		old_state;
-+	u8			new_config;
-+	struct lun		*curlun;
-+	unsigned int		exception_req_tag;
-+	int			rc;
-+
-+	/* Clear the existing signals.  Anything but SIGUSR1 is converted
-+	 * into a high-priority EXIT exception. */
-+	for (;;) {
-+		spin_lock_irq(&current->sigmask_lock);
-+		sig = dequeue_signal(&fsg->thread_signal_mask, &info);
-+		spin_unlock_irq(&current->sigmask_lock);
-+		if (!sig)
-+			break;
-+		if (sig != SIGUSR1) {
-+			if (fsg->state < FSG_STATE_EXIT)
-+				DBG(fsg, "Main thread exiting on signal\n");
-+			raise_exception(fsg, FSG_STATE_EXIT);
-+		}
-+	}
-+
-+	/* Cancel all the pending transfers */
-+	if (fsg->intreq_busy)
-+		usb_ep_dequeue(fsg->intr_in, fsg->intreq);
-+	for (i = 0; i < NUM_BUFFERS; ++i) {
-+		bh = &fsg->buffhds[i];
-+		if (bh->inreq_busy)
-+			usb_ep_dequeue(fsg->bulk_in, bh->inreq);
-+		if (bh->outreq_busy)
-+			usb_ep_dequeue(fsg->bulk_out, bh->outreq);
-+	}
-+
-+	/* Wait until everything is idle */
-+	for (;;) {
-+		num_active = fsg->intreq_busy;
-+		for (i = 0; i < NUM_BUFFERS; ++i) {
-+			bh = &fsg->buffhds[i];
-+			num_active += bh->inreq_busy + bh->outreq_busy;
-+		}
-+		if (num_active == 0)
-+			break;
-+		if (sleep_thread(fsg))
-+			return;
-+	}
-+
-+	/* Clear out the controller's fifos */
-+	if (fsg->bulk_in_enabled)
-+		usb_ep_fifo_flush(fsg->bulk_in);
-+	if (fsg->bulk_out_enabled)
-+		usb_ep_fifo_flush(fsg->bulk_out);
-+	if (fsg->intr_in_enabled)
-+		usb_ep_fifo_flush(fsg->intr_in);
-+
-+	/* Reset the I/O buffer states and pointers, the SCSI
-+	 * state, and the exception.  Then invoke the handler. */
-+	spin_lock_irq(&fsg->lock);
-+
-+	for (i = 0; i < NUM_BUFFERS; ++i) {
-+		bh = &fsg->buffhds[i];
-+		bh->state = BUF_STATE_EMPTY;
-+	}
-+	fsg->next_buffhd_to_fill = fsg->next_buffhd_to_drain =
-+			&fsg->buffhds[0];
-+
-+	exception_req_tag = fsg->exception_req_tag;
-+	new_config = fsg->new_config;
-+	old_state = fsg->state;
-+
-+	if (old_state == FSG_STATE_ABORT_BULK_OUT)
-+		fsg->state = FSG_STATE_STATUS_PHASE;
-+	else {
-+		for (i = 0; i < fsg->nluns; ++i) {
-+			curlun = &fsg->luns[i];
-+			curlun->prevent_medium_removal = 0;
-+			curlun->sense_data = curlun->unit_attention_data =
-+					SS_NO_SENSE;
-+			curlun->sense_data_info = 0;
-+		}
-+		fsg->state = FSG_STATE_IDLE;
-+	}
-+	spin_unlock_irq(&fsg->lock);
-+
-+	/* Carry out any extra actions required for the exception */
-+	switch (old_state) {
-+	default:
-+		break;
-+
-+	case FSG_STATE_ABORT_BULK_OUT:
-+		send_status(fsg);
-+		spin_lock_irq(&fsg->lock);
-+		if (fsg->state == FSG_STATE_STATUS_PHASE)
-+			fsg->state = FSG_STATE_IDLE;
-+		spin_unlock_irq(&fsg->lock);
-+		break;
-+
-+	case FSG_STATE_RESET:
-+		/* In case we were forced against our will to halt a
-+		 * bulk endpoint, clear the halt now.  (The SuperH UDC
-+		 * requires this.) */
-+		if (test_and_clear_bit(CLEAR_BULK_HALTS,
-+				&fsg->atomic_bitflags)) {
-+			usb_ep_clear_halt(fsg->bulk_in);
-+			usb_ep_clear_halt(fsg->bulk_out);
-+		}
-+
-+		if (transport_is_bbb()) {
-+			if (fsg->ep0_req_tag == exception_req_tag)
-+				ep0_queue(fsg);	// Complete the status stage
-+
-+		} else if (transport_is_cbi())
-+			send_status(fsg);	// Status by interrupt pipe
-+
-+		/* Technically this should go here, but it would only be
-+		 * a waste of time.  Ditto for the INTERFACE_CHANGE and
-+		 * CONFIG_CHANGE cases. */
-+		// for (i = 0; i < fsg->nluns; ++i)
-+		//	fsg->luns[i].unit_attention_data = SS_RESET_OCCURRED;
-+		break;
-+
-+	case FSG_STATE_INTERFACE_CHANGE:
-+		rc = do_set_interface(fsg, 0);
-+		if (fsg->ep0_req_tag != exception_req_tag)
-+			break;
-+		if (rc != 0)			// STALL on errors
-+			fsg_set_halt(fsg, fsg->ep0);
-+		else				// Complete the status stage
-+			ep0_queue(fsg);
-+		break;
-+
-+	case FSG_STATE_CONFIG_CHANGE:
-+		rc = do_set_config(fsg, new_config);
-+		if (fsg->ep0_req_tag != exception_req_tag)
-+			break;
-+		if (rc != 0)			// STALL on errors
-+			fsg_set_halt(fsg, fsg->ep0);
-+		else				// Complete the status stage
-+			ep0_queue(fsg);
-+		break;
-+
-+	case FSG_STATE_DISCONNECT:
-+		fsync_all(fsg);
-+		do_set_config(fsg, 0);		// Unconfigured state
-+		break;
-+
-+	case FSG_STATE_EXIT:
-+	case FSG_STATE_TERMINATED:
-+		do_set_config(fsg, 0);			// Free resources
-+		spin_lock_irq(&fsg->lock);
-+		fsg->state = FSG_STATE_TERMINATED;	// Stop the thread
-+		spin_unlock_irq(&fsg->lock);
-+		break;
-+	}
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int fsg_main_thread(void *fsg_)
-+{
-+	struct fsg_dev		*fsg = (struct fsg_dev *) fsg_;
-+
-+	fsg->thread_task = current;
-+
-+	/* Release all our userspace resources */
-+	daemonize();
-+	reparent_to_init();
-+	strncpy(current->comm, "file-storage-gadget",
-+			sizeof(current->comm) - 1);
-+
-+	/* Allow the thread to be killed by a signal, but set the signal mask
-+	 * to block everything but INT, TERM, KILL, and USR1. */
-+	siginitsetinv(&fsg->thread_signal_mask, sigmask(SIGINT) |
-+			sigmask(SIGTERM) | sigmask(SIGKILL) |
-+			sigmask(SIGUSR1));
-+	spin_lock_irq(&current->sigmask_lock);
-+	flush_signals(current);
-+	current->blocked = fsg->thread_signal_mask;
-+	recalc_sigpending(current);
-+	spin_unlock_irq(&current->sigmask_lock);
-+
-+	/* Arrange for userspace references to be interpreted as kernel
-+	 * pointers.  That way we can pass a kernel pointer to a routine
-+	 * that expects a __user pointer and it will work okay. */
-+	set_fs(get_ds());
-+
-+	/* Wait for the gadget registration to finish up */
-+	wait_for_completion(&fsg->thread_notifier);
-+
-+	/* The main loop */
-+	while (fsg->state != FSG_STATE_TERMINATED) {
-+		if (exception_in_progress(fsg) || signal_pending(current)) {
-+			handle_exception(fsg);
-+			continue;
-+		}
-+
-+		if (!fsg->running) {
-+			sleep_thread(fsg);
-+			continue;
-+		}
-+
-+		if (get_next_command(fsg))
-+			continue;
-+
-+		spin_lock_irq(&fsg->lock);
-+		if (!exception_in_progress(fsg))
-+			fsg->state = FSG_STATE_DATA_PHASE;
-+		spin_unlock_irq(&fsg->lock);
-+
-+		if (do_scsi_command(fsg) || finish_reply(fsg))
-+			continue;
-+
-+		spin_lock_irq(&fsg->lock);
-+		if (!exception_in_progress(fsg))
-+			fsg->state = FSG_STATE_STATUS_PHASE;
-+		spin_unlock_irq(&fsg->lock);
-+
-+		if (send_status(fsg))
-+			continue;
-+
-+		spin_lock_irq(&fsg->lock);
-+		if (!exception_in_progress(fsg))
-+			fsg->state = FSG_STATE_IDLE;
-+		spin_unlock_irq(&fsg->lock);
-+		}
-+
-+	fsg->thread_task = NULL;
-+	flush_signals(current);
-+
-+	/* In case we are exiting because of a signal, unregister the
-+	 * gadget driver and close the backing file. */
-+	if (test_and_clear_bit(REGISTERED, &fsg->atomic_bitflags)) {
-+		usb_gadget_unregister_driver(&fsg_driver);
-+		close_all_backing_files(fsg);
-+	}
-+
-+	/* Let the unbind and cleanup routines know the thread has exited */
-+	complete_and_exit(&fsg->thread_notifier, 0);
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* If the next two routines are called while the gadget is registered,
-+ * the caller must own fsg->filesem for writing. */
-+
-+static int NORMALLY_INIT open_backing_file(struct lun *curlun,
-+		const char *filename)
-+{
-+	int				ro;
-+	struct file			*filp = NULL;
-+	int				rc = -EINVAL;
-+	struct inode			*inode = NULL;
-+	loff_t				size;
-+	loff_t				num_sectors;
-+
-+	/* R/W if we can, R/O if we must */
-+	ro = curlun->ro;
-+	if (!ro) {
-+		filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
-+		if (-EROFS == PTR_ERR(filp))
-+			ro = 1;
-+	}
-+	if (ro)
-+		filp = filp_open(filename, O_RDONLY | O_LARGEFILE, 0);
-+	if (IS_ERR(filp)) {
-+		LINFO(curlun, "unable to open backing file: %s\n", filename);
-+		return PTR_ERR(filp);
-+	}
-+
-+	if (!(filp->f_mode & FMODE_WRITE))
-+		ro = 1;
-+
-+	if (filp->f_dentry)
-+		inode = filp->f_dentry->d_inode;
-+	if (inode && S_ISBLK(inode->i_mode)) {
-+		kdev_t		dev = inode->i_rdev;
-+
-+		if (blk_size[MAJOR(dev)])
-+			size = (loff_t) blk_size[MAJOR(dev)][MINOR(dev)] <<
-+					BLOCK_SIZE_BITS;
-+		else {
-+			LINFO(curlun, "unable to find file size: %s\n",
-+					filename);
-+			goto out;
-+		}
-+	} else if (inode && S_ISREG(inode->i_mode))
-+		size = inode->i_size;
-+	else {
-+		LINFO(curlun, "invalid file type: %s\n", filename);
-+		goto out;
-+	}
-+
-+	/* If we can't read the file, it's no good.
-+	 * If we can't write the file, use it read-only. */
-+	if (!filp->f_op || !filp->f_op->read) {
-+		LINFO(curlun, "file not readable: %s\n", filename);
-+		goto out;
-+	}
-+	if (IS_RDONLY(inode) || !filp->f_op->write)
-+		ro = 1;
-+
-+	num_sectors = size >> 9;	// File size in 512-byte sectors
-+	if (num_sectors == 0) {
-+		LINFO(curlun, "file too small: %s\n", filename);
-+		rc = -ETOOSMALL;
-+		goto out;
-+	}
-+
-+	get_file(filp);
-+	curlun->ro = ro;
-+	curlun->filp = filp;
-+	curlun->file_length = size;
-+	curlun->num_sectors = num_sectors;
-+	LDBG(curlun, "open backing file: %s\n", filename);
-+	rc = 0;
-+
-+out:
-+	filp_close(filp, current->files);
-+	return rc;
-+}
-+
-+
-+static void close_backing_file(struct lun *curlun)
-+{
-+	if (curlun->filp) {
-+		LDBG(curlun, "close backing file\n");
-+		fput(curlun->filp);
-+		curlun->filp = NULL;
-+	}
-+}
-+
-+static void close_all_backing_files(struct fsg_dev *fsg)
-+{
-+	int	i;
-+
-+	for (i = 0; i < fsg->nluns; ++i)
-+		close_backing_file(&fsg->luns[i]);
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void fsg_unbind(struct usb_gadget *gadget)
-+{
-+	struct fsg_dev		*fsg = get_gadget_data(gadget);
-+	int			i;
-+	struct usb_request	*req = fsg->ep0req;
-+
-+	DBG(fsg, "unbind\n");
-+	clear_bit(REGISTERED, &fsg->atomic_bitflags);
-+
-+	/* If the thread isn't already dead, tell it to exit now */
-+	if (fsg->state != FSG_STATE_TERMINATED) {
-+		raise_exception(fsg, FSG_STATE_EXIT);
-+		wait_for_completion(&fsg->thread_notifier);
-+
-+		/* The cleanup routine waits for this completion also */
-+		complete(&fsg->thread_notifier);
-+	}
-+
-+	/* Free the data buffers */
-+	for (i = 0; i < NUM_BUFFERS; ++i) {
-+		struct fsg_buffhd	*bh = &fsg->buffhds[i];
-+
-+		if (bh->buf)
-+			usb_ep_free_buffer(fsg->bulk_in, bh->buf, bh->dma,
-+					mod_data.buflen);
-+	}
-+
-+	/* Free the request and buffer for endpoint 0 */
-+	if (req) {
-+		if (req->buf)
-+			usb_ep_free_buffer(fsg->ep0, req->buf,
-+					req->dma, EP0_BUFSIZE);
-+		usb_ep_free_request(fsg->ep0, req);
-+	}
-+
-+	set_gadget_data(gadget, 0);
-+}
-+
-+
-+static int __init check_parameters(struct fsg_dev *fsg)
-+{
-+	int	prot;
-+
-+	/* Store the default values */
-+	mod_data.transport_type = USB_PR_BULK;
-+	mod_data.transport_name = "Bulk-only";
-+	mod_data.protocol_type = USB_SC_SCSI;
-+	mod_data.protocol_name = "Transparent SCSI";
-+
-+	if (gadget_is_sh(fsg->gadget))
-+		mod_data.can_stall = 0;
-+
-+	if (mod_data.release == 0xffff) {	// Parameter wasn't set
-+		if (gadget_is_net2280(fsg->gadget))
-+			mod_data.release = __constant_cpu_to_le16(0x0221);
-+		else if (gadget_is_dummy(fsg->gadget))
-+			mod_data.release = __constant_cpu_to_le16(0x0222);
-+		else if (gadget_is_pxa(fsg->gadget))
-+			mod_data.release = __constant_cpu_to_le16(0x0223);
-+		else if (gadget_is_sh(fsg->gadget))
-+			mod_data.release = __constant_cpu_to_le16(0x0224);
-+
-+		/* The sa1100 controller is not supported */
-+
-+		else if (gadget_is_goku(fsg->gadget))
-+			mod_data.release = __constant_cpu_to_le16(0x0226);
-+		else if (gadget_is_mq11xx(fsg->gadget))
-+			mod_data.release = __constant_cpu_to_le16(0x0227);
-+		else if (gadget_is_omap(fsg->gadget))
-+			mod_data.release = __constant_cpu_to_le16(0x0228);
-+		else {
-+			WARN(fsg, "controller '%s' not recognized\n",
-+				fsg->gadget->name);
-+			mod_data.release = __constant_cpu_to_le16(0x0299);
-+		}
-+	}
-+
-+	prot = simple_strtol(mod_data.protocol_parm, NULL, 0);
-+
-+#ifdef CONFIG_USB_FILE_STORAGE_TEST
-+	if (strnicmp(mod_data.transport_parm, "BBB", 10) == 0) {
-+		;		// Use default setting
-+	} else if (strnicmp(mod_data.transport_parm, "CB", 10) == 0) {
-+		mod_data.transport_type = USB_PR_CB;
-+		mod_data.transport_name = "Control-Bulk";
-+	} else if (strnicmp(mod_data.transport_parm, "CBI", 10) == 0) {
-+		mod_data.transport_type = USB_PR_CBI;
-+		mod_data.transport_name = "Control-Bulk-Interrupt";
-+	} else {
-+		ERROR(fsg, "invalid transport: %s\n", mod_data.transport_parm);
-+		return -EINVAL;
-+	}
-+
-+	if (strnicmp(mod_data.protocol_parm, "SCSI", 10) == 0 ||
-+			prot == USB_SC_SCSI) {
-+		;		// Use default setting
-+	} else if (strnicmp(mod_data.protocol_parm, "RBC", 10) == 0 ||
-+			prot == USB_SC_RBC) {
-+		mod_data.protocol_type = USB_SC_RBC;
-+		mod_data.protocol_name = "RBC";
-+	} else if (strnicmp(mod_data.protocol_parm, "8020", 4) == 0 ||
-+			strnicmp(mod_data.protocol_parm, "ATAPI", 10) == 0 ||
-+			prot == USB_SC_8020) {
-+		mod_data.protocol_type = USB_SC_8020;
-+		mod_data.protocol_name = "8020i (ATAPI)";
-+	} else if (strnicmp(mod_data.protocol_parm, "QIC", 3) == 0 ||
-+			prot == USB_SC_QIC) {
-+		mod_data.protocol_type = USB_SC_QIC;
-+		mod_data.protocol_name = "QIC-157";
-+	} else if (strnicmp(mod_data.protocol_parm, "UFI", 10) == 0 ||
-+			prot == USB_SC_UFI) {
-+		mod_data.protocol_type = USB_SC_UFI;
-+		mod_data.protocol_name = "UFI";
-+	} else if (strnicmp(mod_data.protocol_parm, "8070", 4) == 0 ||
-+			prot == USB_SC_8070) {
-+		mod_data.protocol_type = USB_SC_8070;
-+		mod_data.protocol_name = "8070i";
-+	} else {
-+		ERROR(fsg, "invalid protocol: %s\n", mod_data.protocol_parm);
-+		return -EINVAL;
-+	}
-+
-+	mod_data.buflen &= PAGE_CACHE_MASK;
-+	if (mod_data.buflen <= 0) {
-+		ERROR(fsg, "invalid buflen\n");
-+		return -ETOOSMALL;
-+	}
-+#endif /* CONFIG_USB_FILE_STORAGE_TEST */
-+
-+	return 0;
-+}
-+
-+
-+static int __init fsg_bind(struct usb_gadget *gadget)
-+{
-+	struct fsg_dev		*fsg = the_fsg;
-+	int			rc;
-+	int			i;
-+	struct lun		*curlun;
-+	struct usb_ep		*ep;
-+	struct usb_request	*req;
-+	char			*pathbuf, *p;
-+
-+	fsg->gadget = gadget;
-+	set_gadget_data(gadget, fsg);
-+	fsg->ep0 = gadget->ep0;
-+	fsg->ep0->driver_data = fsg;
-+
-+	if ((rc = check_parameters(fsg)) != 0)
-+		goto out;
-+
-+	/* Find out how many LUNs there should be */
-+	i = mod_data.nluns;
-+	if (i == 0) {
-+		for (i = MAX_LUNS; i > 1; --i) {
-+			if (file[i - 1])
-+				break;
-+		}
-+	}
-+	if (i > MAX_LUNS) {
-+		ERROR(fsg, "invalid number of LUNs: %d\n", i);
-+		rc = -EINVAL;
-+		goto out;
-+	}
-+
-+	/* Create the LUNs and open their backing files.  We can't register
-+	 * the LUN devices until the gadget itself is registered, which
-+	 * doesn't happen until after fsg_bind() returns. */
-+	fsg->luns = kmalloc(i * sizeof(struct lun), GFP_KERNEL);
-+	if (!fsg->luns) {
-+		rc = -ENOMEM;
-+		goto out;
-+	}
-+	memset(fsg->luns, 0, i * sizeof(struct lun));
-+	fsg->nluns = i;
-+
-+	for (i = 0; i < fsg->nluns; ++i) {
-+		curlun = &fsg->luns[i];
-+		curlun->ro = ro[i];
-+		curlun->dev.driver_data = fsg;
-+		snprintf(curlun->dev.name, BUS_ID_SIZE,
-+				"%s-lun%d", gadget->name, i);
-+
-+		if (file[i] && *file[i]) {
-+			if ((rc = open_backing_file(curlun, file[i])) != 0)
-+				goto out;
-+		} else if (!mod_data.removable) {
-+			ERROR(fsg, "no file given for LUN%d\n", i);
-+			rc = -EINVAL;
-+			goto out;
-+		}
-+	}
-+
-+	/* Find all the endpoints we will use */
-+	usb_ep_autoconfig_reset(gadget);
-+	ep = usb_ep_autoconfig(gadget, &fs_bulk_in_desc);
-+	if (!ep)
-+		goto autoconf_fail;
-+	ep->driver_data = fsg;		// claim the endpoint
-+	fsg->bulk_in = ep;
-+
-+	ep = usb_ep_autoconfig(gadget, &fs_bulk_out_desc);
-+	if (!ep)
-+		goto autoconf_fail;
-+	ep->driver_data = fsg;		// claim the endpoint
-+	fsg->bulk_out = ep;
-+
-+	if (transport_is_cbi()) {
-+		ep = usb_ep_autoconfig(gadget, &fs_intr_in_desc);
-+		if (!ep)
-+			goto autoconf_fail;
-+		ep->driver_data = fsg;		// claim the endpoint
-+		fsg->intr_in = ep;
-+	}
-+
-+	/* Fix up the descriptors */
-+	device_desc.bMaxPacketSize0 = fsg->ep0->maxpacket;
-+	device_desc.idVendor = cpu_to_le16(mod_data.vendor);
-+	device_desc.idProduct = cpu_to_le16(mod_data.product);
-+	device_desc.bcdDevice = cpu_to_le16(mod_data.release);
-+
-+	i = (transport_is_cbi() ? 3 : 2);	// Number of endpoints
-+	intf_desc.bNumEndpoints = i;
-+	intf_desc.bInterfaceSubClass = mod_data.protocol_type;
-+	intf_desc.bInterfaceProtocol = mod_data.transport_type;
-+	fs_function[i+1] = NULL;
-+
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+	hs_function[i+1] = NULL;
-+
-+	/* Assume ep0 uses the same maxpacket value for both speeds */
-+	dev_qualifier.bMaxPacketSize0 = fsg->ep0->maxpacket;
-+
-+	/* Assume that all endpoint addresses are the same for both speeds */
-+	hs_bulk_in_desc.bEndpointAddress = fs_bulk_in_desc.bEndpointAddress;
-+	hs_bulk_out_desc.bEndpointAddress = fs_bulk_out_desc.bEndpointAddress;
-+	hs_intr_in_desc.bEndpointAddress = fs_intr_in_desc.bEndpointAddress;
-+#endif
-+
-+	rc = -ENOMEM;
-+
-+	/* Allocate the request and buffer for endpoint 0 */
-+	fsg->ep0req = req = usb_ep_alloc_request(fsg->ep0, GFP_KERNEL);
-+	if (!req)
-+		goto out;
-+	req->buf = usb_ep_alloc_buffer(fsg->ep0, EP0_BUFSIZE,
-+			&req->dma, GFP_KERNEL);
-+	if (!req->buf)
-+		goto out;
-+	req->complete = ep0_complete;
-+
-+	/* Allocate the data buffers */
-+	for (i = 0; i < NUM_BUFFERS; ++i) {
-+		struct fsg_buffhd	*bh = &fsg->buffhds[i];
-+
-+		bh->buf = usb_ep_alloc_buffer(fsg->bulk_in, mod_data.buflen,
-+				&bh->dma, GFP_KERNEL);
-+		if (!bh->buf)
-+			goto out;
-+		bh->next = bh + 1;
-+	}
-+	fsg->buffhds[NUM_BUFFERS - 1].next = &fsg->buffhds[0];
-+
-+	/* This should reflect the actual gadget power source */
-+	usb_gadget_set_selfpowered(gadget);
-+
-+	snprintf(manufacturer, sizeof manufacturer,
-+			UTS_SYSNAME " " UTS_RELEASE " with %s",
-+			gadget->name);
-+
-+	/* On a real device, serial[] would be loaded from permanent
-+	 * storage.  We just encode it from the driver version string. */
-+	for (i = 0; i < sizeof(serial) - 2; i += 2) {
-+		unsigned char		c = DRIVER_VERSION[i / 2];
-+
-+		if (!c)
-+			break;
-+		sprintf(&serial[i], "%02X", c);
-+	}
-+
-+	if ((rc = kernel_thread(fsg_main_thread, fsg, (CLONE_VM | CLONE_FS |
-+			CLONE_FILES))) < 0)
-+		goto out;
-+	fsg->thread_pid = rc;
-+
-+	INFO(fsg, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
-+	INFO(fsg, "Number of LUNs=%d\n", fsg->nluns);
-+
-+	pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
-+	for (i = 0; i < fsg->nluns; ++i) {
-+		curlun = &fsg->luns[i];
-+		if (backing_file_is_open(curlun)) {
-+			p = NULL;
-+			if (pathbuf) {
-+				p = d_path(curlun->filp->f_dentry,
-+					curlun->filp->f_vfsmnt,
-+					pathbuf, PATH_MAX);
-+				if (IS_ERR(p))
-+					p = NULL;
-+			}
-+			LINFO(curlun, "ro=%d, file: %s\n",
-+					curlun->ro, (p ? p : "(error)"));
-+		}
-+	}
-+	kfree(pathbuf);
-+
-+	DBG(fsg, "transport=%s (x%02x)\n",
-+			mod_data.transport_name, mod_data.transport_type);
-+	DBG(fsg, "protocol=%s (x%02x)\n",
-+			mod_data.protocol_name, mod_data.protocol_type);
-+	DBG(fsg, "VendorID=x%04x, ProductID=x%04x, Release=x%04x\n",
-+			mod_data.vendor, mod_data.product, mod_data.release);
-+	DBG(fsg, "removable=%d, stall=%d, buflen=%u\n",
-+			mod_data.removable, mod_data.can_stall,
-+			mod_data.buflen);
-+	DBG(fsg, "I/O thread pid: %d\n", fsg->thread_pid);
-+	return 0;
-+
-+autoconf_fail:
-+	ERROR(fsg, "unable to autoconfigure all endpoints\n");
-+	rc = -ENOTSUPP;
-+
-+out:
-+	fsg->state = FSG_STATE_TERMINATED;	// The thread is dead
-+	fsg_unbind(gadget);
-+	close_all_backing_files(fsg);
-+	return rc;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static struct usb_gadget_driver		fsg_driver = {
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+	.speed		= USB_SPEED_HIGH,
-+#else
-+	.speed		= USB_SPEED_FULL,
-+#endif
-+	.function	= (char *) longname,
-+	.bind		= fsg_bind,
-+	.unbind		= fsg_unbind,
-+	.disconnect	= fsg_disconnect,
-+	.setup		= fsg_setup,
-+
-+	.driver		= {
-+		.name		= (char *) shortname,
-+		// .release = ...
-+		// .suspend = ...
-+		// .resume = ...
-+	},
-+};
-+
-+
-+static int __init fsg_alloc(void)
-+{
-+	struct fsg_dev		*fsg;
-+
-+	fsg = kmalloc(sizeof *fsg, GFP_KERNEL);
-+	if (!fsg)
-+		return -ENOMEM;
-+	memset(fsg, 0, sizeof *fsg);
-+	spin_lock_init(&fsg->lock);
-+	init_rwsem(&fsg->filesem);
-+	init_waitqueue_head(&fsg->thread_wqh);
-+	init_completion(&fsg->thread_notifier);
-+
-+	the_fsg = fsg;
-+	return 0;
-+}
-+
-+
-+static void fsg_free(struct fsg_dev *fsg)
-+{
-+	kfree(fsg->luns);
-+	kfree(fsg);
-+}
-+
-+
-+static int __init fsg_init(void)
-+{
-+	int		rc;
-+	struct fsg_dev	*fsg;
-+
-+	/* Put the module parameters where they belong -- arghh! */
-+	mod_data.nluns = luns;
-+	mod_data.transport_parm = transport;
-+	mod_data.protocol_parm = protocol;
-+	mod_data.removable = removable;
-+	mod_data.vendor = vendor;
-+	mod_data.product = product;
-+	mod_data.release = release;
-+	mod_data.buflen = buflen;
-+	mod_data.can_stall = stall;
-+
-+	if ((rc = fsg_alloc()) != 0)
-+		return rc;
-+	fsg = the_fsg;
-+	if ((rc = usb_gadget_register_driver(&fsg_driver)) != 0) {
-+		fsg_free(fsg);
-+		return rc;
-+	}
-+	set_bit(REGISTERED, &fsg->atomic_bitflags);
-+
-+	/* Tell the thread to start working */
-+	complete(&fsg->thread_notifier);
-+	return 0;
-+}
-+module_init(fsg_init);
-+
-+
-+static void __exit fsg_cleanup(void)
-+{
-+	struct fsg_dev	*fsg = the_fsg;
-+
-+	/* Unregister the driver iff the thread hasn't already done so */
-+	if (test_and_clear_bit(REGISTERED, &fsg->atomic_bitflags))
-+		usb_gadget_unregister_driver(&fsg_driver);
-+
-+	/* Wait for the thread to finish up */
-+	wait_for_completion(&fsg->thread_notifier);
-+
-+	close_all_backing_files(fsg);
-+	fsg_free(fsg);
-+}
-+module_exit(fsg_cleanup);
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/gadget_chips.h kernel/drivers/usb/gadget/gadget_chips.h
---- /tmp/kernel/drivers/usb/gadget/gadget_chips.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/gadget_chips.h	2005-04-22 17:53:19.434539516 +0200
-@@ -0,0 +1,92 @@
-+/*
-+ * USB device controllers have lots of quirks.  Use these macros in
-+ * gadget drivers or other code that needs to deal with them, and which
-+ * autoconfigures instead of using early binding to the hardware.
-+ *
-+ * This could eventually work like the ARM mach_is_*() stuff, driven by
-+ * some config file that gets updated as new hardware is supported.
-+ *
-+ * NOTE:  some of these controller drivers may not be available yet.
-+ */
-+#ifdef CONFIG_USB_GADGET_NET2280
-+#define	gadget_is_net2280(g)	!strcmp("net2280", (g)->name)
-+#else
-+#define	gadget_is_net2280(g)	0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_DUMMY_HCD
-+#define	gadget_is_dummy(g)	!strcmp("dummy_udc", (g)->name)
-+#else
-+#define	gadget_is_dummy(g)	0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_PXA2XX
-+#define	gadget_is_pxa(g)	!strcmp("pxa2xx_udc", (g)->name)
-+#else
-+#define	gadget_is_pxa(g)	0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_GOKU
-+#define	gadget_is_goku(g)	!strcmp("goku_udc", (g)->name)
-+#else
-+#define	gadget_is_goku(g)	0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_SUPERH
-+#define	gadget_is_sh(g)		!strcmp("sh_udc", (g)->name)
-+#else
-+#define	gadget_is_sh(g)		0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_SA1100
-+#define	gadget_is_sa1100(g)	!strcmp("sa1100_udc", (g)->name)
-+#else
-+#define	gadget_is_sa1100(g)	0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_LH7A40X
-+#define	gadget_is_lh7a40x(g)	!strcmp("lh7a40x_udc", (g)->name)
-+#else
-+#define	gadget_is_lh7a40x(g)	0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_MQ11XX
-+#define	gadget_is_mq11xx(g)	!strcmp("mq11xx_udc", (g)->name)
-+#else
-+#define	gadget_is_mq11xx(g)	0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_OMAP
-+#define	gadget_is_omap(g)	!strcmp("omap_udc", (g)->name)
-+#else
-+#define	gadget_is_omap(g)	0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_N9604
-+#define	gadget_is_n9604(g)	!strcmp("n9604_udc", (g)->name)
-+#else
-+#define	gadget_is_n9604(g)	0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_PXA27X
-+#define	gadget_is_pxa27x(g)	!strcmp("pxa27x_udc", (g)->name)
-+#else
-+#define	gadget_is_pxa27x(g)	0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_S3C2410
-+#define gadget_is_s3c2410(g)    !strcmp("s3c2410_udc", (g)->name)
-+#else
-+#define gadget_is_s3c2410(g)    0
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_AT91
-+#define gadget_is_at91(g)	!strcmp("at91_udc", (g)->name)
-+#else
-+#define gadget_is_at91(g)	0
-+#endif
-+
-+// CONFIG_USB_GADGET_SX2
-+// CONFIG_USB_GADGET_AU1X00
-+// ...
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/goku_udc.c kernel/drivers/usb/gadget/goku_udc.c
---- /tmp/kernel/drivers/usb/gadget/goku_udc.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/goku_udc.c	2005-04-22 17:53:19.440538539 +0200
-@@ -0,0 +1,1975 @@
-+/*
-+ * Toshiba TC86C001 ("Goku-S") USB Device Controller driver
-+ *
-+ * Copyright (C) 2000-2002 Lineo
-+ *      by Stuart Lynne, Tom Rushworth, and Bruce Balden
-+ * Copyright (C) 2002 Toshiba Corporation
-+ * Copyright (C) 2003 MontaVista Software (source@mvista.com)
-+ *
-+ * This file is licensed under the terms of the GNU General Public
-+ * License version 2.  This program is licensed "as is" without any
-+ * warranty of any kind, whether express or implied.
-+ */
-+
-+/*
-+ * This device has ep0 and three semi-configurable bulk/interrupt endpoints.
-+ *
-+ *  - Endpoint numbering is fixed: ep{1,2,3}-bulk
-+ *  - Gadget drivers can choose ep maxpacket (8/16/32/64)
-+ *  - Gadget drivers can choose direction (IN, OUT)
-+ *  - DMA works with ep1 (OUT transfers) and ep2 (IN transfers).
-+ */
-+
-+#undef DEBUG
-+// #define	VERBOSE		/* extra debug messages (success too) */
-+// #define	USB_TRACE	/* packet-level success messages */
-+
-+#include <linux/config.h>
-+#include <linux/kernel.h>
-+#include <linux/module.h>
-+#include <linux/pci.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/proc_fs.h>
-+#include <linux/usb_ch9.h>
-+#include <linux/usb_gadget.h>
-+
-+#include <asm/byteorder.h>
-+#include <asm/io.h>
-+#include <asm/irq.h>
-+#include <asm/system.h>
-+#include <asm/unaligned.h>
-+
-+
-+#include "goku_udc.h"
-+
-+#define	DRIVER_DESC		"TC86C001 USB Device Controller"
-+#define	DRIVER_VERSION		"30-Oct 2003"
-+
-+#define	DMA_ADDR_INVALID	(~(dma_addr_t)0)
-+
-+static const char driver_name [] = "goku_udc";
-+static const char driver_desc [] = DRIVER_DESC;
-+
-+MODULE_AUTHOR("source@mvista.com");
-+MODULE_DESCRIPTION(DRIVER_DESC);
-+MODULE_LICENSE("GPL");
-+
-+
-+/*
-+ * IN dma behaves ok under testing, though the IN-dma abort paths don't
-+ * seem to behave quite as expected.  Used by default.
-+ *
-+ * OUT dma documents design problems handling the common "short packet"
-+ * transfer termination policy; it couldn't enabled by default, even
-+ * if the OUT-dma abort problems had a resolution.
-+ */
-+static unsigned use_dma = 1;
-+
-+#if 0
-+//#include <linux/moduleparam.h>
-+/* "modprobe goku_udc use_dma=1" etc
-+ *	0 to disable dma
-+ *	1 to use IN dma only (normal operation)
-+ *	2 to use IN and OUT dma
-+ */
-+module_param(use_dma, uint, S_IRUGO);
-+#endif
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void nuke(struct goku_ep *, int status);
-+
-+static inline void
-+command(struct goku_udc_regs *regs, int command, unsigned epnum)
-+{
-+	writel(COMMAND_EP(epnum) | command, &regs->Command);
-+	udelay(300);
-+}
-+
-+static int
-+goku_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
-+{
-+	struct goku_udc	*dev;
-+	struct goku_ep	*ep;
-+	u32		mode;
-+	u16		max;
-+	unsigned long	flags;
-+
-+	ep = container_of(_ep, struct goku_ep, ep);
-+	if (!_ep || !desc || ep->desc
-+			|| desc->bDescriptorType != USB_DT_ENDPOINT)
-+		return -EINVAL;
-+	dev = ep->dev;
-+	if (ep == &dev->ep[0])
-+		return -EINVAL;
-+	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
-+		return -ESHUTDOWN;
-+	if (ep->num != (desc->bEndpointAddress & 0x0f))
-+		return -EINVAL;
-+
-+	switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
-+	case USB_ENDPOINT_XFER_BULK:
-+	case USB_ENDPOINT_XFER_INT:
-+		break;
-+	default:
-+		return -EINVAL;
-+	}
-+
-+	if ((readl(ep->reg_status) & EPxSTATUS_EP_MASK)
-+			!= EPxSTATUS_EP_INVALID)
-+		return -EBUSY;
-+
-+	/* enabling the no-toggle interrupt mode would need an api hook */
-+	mode = 0;
-+	max = le16_to_cpu(get_unaligned(&desc->wMaxPacketSize));
-+	switch (max) {
-+	case 64:	mode++;
-+	case 32:	mode++;
-+	case 16:	mode++;
-+	case 8:		mode <<= 3;
-+			break;
-+	default:
-+		return -EINVAL;
-+	}
-+	mode |= 2 << 1;		/* bulk, or intr-with-toggle */
-+
-+	/* ep1/ep2 dma direction is chosen early; it works in the other
-+	 * direction, with pio.  be cautious with out-dma.
-+	 */
-+	ep->is_in = (USB_DIR_IN & desc->bEndpointAddress) != 0;
-+	if (ep->is_in) {
-+		mode |= 1;
-+		ep->dma = (use_dma != 0) && (ep->num == UDC_MSTRD_ENDPOINT);
-+	} else {
-+		ep->dma = (use_dma == 2) && (ep->num == UDC_MSTWR_ENDPOINT);
-+		if (ep->dma)
-+			DBG(dev, "%s out-dma hides short packets\n",
-+				ep->ep.name);
-+	}
-+
-+	spin_lock_irqsave(&ep->dev->lock, flags);
-+
-+	/* ep1 and ep2 can do double buffering and/or dma */
-+	if (ep->num < 3) {
-+		struct goku_udc_regs	*regs = ep->dev->regs;
-+		u32			tmp;
-+
-+		/* double buffer except (for now) with pio in */
-+		tmp = ((ep->dma || !ep->is_in)
-+				? 0x10	/* double buffered */
-+				: 0x11	/* single buffer */
-+			) << ep->num;
-+		tmp |= readl(&regs->EPxSingle);
-+		writel(tmp, &regs->EPxSingle);
-+
-+		tmp = (ep->dma ? 0x10/*dma*/ : 0x11/*pio*/) << ep->num;
-+		tmp |= readl(&regs->EPxBCS);
-+		writel(tmp, &regs->EPxBCS);
-+	}
-+	writel(mode, ep->reg_mode);
-+	command(ep->dev->regs, COMMAND_RESET, ep->num);
-+	ep->ep.maxpacket = max;
-+	ep->stopped = 0;
-+	ep->desc = desc;
-+	spin_unlock_irqrestore(&ep->dev->lock, flags);
-+
-+	DBG(dev, "enable %s %s %s maxpacket %u\n", ep->ep.name,
-+		ep->is_in ? "IN" : "OUT",
-+		ep->dma ? "dma" : "pio",
-+		max);
-+
-+	return 0;
-+}
-+
-+static void ep_reset(struct goku_udc_regs *regs, struct goku_ep *ep)
-+{
-+	struct goku_udc		*dev = ep->dev;
-+
-+	if (regs) {
-+		command(regs, COMMAND_INVALID, ep->num);
-+		if (ep->num) {
-+			if (ep->num == UDC_MSTWR_ENDPOINT)
-+				dev->int_enable &= ~(INT_MSTWREND
-+							|INT_MSTWRTMOUT);
-+			else if (ep->num == UDC_MSTRD_ENDPOINT)
-+				dev->int_enable &= ~INT_MSTRDEND;
-+			dev->int_enable &= ~INT_EPxDATASET (ep->num);
-+		} else
-+			dev->int_enable &= ~INT_EP0;
-+		writel(dev->int_enable, &regs->int_enable);
-+		readl(&regs->int_enable);
-+		if (ep->num < 3) {
-+			struct goku_udc_regs	*regs = ep->dev->regs;
-+			u32			tmp;
-+
-+			tmp = readl(&regs->EPxSingle);
-+			tmp &= ~(0x11 << ep->num);
-+			writel(tmp, &regs->EPxSingle);
-+
-+			tmp = readl(&regs->EPxBCS);
-+			tmp &= ~(0x11 << ep->num);
-+			writel(tmp, &regs->EPxBCS);
-+		}
-+		/* reset dma in case we're still using it */
-+		if (ep->dma) {
-+			u32	master;
-+
-+			master = readl(&regs->dma_master) & MST_RW_BITS;
-+			if (ep->num == UDC_MSTWR_ENDPOINT) {
-+				master &= ~MST_W_BITS;
-+				master |= MST_WR_RESET;
-+			} else {
-+				master &= ~MST_R_BITS;
-+				master |= MST_RD_RESET;
-+			}
-+			writel(master, &regs->dma_master);
-+		}
-+	}
-+
-+	ep->ep.maxpacket = MAX_FIFO_SIZE;
-+	ep->desc = 0;
-+	ep->stopped = 1;
-+	ep->irqs = 0;
-+	ep->dma = 0;
-+}
-+
-+static int goku_ep_disable(struct usb_ep *_ep)
-+{
-+	struct goku_ep	*ep;
-+	struct goku_udc	*dev;
-+	unsigned long	flags;
-+
-+	ep = container_of(_ep, struct goku_ep, ep);
-+	if (!_ep || !ep->desc)
-+		return -ENODEV;
-+	dev = ep->dev;
-+	if (dev->ep0state == EP0_SUSPEND)
-+		return -EBUSY;
-+
-+	VDBG(dev, "disable %s\n", _ep->name);
-+
-+	spin_lock_irqsave(&dev->lock, flags);
-+	nuke(ep, -ESHUTDOWN);
-+	ep_reset(dev->regs, ep);
-+	spin_unlock_irqrestore(&dev->lock, flags);
-+
-+	return 0;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static struct usb_request *
-+goku_alloc_request(struct usb_ep *_ep, int gfp_flags)
-+{
-+	struct goku_request	*req;
-+
-+	if (!_ep)
-+		return 0;
-+	req = kmalloc(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
-+goku_free_request(struct usb_ep *_ep, struct usb_request *_req)
-+{
-+	struct goku_request	*req;
-+
-+	if (!_ep || !_req)
-+		return;
-+
-+	req = container_of(_req, struct goku_request, req);
-+	WARN_ON(!list_empty(&req->queue));
-+	kfree(req);
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#undef USE_KMALLOC
-+
-+/* many common platforms have dma-coherent caches, which means that it's
-+ * safe to use kmalloc() memory for all i/o buffers without using any
-+ * cache flushing calls.  (unless you're trying to share cache lines
-+ * between dma and non-dma activities, which is a slow idea in any case.)
-+ *
-+ * other platforms need more care, with 2.6 having a moderately general
-+ * solution except for the common "buffer is smaller than a page" case.
-+ */
-+#if	defined(CONFIG_X86)
-+#define USE_KMALLOC
-+
-+#elif	defined(CONFIG_MIPS) && !defined(CONFIG_NONCOHERENT_IO)
-+#define USE_KMALLOC
-+
-+#elif	defined(CONFIG_PPC) && !defined(CONFIG_NOT_COHERENT_CACHE)
-+#define USE_KMALLOC
-+
-+#endif
-+
-+/* allocating buffers this way eliminates dma mapping overhead, which
-+ * on some platforms will mean eliminating a per-io buffer copy.  with
-+ * some kinds of system caches, further tweaks may still be needed.
-+ */
-+static void *
-+goku_alloc_buffer(struct usb_ep *_ep, unsigned bytes,
-+			dma_addr_t *dma, int  gfp_flags)
-+{
-+	void		*retval;
-+	struct goku_ep	*ep;
-+
-+	ep = container_of(_ep, struct goku_ep, ep);
-+	if (!_ep)
-+		return 0;
-+	*dma = DMA_ADDR_INVALID;
-+
-+#if	defined(USE_KMALLOC)
-+	retval = kmalloc(bytes, gfp_flags);
-+	if (retval)
-+		*dma = virt_to_phys(retval);
-+#else
-+	if (ep->dma) {
-+		/* one problem with this call is that it wastes memory on
-+		 * typical 1/N page allocations: it allocates 1-N pages.
-+		 * another is that it always uses GFP_ATOMIC.
-+		 */
-+#warning Using pci_alloc_consistent even with buffers smaller than a page.
-+		retval = pci_alloc_consistent(ep->dev->pdev, bytes, dma);
-+	} else
-+		retval = kmalloc(bytes, gfp_flags);
-+#endif
-+	return retval;
-+}
-+
-+static void
-+goku_free_buffer(struct usb_ep *_ep, void *buf, dma_addr_t dma, unsigned bytes)
-+{
-+	/* free memory into the right allocator */
-+#ifndef	USE_KMALLOC
-+	if (dma != DMA_ADDR_INVALID) {
-+		struct goku_ep	*ep;
-+
-+		ep = container_of(_ep, struct goku_ep, ep);
-+		if (!_ep)
-+			return;
-+		/* one problem with this call is that some platforms
-+		 * don't allow it to be used in_irq().
-+		 */
-+		pci_free_consistent(ep->dev->pdev, bytes, buf, dma);
-+	} else
-+#endif
-+		kfree (buf);
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void
-+done(struct goku_ep *ep, struct goku_request *req, int status)
-+{
-+	struct goku_udc		*dev;
-+	unsigned		stopped = ep->stopped;
-+
-+	list_del_init(&req->queue);
-+
-+	if (likely(req->req.status == -EINPROGRESS))
-+		req->req.status = status;
-+	else
-+		status = req->req.status;
-+
-+	dev = ep->dev;
-+	if (req->mapped) {
-+		pci_unmap_single(dev->pdev, req->req.dma, req->req.length,
-+			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-+		req->req.dma = DMA_ADDR_INVALID;
-+		req->mapped = 0;
-+	}
-+
-+#ifndef USB_TRACE
-+	if (status && status != -ESHUTDOWN)
-+#endif
-+		VDBG(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;
-+	spin_unlock(&dev->lock);
-+	req->req.complete(&ep->ep, &req->req);
-+	spin_lock(&dev->lock);
-+	ep->stopped = stopped;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static inline int
-+write_packet(u32 *fifo, u8 *buf, struct goku_request *req, unsigned max)
-+{
-+	unsigned	length, count;
-+
-+	length = min(req->req.length - req->req.actual, max);
-+	req->req.actual += length;
-+
-+	count = length;
-+	while (likely(count--))
-+		writel(*buf++, fifo);
-+	return length;
-+}
-+
-+// return:  0 = still running, 1 = completed, negative = errno
-+static int write_fifo(struct goku_ep *ep, struct goku_request *req)
-+{
-+	struct goku_udc	*dev = ep->dev;
-+	u32		tmp;
-+	u8		*buf;
-+	unsigned	count;
-+	int		is_last;
-+
-+	tmp = readl(&dev->regs->DataSet);
-+	buf = req->req.buf + req->req.actual;
-+	prefetch(buf);
-+
-+	dev = ep->dev;
-+	if (unlikely(ep->num == 0 && dev->ep0state != EP0_IN))
-+		return -EL2HLT;
-+
-+	/* NOTE:  just single-buffered PIO-IN for now.  */
-+	if (unlikely((tmp & DATASET_A(ep->num)) != 0))
-+		return 0;
-+
-+	/* clear our "packet available" irq */
-+	if (ep->num != 0)
-+		writel(~INT_EPxDATASET(ep->num), &dev->regs->int_status);
-+
-+	count = write_packet(ep->reg_fifo, buf, req, ep->ep.maxpacket);
-+
-+	/* last packet often short (sometimes a zlp, especially on ep0) */
-+	if (unlikely(count != ep->ep.maxpacket)) {
-+		writel(~(1<<ep->num), &dev->regs->EOP);
-+		if (ep->num == 0) {
-+			dev->ep[0].stopped = 1;
-+			dev->ep0state = EP0_STATUS;
-+		}
-+		is_last = 1;
-+	} else {
-+		if (likely(req->req.length != req->req.actual)
-+				|| req->req.zero)
-+			is_last = 0;
-+		else
-+			is_last = 1;
-+	}
-+#if 0		/* printk seemed to trash is_last...*/
-+//#ifdef USB_TRACE
-+	VDBG(dev, "wrote %s %u bytes%s IN %u left %p\n",
-+		ep->ep.name, count, is_last ? "/last" : "",
-+		req->req.length - req->req.actual, req);
-+#endif
-+
-+	/* requests complete when all IN data is in the FIFO,
-+	 * or sometimes later, if a zlp was needed.
-+	 */
-+	if (is_last) {
-+		done(ep, req, 0);
-+		return 1;
-+	}
-+
-+	return 0;
-+}
-+
-+static int read_fifo(struct goku_ep *ep, struct goku_request *req)
-+{
-+	struct goku_udc_regs	*regs;
-+	u32			size, set;
-+	u8			*buf;
-+	unsigned		bufferspace, is_short, dbuff;
-+
-+	regs = ep->dev->regs;
-+top:
-+	buf = req->req.buf + req->req.actual;
-+	prefetchw(buf);
-+
-+	if (unlikely(ep->num == 0 && ep->dev->ep0state != EP0_OUT))
-+		return -EL2HLT;
-+
-+	dbuff = (ep->num == 1 || ep->num == 2);
-+	do {
-+		/* ack dataset irq matching the status we'll handle */
-+		if (ep->num != 0)
-+			writel(~INT_EPxDATASET(ep->num), &regs->int_status);
-+
-+		set = readl(&regs->DataSet) & DATASET_AB(ep->num);
-+		size = readl(&regs->EPxSizeLA[ep->num]);
-+		bufferspace = req->req.length - req->req.actual;
-+
-+		/* usually do nothing without an OUT packet */
-+		if (likely(ep->num != 0 || bufferspace != 0)) {
-+			if (unlikely(set == 0))
-+				break;
-+			/* use ep1/ep2 double-buffering for OUT */
-+			if (!(size & PACKET_ACTIVE))
-+				size = readl(&regs->EPxSizeLB[ep->num]);
-+			if (!(size & PACKET_ACTIVE)) 	// "can't happen"
-+				break;
-+			size &= DATASIZE;	/* EPxSizeH == 0 */
-+
-+		/* ep0out no-out-data case for set_config, etc */
-+		} else
-+			size = 0;
-+
-+		/* read all bytes from this packet */
-+		req->req.actual += size;
-+		is_short = (size < ep->ep.maxpacket);
-+#ifdef USB_TRACE
-+		VDBG(ep->dev, "read %s %u bytes%s OUT req %p %u/%u\n",
-+			ep->ep.name, size, is_short ? "/S" : "",
-+			req, req->req.actual, req->req.length);
-+#endif
-+		while (likely(size-- != 0)) {
-+			u8	byte = (u8) readl(ep->reg_fifo);
-+
-+			if (unlikely(bufferspace == 0)) {
-+				/* this happens when the driver's buffer
-+				 * is smaller than what the host sent.
-+				 * discard the extra data in this packet.
-+				 */
-+				if (req->req.status != -EOVERFLOW)
-+					DBG(ep->dev, "%s overflow %u\n",
-+						ep->ep.name, size);
-+				req->req.status = -EOVERFLOW;
-+			} else {
-+				*buf++ = byte;
-+				bufferspace--;
-+			}
-+		}
-+
-+		/* completion */
-+		if (unlikely(is_short || req->req.actual == req->req.length)) {
-+			if (unlikely(ep->num == 0)) {
-+				/* non-control endpoints now usable? */
-+				if (ep->dev->req_config)
-+					writel(ep->dev->configured
-+							? USBSTATE_CONFIGURED
-+							: 0,
-+						&regs->UsbState);
-+				/* ep0out status stage */
-+				writel(~(1<<0), &regs->EOP);
-+				ep->stopped = 1;
-+				ep->dev->ep0state = EP0_STATUS;
-+			}
-+			done(ep, req, 0);
-+
-+			/* empty the second buffer asap */
-+			if (dbuff && !list_empty(&ep->queue)) {
-+				req = list_entry(ep->queue.next,
-+						struct goku_request, queue);
-+				goto top;
-+			}
-+			return 1;
-+		}
-+	} while (dbuff);
-+	return 0;
-+}
-+
-+static inline void
-+pio_irq_enable(struct goku_udc *dev, struct goku_udc_regs *regs, int epnum)
-+{
-+	dev->int_enable |= INT_EPxDATASET (epnum);
-+	writel(dev->int_enable, &regs->int_enable);
-+	/* write may still be posted */
-+}
-+
-+static inline void
-+pio_irq_disable(struct goku_udc *dev, struct goku_udc_regs *regs, int epnum)
-+{
-+	dev->int_enable &= ~INT_EPxDATASET (epnum);
-+	writel(dev->int_enable, &regs->int_enable);
-+	/* write may still be posted */
-+}
-+
-+static inline void
-+pio_advance(struct goku_ep *ep)
-+{
-+	struct goku_request	*req;
-+
-+	if (unlikely(list_empty (&ep->queue)))
-+		return;
-+	req = list_entry(ep->queue.next, struct goku_request, queue);
-+	(ep->is_in ? write_fifo : read_fifo)(ep, req);
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+// return:  0 = q running, 1 = q stopped, negative = errno
-+static int start_dma(struct goku_ep *ep, struct goku_request *req)
-+{
-+	struct goku_udc_regs	*regs = ep->dev->regs;
-+	u32			master;
-+	u32			start = req->req.dma;
-+	u32			end = start + req->req.length - 1;
-+
-+	master = readl(&regs->dma_master) & MST_RW_BITS;
-+
-+	/* re-init the bits affecting IN dma; careful with zlps */
-+	if (likely(ep->is_in)) {
-+		if (unlikely(master & MST_RD_ENA)) {
-+			DBG (ep->dev, "start, IN active dma %03x!!\n",
-+				master);
-+//			return -EL2HLT;
-+		}
-+		writel(end, &regs->in_dma_end);
-+		writel(start, &regs->in_dma_start);
-+
-+		master &= ~MST_R_BITS;
-+		if (unlikely(req->req.length == 0))
-+			master = MST_RD_ENA | MST_RD_EOPB;
-+		else if ((req->req.length % ep->ep.maxpacket) != 0
-+					|| req->req.zero)
-+			master = MST_RD_ENA | MST_EOPB_ENA;
-+		else
-+			master = MST_RD_ENA | MST_EOPB_DIS;
-+
-+		ep->dev->int_enable |= INT_MSTRDEND;
-+
-+	/* Goku DMA-OUT merges short packets, which plays poorly with
-+	 * protocols where short packets mark the transfer boundaries.
-+	 * The chip supports a nonstandard policy with INT_MSTWRTMOUT,
-+	 * ending transfers after 3 SOFs; we don't turn it on.
-+	 */
-+	} else {
-+		if (unlikely(master & MST_WR_ENA)) {
-+			DBG (ep->dev, "start, OUT active dma %03x!!\n",
-+				master);
-+//			return -EL2HLT;
-+		}
-+		writel(end, &regs->out_dma_end);
-+		writel(start, &regs->out_dma_start);
-+
-+		master &= ~MST_W_BITS;
-+		master |= MST_WR_ENA | MST_TIMEOUT_DIS;
-+
-+		ep->dev->int_enable |= INT_MSTWREND|INT_MSTWRTMOUT;
-+	}
-+
-+	writel(master, &regs->dma_master);
-+	writel(ep->dev->int_enable, &regs->int_enable);
-+	return 0;
-+}
-+
-+static void dma_advance(struct goku_udc *dev, struct goku_ep *ep)
-+{
-+	struct goku_request	*req;
-+	struct goku_udc_regs	*regs = ep->dev->regs;
-+	u32			master;
-+
-+	master = readl(&regs->dma_master);
-+
-+	if (unlikely(list_empty(&ep->queue))) {
-+stop:
-+		if (ep->is_in)
-+			dev->int_enable &= ~INT_MSTRDEND;
-+		else
-+			dev->int_enable &= ~(INT_MSTWREND|INT_MSTWRTMOUT);
-+		writel(dev->int_enable, &regs->int_enable);
-+		return;
-+	}
-+	req = list_entry(ep->queue.next, struct goku_request, queue);
-+
-+	/* normal hw dma completion (not abort) */
-+	if (likely(ep->is_in)) {
-+		if (unlikely(master & MST_RD_ENA))
-+			return;
-+		req->req.actual = readl(&regs->in_dma_current);
-+	} else {
-+		if (unlikely(master & MST_WR_ENA))
-+			return;
-+
-+		/* hardware merges short packets, and also hides packet
-+		 * overruns.  a partial packet MAY be in the fifo here.
-+		 */
-+		req->req.actual = readl(&regs->out_dma_current);
-+	}
-+	req->req.actual -= req->req.dma;
-+	req->req.actual++;
-+
-+#ifdef USB_TRACE
-+	VDBG(dev, "done %s %s dma, %u/%u bytes, req %p\n",
-+		ep->ep.name, ep->is_in ? "IN" : "OUT",
-+		req->req.actual, req->req.length, req);
-+#endif
-+	done(ep, req, 0);
-+	if (list_empty(&ep->queue))
-+		goto stop;
-+	req = list_entry(ep->queue.next, struct goku_request, queue);
-+	(void) start_dma(ep, req);
-+}
-+
-+static void abort_dma(struct goku_ep *ep, int status)
-+{
-+	struct goku_udc_regs	*regs = ep->dev->regs;
-+	struct goku_request	*req;
-+	u32			curr, master;
-+
-+	/* NAK future host requests, hoping the implicit delay lets the
-+	 * dma engine finish reading (or writing) its latest packet and
-+	 * empty the dma buffer (up to 16 bytes).
-+	 *
-+	 * This avoids needing to clean up a partial packet in the fifo;
-+	 * we can't do that for IN without side effects to HALT and TOGGLE.
-+	 */
-+	command(regs, COMMAND_FIFO_DISABLE, ep->num);
-+	req = list_entry(ep->queue.next, struct goku_request, queue);
-+	master = readl(&regs->dma_master) & MST_RW_BITS;
-+
-+	/* FIXME using these resets isn't usably documented. this may
-+	 * not work unless it's followed by disabling the endpoint.
-+	 *
-+	 * FIXME the OUT reset path doesn't even behave consistently.
-+	 */
-+	if (ep->is_in) {
-+		if (unlikely((readl(&regs->dma_master) & MST_RD_ENA) == 0))
-+			goto finished;
-+		curr = readl(&regs->in_dma_current);
-+
-+		writel(curr, &regs->in_dma_end);
-+		writel(curr, &regs->in_dma_start);
-+
-+		master &= ~MST_R_BITS;
-+		master |= MST_RD_RESET;
-+		writel(master, &regs->dma_master);
-+
-+		if (readl(&regs->dma_master) & MST_RD_ENA)
-+			DBG(ep->dev, "IN dma active after reset!\n");
-+
-+	} else {
-+		if (unlikely((readl(&regs->dma_master) & MST_WR_ENA) == 0))
-+			goto finished;
-+		curr = readl(&regs->out_dma_current);
-+
-+		writel(curr, &regs->out_dma_end);
-+		writel(curr, &regs->out_dma_start);
-+
-+		master &= ~MST_W_BITS;
-+		master |= MST_WR_RESET;
-+		writel(master, &regs->dma_master);
-+
-+		if (readl(&regs->dma_master) & MST_WR_ENA)
-+			DBG(ep->dev, "OUT dma active after reset!\n");
-+	}
-+	req->req.actual = (curr - req->req.dma) + 1;
-+	req->req.status = status;
-+
-+	VDBG(ep->dev, "%s %s %s %d/%d\n", __FUNCTION__, ep->ep.name,
-+		ep->is_in ? "IN" : "OUT",
-+		req->req.actual, req->req.length);
-+
-+	command(regs, COMMAND_FIFO_ENABLE, ep->num);
-+
-+	return;
-+
-+finished:
-+	/* dma already completed; no abort needed */
-+	command(regs, COMMAND_FIFO_ENABLE, ep->num);
-+	req->req.actual = req->req.length;
-+	req->req.status = 0;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int
-+goku_queue(struct usb_ep *_ep, struct usb_request *_req, int gfp_flags)
-+{
-+	struct goku_request	*req;
-+	struct goku_ep		*ep;
-+	struct goku_udc		*dev;
-+	unsigned long		flags;
-+	int			status;
-+
-+	/* always require a cpu-view buffer so pio works */
-+	req = container_of(_req, struct goku_request, req);
-+	if (unlikely(!_req || !_req->complete
-+			|| !_req->buf || !list_empty(&req->queue)))
-+		return -EINVAL;
-+	ep = container_of(_ep, struct goku_ep, ep);
-+	if (unlikely(!_ep || (!ep->desc && ep->num != 0)))
-+		return -EINVAL;
-+	dev = ep->dev;
-+	if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN))
-+		return -ESHUTDOWN;
-+
-+	/* can't touch registers when suspended */
-+	if (dev->ep0state == EP0_SUSPEND)
-+		return -EBUSY;
-+
-+	/* set up dma mapping in case the caller didn't */
-+	if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
-+		_req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
-+			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-+		req->mapped = 1;
-+	}
-+
-+#ifdef USB_TRACE
-+	VDBG(dev, "%s queue req %p, len %u buf %p\n",
-+			_ep->name, _req, _req->length, _req->buf);
-+#endif
-+
-+	spin_lock_irqsave(&dev->lock, flags);
-+
-+	_req->status = -EINPROGRESS;
-+	_req->actual = 0;
-+
-+	/* for ep0 IN without premature status, zlp is required and
-+	 * writing EOP starts the status stage (OUT).
-+	 */
-+	if (unlikely(ep->num == 0 && ep->is_in))
-+		_req->zero = 1;
-+
-+	/* kickstart this i/o queue? */
-+	status = 0;
-+	if (list_empty(&ep->queue) && likely(!ep->stopped)) {
-+		/* dma:  done after dma completion IRQ (or error)
-+		 * pio:  done after last fifo operation
-+		 */
-+		if (ep->dma)
-+			status = start_dma(ep, req);
-+		else
-+			status = (ep->is_in ? write_fifo : read_fifo)(ep, req);
-+
-+		if (unlikely(status != 0)) {
-+			if (status > 0)
-+				status = 0;
-+			req = 0;
-+		}
-+
-+	} /* else pio or dma irq handler advances the queue. */
-+
-+	if (likely(req != 0))
-+		list_add_tail(&req->queue, &ep->queue);
-+
-+	if (likely(!list_empty(&ep->queue))
-+			&& likely(ep->num != 0)
-+			&& !ep->dma
-+			&& !(dev->int_enable & INT_EPxDATASET (ep->num)))
-+		pio_irq_enable(dev, dev->regs, ep->num);
-+
-+	spin_unlock_irqrestore(&dev->lock, flags);
-+
-+	/* pci writes may still be posted */
-+	return status;
-+}
-+
-+/* dequeue ALL requests */
-+static void nuke(struct goku_ep *ep, int status)
-+{
-+	struct goku_request	*req;
-+
-+	ep->stopped = 1;
-+	if (list_empty(&ep->queue))
-+		return;
-+	if (ep->dma)
-+		abort_dma(ep, status);
-+	while (!list_empty(&ep->queue)) {
-+		req = list_entry(ep->queue.next, struct goku_request, queue);
-+		done(ep, req, status);
-+	}
-+}
-+
-+/* dequeue JUST ONE request */
-+static int goku_dequeue(struct usb_ep *_ep, struct usb_request *_req)
-+{
-+	struct goku_request	*req;
-+	struct goku_ep		*ep;
-+	struct goku_udc		*dev;
-+	unsigned long		flags;
-+
-+	ep = container_of(_ep, struct goku_ep, ep);
-+	if (!_ep || !_req || (!ep->desc && ep->num != 0))
-+		return -EINVAL;
-+	dev = ep->dev;
-+	if (!dev->driver)
-+		return -ESHUTDOWN;
-+
-+	/* we can't touch (dma) registers when suspended */
-+	if (dev->ep0state == EP0_SUSPEND)
-+		return -EBUSY;
-+
-+	VDBG(dev, "%s %s %s %s %p\n", __FUNCTION__, _ep->name,
-+		ep->is_in ? "IN" : "OUT",
-+		ep->dma ? "dma" : "pio",
-+		_req);
-+
-+	spin_lock_irqsave(&dev->lock, 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) {
-+		spin_unlock_irqrestore (&dev->lock, flags);
-+		return -EINVAL;
-+	}
-+
-+	if (ep->dma && ep->queue.next == &req->queue && !ep->stopped) {
-+		abort_dma(ep, -ECONNRESET);
-+		done(ep, req, -ECONNRESET);
-+		dma_advance(dev, ep);
-+	} else if (!list_empty(&req->queue))
-+		done(ep, req, -ECONNRESET);
-+	else
-+		req = 0;
-+	spin_unlock_irqrestore(&dev->lock, flags);
-+
-+	return req ? 0 : -EOPNOTSUPP;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void goku_clear_halt(struct goku_ep *ep)
-+{
-+	// assert (ep->num !=0)
-+	VDBG(ep->dev, "%s clear halt\n", ep->ep.name);
-+	command(ep->dev->regs, COMMAND_SETDATA0, ep->num);
-+	command(ep->dev->regs, COMMAND_STALL_CLEAR, ep->num);
-+	if (ep->stopped) {
-+		ep->stopped = 0;
-+		if (ep->dma) {
-+			struct goku_request	*req;
-+
-+			if (list_empty(&ep->queue))
-+				return;
-+			req = list_entry(ep->queue.next, struct goku_request,
-+						queue);
-+			(void) start_dma(ep, req);
-+		} else
-+			pio_advance(ep);
-+	}
-+}
-+
-+static int goku_set_halt(struct usb_ep *_ep, int value)
-+{
-+	struct goku_ep	*ep;
-+	unsigned long	flags;
-+	int		retval = 0;
-+
-+	if (!_ep)
-+		return -ENODEV;
-+	ep = container_of (_ep, struct goku_ep, ep);
-+
-+	if (ep->num == 0) {
-+		if (value) {
-+			ep->dev->ep0state = EP0_STALL;
-+			ep->dev->ep[0].stopped = 1;
-+		} else
-+			return -EINVAL;
-+
-+	/* don't change EPxSTATUS_EP_INVALID to READY */
-+	} else if (!ep->desc) {
-+		DBG(ep->dev, "%s %s inactive?\n", __FUNCTION__, ep->ep.name);
-+		return -EINVAL;
-+	}
-+
-+	spin_lock_irqsave(&ep->dev->lock, flags);
-+	if (!list_empty(&ep->queue))
-+		retval = -EAGAIN;
-+	else if (ep->is_in && value
-+			/* data in (either) packet buffer? */
-+			&& (ep->dev->regs->DataSet & DATASET_AB(ep->num)))
-+		retval = -EAGAIN;
-+	else if (!value)
-+		goku_clear_halt(ep);
-+	else {
-+		ep->stopped = 1;
-+		VDBG(ep->dev, "%s set halt\n", ep->ep.name);
-+		command(ep->dev->regs, COMMAND_STALL, ep->num);
-+		readl(ep->reg_status);
-+	}
-+	spin_unlock_irqrestore(&ep->dev->lock, flags);
-+	return retval;
-+}
-+
-+static int goku_fifo_status(struct usb_ep *_ep)
-+{
-+	struct goku_ep		*ep;
-+	struct goku_udc_regs	*regs;
-+	u32			size;
-+
-+	if (!_ep)
-+		return -ENODEV;
-+	ep = container_of(_ep, struct goku_ep, ep);
-+
-+	/* size is only reported sanely for OUT */
-+	if (ep->is_in)
-+		return -EOPNOTSUPP;
-+
-+	/* ignores 16-byte dma buffer; SizeH == 0 */
-+	regs = ep->dev->regs;
-+	size = readl(&regs->EPxSizeLA[ep->num]) & DATASIZE;
-+	size += readl(&regs->EPxSizeLB[ep->num]) & DATASIZE;
-+	VDBG(ep->dev, "%s %s %u\n", __FUNCTION__, ep->ep.name, size);
-+	return size;
-+}
-+
-+static void goku_fifo_flush(struct usb_ep *_ep)
-+{
-+	struct goku_ep		*ep;
-+	struct goku_udc_regs	*regs;
-+	u32			size;
-+
-+	if (!_ep)
-+		return;
-+	ep = container_of(_ep, struct goku_ep, ep);
-+	VDBG(ep->dev, "%s %s\n", __FUNCTION__, ep->ep.name);
-+
-+	/* don't change EPxSTATUS_EP_INVALID to READY */
-+	if (!ep->desc && ep->num != 0) {
-+		DBG(ep->dev, "%s %s inactive?\n", __FUNCTION__, ep->ep.name);
-+		return;
-+	}
-+
-+	regs = ep->dev->regs;
-+	size = readl(&regs->EPxSizeLA[ep->num]);
-+	size &= DATASIZE;
-+
-+	/* Non-desirable behavior:  FIFO_CLEAR also clears the
-+	 * endpoint halt feature.  For OUT, we _could_ just read
-+	 * the bytes out (PIO, if !ep->dma); for in, no choice.
-+	 */
-+	if (size)
-+		command(regs, COMMAND_FIFO_CLEAR, ep->num);
-+}
-+
-+static struct usb_ep_ops goku_ep_ops = {
-+	.enable		= goku_ep_enable,
-+	.disable	= goku_ep_disable,
-+
-+	.alloc_request	= goku_alloc_request,
-+	.free_request	= goku_free_request,
-+
-+	.alloc_buffer	= goku_alloc_buffer,
-+	.free_buffer	= goku_free_buffer,
-+
-+	.queue		= goku_queue,
-+	.dequeue	= goku_dequeue,
-+
-+	.set_halt	= goku_set_halt,
-+	.fifo_status	= goku_fifo_status,
-+	.fifo_flush	= goku_fifo_flush,
-+};
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int goku_get_frame(struct usb_gadget *_gadget)
-+{
-+	return -EOPNOTSUPP;
-+}
-+
-+static const struct usb_gadget_ops goku_ops = {
-+	.get_frame	= goku_get_frame,
-+	// no remote wakeup
-+	// not selfpowered
-+};
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static inline char *dmastr(void)
-+{
-+	if (use_dma == 0)
-+		return "(dma disabled)";
-+	else if (use_dma == 2)
-+		return "(dma IN and OUT)";
-+	else
-+		return "(dma IN)";
-+}
-+
-+/* if we're trying to save space, don't bother with this proc file */
-+
-+#if defined(CONFIG_PROC_FS) && !defined(CONFIG_EMBEDDED)
-+#  define	UDC_PROC_FILE
-+#endif
-+
-+#ifdef UDC_PROC_FILE
-+
-+static const char proc_node_name [] = "driver/udc";
-+
-+#define FOURBITS "%s%s%s%s"
-+#define EIGHTBITS FOURBITS FOURBITS
-+
-+static void
-+dump_intmask(const char *label, u32 mask, char **next, unsigned *size)
-+{
-+	int t;
-+
-+	/* int_status is the same format ... */
-+	t = snprintf(*next, *size,
-+		"%s %05X =" FOURBITS EIGHTBITS EIGHTBITS "\n",
-+		label, mask,
-+		(mask & INT_PWRDETECT) ? " power" : "",
-+		(mask & INT_SYSERROR) ? " sys" : "",
-+		(mask & INT_MSTRDEND) ? " in-dma" : "",
-+		(mask & INT_MSTWRTMOUT) ? " wrtmo" : "",
-+
-+		(mask & INT_MSTWREND) ? " out-dma" : "",
-+		(mask & INT_MSTWRSET) ? " wrset" : "",
-+		(mask & INT_ERR) ? " err" : "",
-+		(mask & INT_SOF) ? " sof" : "",
-+
-+		(mask & INT_EP3NAK) ? " ep3nak" : "",
-+		(mask & INT_EP2NAK) ? " ep2nak" : "",
-+		(mask & INT_EP1NAK) ? " ep1nak" : "",
-+		(mask & INT_EP3DATASET) ? " ep3" : "",
-+
-+		(mask & INT_EP2DATASET) ? " ep2" : "",
-+		(mask & INT_EP1DATASET) ? " ep1" : "",
-+		(mask & INT_STATUSNAK) ? " ep0snak" : "",
-+		(mask & INT_STATUS) ? " ep0status" : "",
-+
-+		(mask & INT_SETUP) ? " setup" : "",
-+		(mask & INT_ENDPOINT0) ? " ep0" : "",
-+		(mask & INT_USBRESET) ? " reset" : "",
-+		(mask & INT_SUSPEND) ? " suspend" : "");
-+	*size -= t;
-+	*next += t;
-+}
-+
-+
-+static int
-+udc_proc_read(char *buffer, char **start, off_t off, int count,
-+		int *eof, void *_dev)
-+{
-+	char			*buf = buffer;
-+	struct goku_udc		*dev = _dev;
-+	struct goku_udc_regs	*regs = dev->regs;
-+	char			*next = buf;
-+	unsigned		size = count;
-+	unsigned long		flags;
-+	int			i, t, is_usb_connected;
-+	u32			tmp;
-+
-+	if (off != 0)
-+		return 0;
-+
-+	local_irq_save(flags);
-+
-+	/* basic device status */
-+	tmp = readl(&regs->power_detect);
-+	is_usb_connected = tmp & PW_DETECT;
-+	t = snprintf(next, size,
-+		"%s - %s\n"
-+		"%s version: %s %s\n"
-+		"Gadget driver: %s\n"
-+		"Host %s, %s\n"
-+		"\n",
-+		pci_name(dev->pdev), driver_desc,
-+		driver_name, DRIVER_VERSION, dmastr(),
-+		dev->driver ? dev->driver->driver.name : "(none)",
-+		is_usb_connected
-+			? ((tmp & PW_PULLUP) ? "full speed" : "powered")
-+			: "disconnected",
-+		({char *tmp;
-+		switch(dev->ep0state){
-+		case EP0_DISCONNECT:	tmp = "ep0_disconnect"; break;
-+		case EP0_IDLE:		tmp = "ep0_idle"; break;
-+		case EP0_IN:		tmp = "ep0_in"; break;
-+		case EP0_OUT:		tmp = "ep0_out"; break;
-+		case EP0_STATUS:	tmp = "ep0_status"; break;
-+		case EP0_STALL:		tmp = "ep0_stall"; break;
-+		case EP0_SUSPEND:	tmp = "ep0_suspend"; break;
-+		default:		tmp = "ep0_?"; break;
-+		} tmp; })
-+		);
-+	size -= t;
-+	next += t;
-+
-+	dump_intmask("int_status", readl(&regs->int_status), &next, &size);
-+	dump_intmask("int_enable", readl(&regs->int_enable), &next, &size);
-+
-+	if (!is_usb_connected || !dev->driver || (tmp & PW_PULLUP) == 0)
-+		goto done;
-+
-+	/* registers for (active) device and ep0 */
-+	t = snprintf(next, size, "\nirqs %lu\ndataset %02x "
-+			"single.bcs %02x.%02x state %x addr %u\n",
-+			dev->irqs, readl(&regs->DataSet),
-+			readl(&regs->EPxSingle), readl(&regs->EPxBCS),
-+			readl(&regs->UsbState),
-+			readl(&regs->address));
-+	size -= t;
-+	next += t;
-+
-+	tmp = readl(&regs->dma_master);
-+	t = snprintf(next, size,
-+		"dma %03X =" EIGHTBITS "%s %s\n", tmp,
-+		(tmp & MST_EOPB_DIS) ? " eopb-" : "",
-+		(tmp & MST_EOPB_ENA) ? " eopb+" : "",
-+		(tmp & MST_TIMEOUT_DIS) ? " tmo-" : "",
-+		(tmp & MST_TIMEOUT_ENA) ? " tmo+" : "",
-+
-+		(tmp & MST_RD_EOPB) ? " eopb" : "",
-+		(tmp & MST_RD_RESET) ? " in_reset" : "",
-+		(tmp & MST_WR_RESET) ? " out_reset" : "",
-+		(tmp & MST_RD_ENA) ? " IN" : "",
-+
-+		(tmp & MST_WR_ENA) ? " OUT" : "",
-+		(tmp & MST_CONNECTION)
-+			? "ep1in/ep2out"
-+			: "ep1out/ep2in");
-+	size -= t;
-+	next += t;
-+
-+	/* dump endpoint queues */
-+	for (i = 0; i < 4; i++) {
-+		struct goku_ep		*ep = &dev->ep [i];
-+		struct goku_request	*req;
-+		int			t;
-+
-+		if (i && !ep->desc)
-+			continue;
-+
-+		tmp = readl(ep->reg_status);
-+		t = snprintf(next, size,
-+			"%s %s max %u %s, irqs %lu, "
-+			"status %02x (%s) " FOURBITS "\n",
-+			ep->ep.name,
-+			ep->is_in ? "in" : "out",
-+			ep->ep.maxpacket,
-+			ep->dma ? "dma" : "pio",
-+			ep->irqs,
-+			tmp, ({ char *s;
-+			switch (tmp & EPxSTATUS_EP_MASK) {
-+			case EPxSTATUS_EP_READY:
-+				s = "ready"; break;
-+			case EPxSTATUS_EP_DATAIN:
-+				s = "packet"; break;
-+			case EPxSTATUS_EP_FULL:
-+				s = "full"; break;
-+			case EPxSTATUS_EP_TX_ERR:	// host will retry
-+				s = "tx_err"; break;
-+			case EPxSTATUS_EP_RX_ERR:
-+				s = "rx_err"; break;
-+			case EPxSTATUS_EP_BUSY:		/* ep0 only */
-+				s = "busy"; break;
-+			case EPxSTATUS_EP_STALL:
-+				s = "stall"; break;
-+			case EPxSTATUS_EP_INVALID:	// these "can't happen"
-+				s = "invalid"; break;
-+			default:
-+				s = "?"; break;
-+			}; s; }),
-+			(tmp & EPxSTATUS_TOGGLE) ? "data1" : "data0",
-+			(tmp & EPxSTATUS_SUSPEND) ? " suspend" : "",
-+			(tmp & EPxSTATUS_FIFO_DISABLE) ? " disable" : "",
-+			(tmp & EPxSTATUS_STAGE_ERROR) ? " ep0stat" : ""
-+			);
-+		if (t <= 0 || t > size)
-+			goto done;
-+		size -= t;
-+		next += t;
-+
-+		if (list_empty(&ep->queue)) {
-+			t = snprintf(next, size, "\t(nothing queued)\n");
-+			if (t <= 0 || t > size)
-+				goto done;
-+			size -= t;
-+			next += t;
-+			continue;
-+		}
-+		list_for_each_entry(req, &ep->queue, queue) {
-+			if (ep->dma && req->queue.prev == &ep->queue) {
-+				if (i == UDC_MSTRD_ENDPOINT)
-+					tmp = readl(&regs->in_dma_current);
-+				else
-+					tmp = readl(&regs->out_dma_current);
-+				tmp -= req->req.dma;
-+				tmp++;
-+			} else
-+				tmp = req->req.actual;
-+
-+			t = snprintf(next, size,
-+				"\treq %p len %u/%u buf %p\n",
-+				&req->req, tmp, req->req.length,
-+				req->req.buf);
-+			if (t <= 0 || t > size)
-+				goto done;
-+			size -= t;
-+			next += t;
-+		}
-+	}
-+
-+done:
-+	local_irq_restore(flags);
-+	*eof = 1;
-+	return count - size;
-+}
-+
-+#endif	/* UDC_PROC_FILE */
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void udc_reinit (struct goku_udc *dev)
-+{
-+	static char *names [] = { "ep0", "ep1-bulk", "ep2-bulk", "ep3-bulk" };
-+	
-+	unsigned i;
-+
-+	INIT_LIST_HEAD (&dev->gadget.ep_list);
-+	dev->gadget.ep0 = &dev->ep [0].ep;
-+	dev->gadget.speed = USB_SPEED_UNKNOWN;
-+	dev->ep0state = EP0_DISCONNECT;
-+	dev->irqs = 0;
-+
-+	for (i = 0; i < 4; i++) {
-+		struct goku_ep	*ep = &dev->ep[i];
-+
-+		ep->num = i;
-+		ep->ep.name = names[i];
-+		ep->reg_fifo = &dev->regs->ep_fifo [i];
-+		ep->reg_status = &dev->regs->ep_status [i];
-+		ep->reg_mode = &dev->regs->ep_mode[i];
-+
-+		ep->ep.ops = &goku_ep_ops;
-+		list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
-+		ep->dev = dev;
-+		INIT_LIST_HEAD (&ep->queue);
-+
-+		ep_reset(0, ep);
-+	}
-+
-+	dev->ep[0].reg_mode = 0;
-+	dev->ep[0].ep.maxpacket = MAX_EP0_SIZE;
-+	list_del_init (&dev->ep[0].ep.ep_list);
-+}
-+
-+static void udc_reset(struct goku_udc *dev)
-+{
-+	struct goku_udc_regs	*regs = dev->regs;
-+
-+	writel(0, &regs->power_detect);
-+	writel(0, &regs->int_enable);
-+	readl(&regs->int_enable);
-+	dev->int_enable = 0;
-+
-+	/* deassert reset, leave USB D+ at hi-Z (no pullup)
-+	 * don't let INT_PWRDETECT sequence begin
-+	 */
-+	udelay(250);
-+	writel(PW_RESETB, &regs->power_detect);
-+	readl(&regs->int_enable);
-+}
-+
-+static void ep0_start(struct goku_udc *dev)
-+{
-+	struct goku_udc_regs	*regs = dev->regs;
-+	unsigned		i;
-+
-+	VDBG(dev, "%s\n", __FUNCTION__);
-+
-+	udc_reset(dev);
-+	udc_reinit (dev);
-+	//writel(MST_EOPB_ENA | MST_TIMEOUT_ENA, &regs->dma_master);
-+
-+	/* hw handles set_address, set_feature, get_status; maybe more */
-+	writel(   G_REQMODE_SET_INTF | G_REQMODE_GET_INTF
-+		| G_REQMODE_SET_CONF | G_REQMODE_GET_CONF
-+		| G_REQMODE_GET_DESC
-+		| G_REQMODE_CLEAR_FEAT
-+		, &regs->reqmode);
-+
-+	for (i = 0; i < 4; i++)
-+		dev->ep[i].irqs = 0;
-+
-+	/* can't modify descriptors after writing UsbReady */
-+	for (i = 0; i < DESC_LEN; i++)
-+		writel(0, &regs->descriptors[i]);
-+	writel(0, &regs->UsbReady);
-+
-+	/* expect ep0 requests when the host drops reset */
-+	writel(PW_RESETB | PW_PULLUP, &regs->power_detect);
-+	dev->int_enable = INT_DEVWIDE | INT_EP0;
-+	writel(dev->int_enable, &dev->regs->int_enable);
-+	readl(&regs->int_enable);
-+	dev->gadget.speed = USB_SPEED_FULL;
-+	dev->ep0state = EP0_IDLE;
-+}
-+
-+static void udc_enable(struct goku_udc *dev)
-+{
-+	/* start enumeration now, or after power detect irq */
-+	if (readl(&dev->regs->power_detect) & PW_DETECT)
-+		ep0_start(dev);
-+	else {
-+		DBG(dev, "%s\n", __FUNCTION__);
-+		dev->int_enable = INT_PWRDETECT;
-+		writel(dev->int_enable, &dev->regs->int_enable);
-+	}
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* keeping it simple:
-+ * - one bus driver, initted first;
-+ * - one function driver, initted second
-+ */
-+
-+static struct goku_udc	*the_controller;
-+
-+/* 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 goku_udc	*dev = the_controller;
-+	int			retval;
-+
-+	if (!driver
-+			|| driver->speed != USB_SPEED_FULL
-+			|| !driver->bind
-+			|| !driver->unbind
-+			|| !driver->disconnect
-+			|| !driver->setup)
-+		return -EINVAL;
-+	if (!dev)
-+		return -ENODEV;
-+	if (dev->driver)
-+		return -EBUSY;
-+
-+	/* hook up the driver */
-+	dev->driver = driver;
-+	retval = driver->bind(&dev->gadget);
-+	if (retval) {
-+		DBG(dev, "bind to driver %s --> error %d\n",
-+				driver->driver.name, retval);
-+		dev->driver = 0;
-+		return retval;
-+	}
-+
-+	/* then enable host detection and ep0; and we're ready
-+	 * for set_configuration as well as eventual disconnect.
-+	 */
-+	udc_enable(dev);
-+
-+	DBG(dev, "registered gadget driver '%s'\n", driver->driver.name);
-+	return 0;
-+}
-+EXPORT_SYMBOL(usb_gadget_register_driver);
-+
-+static void
-+stop_activity(struct goku_udc *dev, struct usb_gadget_driver *driver)
-+{
-+	unsigned	i;
-+
-+	DBG (dev, "%s\n", __FUNCTION__);
-+
-+	if (dev->gadget.speed == USB_SPEED_UNKNOWN)
-+		driver = 0;
-+
-+	/* disconnect gadget driver after quiesceing hw and the driver */
-+	udc_reset (dev);
-+	for (i = 0; i < 4; i++)
-+		nuke(&dev->ep [i], -ESHUTDOWN);
-+	if (driver) {
-+		spin_unlock(&dev->lock);
-+		driver->disconnect(&dev->gadget);
-+		spin_lock(&dev->lock);
-+	}
-+
-+	if (dev->driver)
-+		udc_enable(dev);
-+}
-+
-+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
-+{
-+	struct goku_udc	*dev = the_controller;
-+	unsigned long	flags;
-+
-+	if (!dev)
-+		return -ENODEV;
-+	if (!driver || driver != dev->driver)
-+		return -EINVAL;
-+
-+	spin_lock_irqsave(&dev->lock, flags);
-+	dev->driver = 0;
-+	stop_activity(dev, driver);
-+	spin_unlock_irqrestore(&dev->lock, flags);
-+
-+	driver->unbind(&dev->gadget);
-+
-+	DBG(dev, "unregistered driver '%s'\n", driver->driver.name);
-+	return 0;
-+}
-+EXPORT_SYMBOL(usb_gadget_unregister_driver);
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void ep0_setup(struct goku_udc *dev)
-+{
-+	struct goku_udc_regs	*regs = dev->regs;
-+	struct usb_ctrlrequest	ctrl;
-+	int			tmp;
-+
-+	/* read SETUP packet and enter DATA stage */
-+	ctrl.bRequestType = readl(&regs->bRequestType);
-+	ctrl.bRequest = readl(&regs->bRequest);
-+	ctrl.wValue  = (readl(&regs->wValueH)  << 8) | readl(&regs->wValueL);
-+	ctrl.wIndex  = (readl(&regs->wIndexH)  << 8) | readl(&regs->wIndexL);
-+	ctrl.wLength = (readl(&regs->wLengthH) << 8) | readl(&regs->wLengthL);
-+	writel(0, &regs->SetupRecv);
-+
-+	nuke(&dev->ep[0], 0);
-+	dev->ep[0].stopped = 0;
-+	if (likely(ctrl.bRequestType & USB_DIR_IN)) {
-+		dev->ep[0].is_in = 1;
-+		dev->ep0state = EP0_IN;
-+		/* detect early status stages */
-+		writel(ICONTROL_STATUSNAK, &dev->regs->IntControl);
-+	} else {
-+		dev->ep[0].is_in = 0;
-+		dev->ep0state = EP0_OUT;
-+
-+		/* NOTE:  CLEAR_FEATURE is done in software so that we can
-+		 * synchronize transfer restarts after bulk IN stalls.  data
-+		 * won't even enter the fifo until the halt is cleared.
-+		 */
-+		switch (ctrl.bRequest) {
-+		case USB_REQ_CLEAR_FEATURE:
-+			switch (ctrl.bRequestType) {
-+			case USB_RECIP_ENDPOINT:
-+				tmp = ctrl.wIndex & 0x0f;
-+				/* active endpoint */
-+				if (tmp > 3 || (!dev->ep[tmp].desc && tmp != 0))
-+					goto stall;
-+				if (ctrl.wIndex & USB_DIR_IN) {
-+					if (!dev->ep[tmp].is_in)
-+						goto stall;
-+				} else {
-+					if (dev->ep[tmp].is_in)
-+						goto stall;
-+				}
-+				/* endpoint halt */
-+				if (ctrl.wValue != 0)
-+					goto stall;
-+				if (tmp)
-+					goku_clear_halt(&dev->ep[tmp]);
-+succeed:
-+				/* start ep0out status stage */
-+				writel(~(1<<0), &regs->EOP);
-+				dev->ep[0].stopped = 1;
-+				dev->ep0state = EP0_STATUS;
-+				return;
-+			case USB_RECIP_DEVICE:
-+				/* device remote wakeup: always clear */
-+				if (ctrl.wValue != 1)
-+					goto stall;
-+				VDBG(dev, "clear dev remote wakeup\n");
-+				goto succeed;
-+			case USB_RECIP_INTERFACE:
-+				goto stall;
-+			default:		/* pass to gadget driver */
-+				break;
-+			}
-+			break;
-+		default:
-+			break;
-+		}
-+	}
-+
-+#ifdef USB_TRACE
-+	VDBG(dev, "SETUP %02x.%02x v%04x i%04x l%04x\n",
-+		ctrl.bRequestType, ctrl.bRequest,
-+		ctrl.wValue, ctrl.wIndex, ctrl.wLength);
-+#endif
-+
-+	/* hw wants to know when we're configured (or not) */
-+	dev->req_config = (ctrl.bRequest == USB_REQ_SET_CONFIGURATION
-+				&& ctrl.bRequestType == USB_RECIP_DEVICE);
-+	if (unlikely(dev->req_config))
-+		dev->configured = (ctrl.wValue != 0);
-+
-+	/* delegate everything to the gadget driver.
-+	 * it may respond after this irq handler returns.
-+	 */
-+	spin_unlock (&dev->lock);
-+	tmp = dev->driver->setup(&dev->gadget, &ctrl);
-+	spin_lock (&dev->lock);
-+	if (unlikely(tmp < 0)) {
-+stall:
-+#ifdef USB_TRACE
-+		VDBG(dev, "req %02x.%02x protocol STALL; err %d\n",
-+				ctrl.bRequestType, ctrl.bRequest, tmp);
-+#endif
-+		command(regs, COMMAND_STALL, 0);
-+		dev->ep[0].stopped = 1;
-+		dev->ep0state = EP0_STALL;
-+	}
-+
-+	/* expect at least one data or status stage irq */
-+}
-+
-+#define ACK(irqbit) { \
-+		stat &= ~irqbit; \
-+		writel(~irqbit, &regs->int_status); \
-+		handled = 1; \
-+		}
-+
-+static irqreturn_t goku_irq(int irq, void *_dev, struct pt_regs *r)
-+{
-+	struct goku_udc		*dev = _dev;
-+	struct goku_udc_regs	*regs = dev->regs;
-+	struct goku_ep		*ep;
-+	u32			stat, handled = 0;
-+	unsigned		i, rescans = 5;
-+
-+	spin_lock(&dev->lock);
-+
-+rescan:
-+	stat = readl(&regs->int_status) & dev->int_enable;
-+        if (!stat)
-+		goto done;
-+	dev->irqs++;
-+
-+	/* device-wide irqs */
-+	if (unlikely(stat & INT_DEVWIDE)) {
-+		if (stat & INT_SYSERROR) {
-+			ERROR(dev, "system error\n");
-+			stop_activity(dev, dev->driver);
-+			stat = 0;
-+			handled = 1;
-+			// FIXME have a neater way to prevent re-enumeration
-+			dev->driver = 0;
-+			goto done;
-+		}
-+		if (stat & INT_PWRDETECT) {
-+			writel(~stat, &regs->int_status);
-+			if (readl(&dev->regs->power_detect) & PW_DETECT) {
-+				VDBG(dev, "connect\n");
-+				ep0_start(dev);
-+			} else {
-+				DBG(dev, "disconnect\n");
-+				if (dev->gadget.speed == USB_SPEED_FULL)
-+					stop_activity(dev, dev->driver);
-+				dev->ep0state = EP0_DISCONNECT;
-+				dev->int_enable = INT_DEVWIDE;
-+				writel(dev->int_enable, &dev->regs->int_enable);
-+			}
-+			stat = 0;
-+			handled = 1;
-+			goto done;
-+		}
-+		if (stat & INT_SUSPEND) {
-+			ACK(INT_SUSPEND);
-+			if (readl(&regs->ep_status[0]) & EPxSTATUS_SUSPEND) {
-+				switch (dev->ep0state) {
-+				case EP0_DISCONNECT:
-+				case EP0_SUSPEND:
-+					goto pm_next;
-+				default:
-+					break;
-+				}
-+				DBG(dev, "USB suspend\n");
-+				dev->ep0state = EP0_SUSPEND;
-+				if (dev->gadget.speed != USB_SPEED_UNKNOWN
-+						&& dev->driver
-+						&& dev->driver->suspend) {
-+					spin_unlock(&dev->lock);
-+					dev->driver->suspend(&dev->gadget);
-+					spin_lock(&dev->lock);
-+				}
-+			} else {
-+				if (dev->ep0state != EP0_SUSPEND) {
-+					DBG(dev, "bogus USB resume %d\n",
-+						dev->ep0state);
-+					goto pm_next;
-+				}
-+				DBG(dev, "USB resume\n");
-+				dev->ep0state = EP0_IDLE;
-+				if (dev->gadget.speed != USB_SPEED_UNKNOWN
-+						&& dev->driver
-+						&& dev->driver->resume) {
-+					spin_unlock(&dev->lock);
-+					dev->driver->resume(&dev->gadget);
-+					spin_lock(&dev->lock);
-+				}
-+			}
-+		}
-+pm_next:
-+		if (stat & INT_USBRESET) {		/* hub reset done */
-+			ACK(INT_USBRESET);
-+			INFO(dev, "USB reset done, gadget %s\n",
-+				dev->driver->driver.name);
-+		}
-+		// and INT_ERR on some endpoint's crc/bitstuff/... problem
-+	}
-+
-+	/* progress ep0 setup, data, or status stages.
-+	 * no transition {EP0_STATUS, EP0_STALL} --> EP0_IDLE; saves irqs
-+	 */
-+	if (stat & INT_SETUP) {
-+		ACK(INT_SETUP);
-+		dev->ep[0].irqs++;
-+		ep0_setup(dev);
-+	}
-+        if (stat & INT_STATUSNAK) {
-+		ACK(INT_STATUSNAK|INT_ENDPOINT0);
-+		if (dev->ep0state == EP0_IN) {
-+			ep = &dev->ep[0];
-+			ep->irqs++;
-+			nuke(ep, 0);
-+			writel(~(1<<0), &regs->EOP);
-+			dev->ep0state = EP0_STATUS;
-+		}
-+	}
-+        if (stat & INT_ENDPOINT0) {
-+		ACK(INT_ENDPOINT0);
-+		ep = &dev->ep[0];
-+		ep->irqs++;
-+		pio_advance(ep);
-+        }
-+
-+	/* dma completion */
-+        if (stat & INT_MSTRDEND) {	/* IN */
-+		ACK(INT_MSTRDEND);
-+		ep = &dev->ep[UDC_MSTRD_ENDPOINT];
-+		ep->irqs++;
-+		dma_advance(dev, ep);
-+        }
-+        if (stat & INT_MSTWREND) {	/* OUT */
-+		ACK(INT_MSTWREND);
-+		ep = &dev->ep[UDC_MSTWR_ENDPOINT];
-+		ep->irqs++;
-+		dma_advance(dev, ep);
-+        }
-+        if (stat & INT_MSTWRTMOUT) {	/* OUT */
-+		ACK(INT_MSTWRTMOUT);
-+		ep = &dev->ep[UDC_MSTWR_ENDPOINT];
-+		ep->irqs++;
-+		ERROR(dev, "%s write timeout ?\n", ep->ep.name);
-+		// reset dma? then dma_advance()
-+        }
-+
-+	/* pio */
-+	for (i = 1; i < 4; i++) {
-+		u32		tmp = INT_EPxDATASET(i);
-+
-+		if (!(stat & tmp))
-+			continue;
-+		ep = &dev->ep[i];
-+		pio_advance(ep);
-+		if (list_empty (&ep->queue))
-+			pio_irq_disable(dev, regs, i);
-+		stat &= ~tmp;
-+		handled = 1;
-+		ep->irqs++;
-+	}
-+
-+	if (rescans--)
-+		goto rescan;
-+
-+done:
-+	(void)readl(&regs->int_enable);
-+	spin_unlock(&dev->lock);
-+	if (stat)
-+		DBG(dev, "unhandled irq status: %05x (%05x, %05x)\n", stat,
-+				readl(&regs->int_status), dev->int_enable);
-+	return IRQ_RETVAL(handled);
-+}
-+
-+#undef ACK
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* tear down the binding between this driver and the pci device */
-+
-+static void goku_remove(struct pci_dev *pdev)
-+{
-+	struct goku_udc		*dev = pci_get_drvdata(pdev);
-+
-+	DBG(dev, "%s\n", __FUNCTION__);
-+	/* start with the driver above us */
-+	if (dev->driver) {
-+		/* should have been done already by driver model core */
-+		WARN(dev, "pci remove, driver '%s' is still registered\n",
-+				dev->driver->driver.name);
-+		usb_gadget_unregister_driver(dev->driver);
-+	}
-+
-+#ifdef	UDC_PROC_FILE
-+	remove_proc_entry(proc_node_name, NULL);
-+#endif
-+	if (dev->regs)
-+		udc_reset(dev);
-+	if (dev->got_irq)
-+		free_irq(pdev->irq, dev);
-+	if (dev->regs)
-+		iounmap(dev->regs);
-+	if (dev->got_region)
-+		release_mem_region(pci_resource_start (pdev, 0),
-+				pci_resource_len (pdev, 0));
-+	if (dev->enabled)
-+		pci_disable_device(pdev);
-+
-+	pci_set_drvdata(pdev, 0);
-+	dev->regs = 0;
-+	the_controller = 0;
-+
-+	INFO(dev, "unbind\n");
-+}
-+
-+/* wrap this driver around the specified pci device, but
-+ * don't respond over USB until a gadget driver binds to us.
-+ */
-+
-+static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
-+{
-+	struct goku_udc		*dev = 0;
-+	unsigned long		resource, len;
-+	void			*base = 0;
-+	int			retval;
-+	char			buf [8], *bufp;
-+
-+	/* if you want to support more than one controller in a system,
-+	 * usb_gadget_driver_{register,unregister}() must change.
-+	 */
-+	if (the_controller) {
-+		WARN(dev, "ignoring %s\n", pci_name(pdev));
-+		return -EBUSY;
-+	}
-+	if (!pdev->irq) {
-+		printk(KERN_ERR "Check PCI %s IRQ setup!\n", pci_name(pdev));
-+		retval = -ENODEV;
-+		goto done;
-+	}
-+
-+	/* alloc, and start init */
-+	dev = kmalloc (sizeof *dev, SLAB_KERNEL);
-+	if (dev == NULL){
-+		pr_debug("enomem %s\n", pci_name(pdev));
-+		retval = -ENOMEM;
-+		goto done;
-+	}
-+
-+	memset(dev, 0, sizeof *dev);
-+	spin_lock_init(&dev->lock);
-+	dev->pdev = pdev;
-+	dev->gadget.ops = &goku_ops;
-+
-+	/* the "gadget" abstracts/virtualizes the controller */
-+	dev->gadget.dev.bus_id = "gadget";
-+	dev->gadget.name = driver_name;
-+
-+	/* now all the pci goodies ... */
-+	retval = pci_enable_device(pdev);
-+	if (retval < 0) {
-+		DBG(dev, "can't enable, %d\n", retval);
-+		goto done;
-+	}
-+	dev->enabled = 1;
-+
-+	resource = pci_resource_start(pdev, 0);
-+	len = pci_resource_len(pdev, 0);
-+	if (!request_mem_region(resource, len, driver_name)) {
-+		DBG(dev, "controller already in use\n");
-+		retval = -EBUSY;
-+		goto done;
-+	}
-+	dev->got_region = 1;
-+
-+	base = ioremap_nocache(resource, len);
-+	if (base == NULL) {
-+		DBG(dev, "can't map memory\n");
-+		retval = -EFAULT;
-+		goto done;
-+	}
-+	dev->regs = (struct goku_udc_regs *) base;
-+
-+	pci_set_drvdata(pdev, dev);
-+	INFO(dev, "%s\n", driver_desc);
-+	INFO(dev, "version: " DRIVER_VERSION " %s\n", dmastr());
-+#ifndef __sparc__
-+	snprintf(buf, sizeof buf, "%d", pdev->irq);
-+	bufp = buf;
-+#else
-+	bufp = __irq_itoa(pdev->irq);
-+#endif
-+	INFO(dev, "irq %s, pci mem %p\n", bufp, base);
-+
-+	/* init to known state, then setup irqs */
-+	udc_reset(dev);
-+	udc_reinit (dev);
-+	if (request_irq(pdev->irq, goku_irq, SA_SHIRQ/*|SA_SAMPLE_RANDOM*/,
-+			driver_name, dev) != 0) {
-+		DBG(dev, "request interrupt %s failed\n", bufp);
-+		retval = -EBUSY;
-+		goto done;
-+	}
-+	dev->got_irq = 1;
-+	if (use_dma)
-+		pci_set_master(pdev);
-+
-+
-+#ifdef	UDC_PROC_FILE
-+	create_proc_read_entry(proc_node_name, 0, NULL, udc_proc_read, dev);
-+#endif
-+
-+	/* done */
-+	the_controller = dev;
-+
-+	return 0;
-+
-+done:
-+	if (dev)
-+		goku_remove (pdev);
-+	return retval;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static struct pci_device_id pci_ids [] = { {
-+	.class = 	((PCI_CLASS_SERIAL_USB << 8) | 0xfe),
-+	.class_mask = 	~0,
-+	.vendor =	0x102f,		/* Toshiba */
-+	.device =	0x0107,		/* this UDC */
-+	.subvendor =	PCI_ANY_ID,
-+	.subdevice =	PCI_ANY_ID,
-+
-+}, { /* end: all zeroes */ }
-+};
-+MODULE_DEVICE_TABLE (pci, pci_ids);
-+
-+static struct pci_driver goku_pci_driver = {
-+	.name =		(char *) driver_name,
-+	.id_table =	pci_ids,
-+
-+	.probe =	goku_probe,
-+	.remove =	goku_remove,
-+
-+	/* FIXME add power management support */
-+};
-+
-+static int __init init (void)
-+{
-+	return pci_module_init (&goku_pci_driver);
-+}
-+module_init (init);
-+
-+static void __exit cleanup (void)
-+{
-+	pci_unregister_driver (&goku_pci_driver);
-+}
-+module_exit (cleanup);
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/goku_udc.h kernel/drivers/usb/gadget/goku_udc.h
---- /tmp/kernel/drivers/usb/gadget/goku_udc.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/goku_udc.h	2005-04-22 17:53:19.443538050 +0200
-@@ -0,0 +1,321 @@
-+/*
-+ * Toshiba TC86C001 ("Goku-S") USB Device Controller driver
-+ *
-+ * Copyright (C) 2000-2002 Lineo
-+ *      by Stuart Lynne, Tom Rushworth, and Bruce Balden
-+ * Copyright (C) 2002 Toshiba Corporation
-+ * Copyright (C) 2003 MontaVista Software (source@mvista.com)
-+ *
-+ * This file is licensed under the terms of the GNU General Public
-+ * License version 2.  This program is licensed "as is" without any
-+ * warranty of any kind, whether express or implied.
-+ */
-+
-+/*
-+ * PCI BAR 0 points to these registers.
-+ */
-+struct goku_udc_regs {
-+	/* irq management */
-+	u32	int_status;		/* 0x000 */
-+	u32	int_enable;
-+#define INT_SUSPEND		0x00001		/* or resume */
-+#define INT_USBRESET		0x00002
-+#define INT_ENDPOINT0		0x00004
-+#define INT_SETUP		0x00008
-+#define INT_STATUS		0x00010
-+#define INT_STATUSNAK		0x00020
-+#define INT_EPxDATASET(n)	(0x00020 << (n))	/* 0 < n < 4 */
-+#	define INT_EP1DATASET		0x00040
-+#	define INT_EP2DATASET		0x00080
-+#	define INT_EP3DATASET		0x00100
-+#define INT_EPnNAK(n)		(0x00100 < (n))		/* 0 < n < 4 */
-+#	define INT_EP1NAK		0x00200
-+#	define INT_EP2NAK		0x00400
-+#	define INT_EP3NAK		0x00800
-+#define INT_SOF			0x01000
-+#define INT_ERR			0x02000
-+#define INT_MSTWRSET		0x04000
-+#define INT_MSTWREND		0x08000
-+#define INT_MSTWRTMOUT		0x10000
-+#define INT_MSTRDEND		0x20000
-+#define INT_SYSERROR		0x40000
-+#define INT_PWRDETECT		0x80000
-+
-+#define	INT_DEVWIDE		(INT_PWRDETECT|INT_SYSERROR/*|INT_ERR*/|INT_USBRESET|INT_SUSPEND)
-+#define	INT_EP0 		(INT_SETUP|INT_ENDPOINT0/*|INT_STATUS*/|INT_STATUSNAK)
-+
-+	u32	dma_master;
-+#define MST_EOPB_DIS		0x0800
-+#define MST_EOPB_ENA		0x0400
-+#define MST_TIMEOUT_DIS		0x0200
-+#define MST_TIMEOUT_ENA		0x0100
-+#define MST_RD_EOPB		0x0080		/* write-only */
-+#define MST_RD_RESET		0x0040
-+#define MST_WR_RESET		0x0020
-+#define MST_RD_ENA		0x0004		/* 1:start, 0:ignore */
-+#define MST_WR_ENA		0x0002		/* 1:start, 0:ignore */
-+#define MST_CONNECTION		0x0001		/* 0 for ep1out/ep2in */
-+
-+#define MST_R_BITS		(MST_EOPB_DIS|MST_EOPB_ENA \
-+					|MST_RD_ENA|MST_RD_RESET)
-+#define MST_W_BITS		(MST_TIMEOUT_DIS|MST_TIMEOUT_ENA \
-+					|MST_WR_ENA|MST_WR_RESET)
-+#define MST_RW_BITS		(MST_R_BITS|MST_W_BITS \
-+					|MST_CONNECTION)
-+
-+/* these values assume (dma_master & MST_CONNECTION) == 0 */
-+#define UDC_MSTWR_ENDPOINT        1
-+#define UDC_MSTRD_ENDPOINT        2
-+
-+	/* dma master write */
-+	u32	out_dma_start;
-+	u32	out_dma_end;
-+	u32	out_dma_current;
-+
-+	/* dma master read */
-+	u32	in_dma_start;
-+	u32	in_dma_end;
-+	u32	in_dma_current;
-+
-+	u32	power_detect;
-+#define PW_DETECT		0x04
-+#define PW_RESETB		0x02
-+#define PW_PULLUP		0x01
-+
-+	u8	_reserved0 [0x1d8];
-+
-+	/* endpoint registers */
-+	u32	ep_fifo [4];		/* 0x200 */
-+	u8	_reserved1 [0x10];
-+	u32	ep_mode [4];		/* only 1-3 valid */
-+	u8	_reserved2 [0x10];
-+
-+	u32	ep_status [4];
-+#define EPxSTATUS_TOGGLE	0x40
-+#define EPxSTATUS_SUSPEND	0x20
-+#define EPxSTATUS_EP_MASK	(0x07<<2)
-+#	define EPxSTATUS_EP_READY	(0<<2)
-+#	define EPxSTATUS_EP_DATAIN	(1<<2)
-+#	define EPxSTATUS_EP_FULL	(2<<2)
-+#	define EPxSTATUS_EP_TX_ERR	(3<<2)
-+#	define EPxSTATUS_EP_RX_ERR	(4<<2)
-+#	define EPxSTATUS_EP_BUSY	(5<<2)
-+#	define EPxSTATUS_EP_STALL	(6<<2)
-+#	define EPxSTATUS_EP_INVALID	(7<<2)
-+#define EPxSTATUS_FIFO_DISABLE	0x02
-+#define EPxSTATUS_STAGE_ERROR	0x01
-+
-+	u8	_reserved3 [0x10];
-+	u32	EPxSizeLA[4];
-+#define PACKET_ACTIVE		(1<<7)
-+#define DATASIZE		0x7f
-+	u8	_reserved3a [0x10];
-+	u32	EPxSizeLB[4];		/* only 1,2 valid */
-+	u8	_reserved3b [0x10];
-+	u32	EPxSizeHA[4];		/* only 1-3 valid */
-+	u8	_reserved3c [0x10];
-+	u32	EPxSizeHB[4];		/* only 1,2 valid */
-+	u8	_reserved4[0x30];
-+
-+	/* SETUP packet contents */
-+	u32	bRequestType;		/* 0x300 */
-+	u32	bRequest;
-+	u32	wValueL;
-+	u32	wValueH;
-+	u32	wIndexL;
-+	u32	wIndexH;
-+	u32	wLengthL;
-+	u32	wLengthH;
-+
-+	/* command interaction/handshaking */
-+	u32	SetupRecv;		/* 0x320 */
-+	u32	CurrConfig;
-+	u32	StdRequest;
-+	u32	Request;
-+	u32	DataSet;
-+#define DATASET_A(epnum)	(1<<(2*(epnum)))
-+#define DATASET_B(epnum)	(2<<(2*(epnum)))
-+#define DATASET_AB(epnum)	(3<<(2*(epnum)))
-+	u8	_reserved5[4];
-+
-+	u32	UsbState;
-+#define USBSTATE_CONFIGURED	0x04
-+#define USBSTATE_ADDRESSED	0x02
-+#define USBSTATE_DEFAULT	0x01
-+
-+	u32	EOP;
-+
-+	u32	Command;		/* 0x340 */
-+#define COMMAND_SETDATA0	2
-+#define COMMAND_RESET		3
-+#define COMMAND_STALL		4
-+#define COMMAND_INVALID		5
-+#define COMMAND_FIFO_DISABLE	7
-+#define COMMAND_FIFO_ENABLE	8
-+#define COMMAND_INIT_DESCRIPTOR	9
-+#define COMMAND_FIFO_CLEAR	10	/* also stall */
-+#define COMMAND_STALL_CLEAR	11
-+#define COMMAND_EP(n)		((n) << 4)
-+
-+	u32	EPxSingle;
-+	u8	_reserved6[4];
-+	u32	EPxBCS;
-+	u8	_reserved7[8];
-+	u32	IntControl;
-+#define ICONTROL_STATUSNAK	1
-+	u8	_reserved8[4];
-+
-+	u32	reqmode;	// 0x360 standard request mode, low 8 bits
-+#define G_REQMODE_SET_INTF	(1<<7)
-+#define G_REQMODE_GET_INTF	(1<<6)
-+#define G_REQMODE_SET_CONF	(1<<5)
-+#define G_REQMODE_GET_CONF	(1<<4)
-+#define G_REQMODE_GET_DESC	(1<<3)
-+#define G_REQMODE_SET_FEAT	(1<<2)
-+#define G_REQMODE_CLEAR_FEAT	(1<<1)
-+#define G_REQMODE_GET_STATUS	(1<<0)
-+
-+	u32	ReqMode;
-+	u8	_reserved9[0x18];
-+	u32	PortStatus;		/* 0x380 */
-+	u8	_reserved10[8];
-+	u32	address;
-+	u32	buff_test;
-+	u8	_reserved11[4];
-+	u32	UsbReady;
-+	u8	_reserved12[4];
-+	u32	SetDescStall;		/* 0x3a0 */
-+	u8	_reserved13[0x45c];
-+
-+	/* hardware could handle limited GET_DESCRIPTOR duties */
-+#define	DESC_LEN	0x80
-+	u32	descriptors[DESC_LEN];	/* 0x800 */
-+	u8	_reserved14[0x600];
-+
-+} __attribute__ ((packed));
-+
-+#define	MAX_FIFO_SIZE	64
-+#define	MAX_EP0_SIZE	8		/* ep0 fifo is bigger, though */
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* DRIVER DATA STRUCTURES and UTILITIES */
-+
-+struct goku_ep {
-+	struct usb_ep				ep;
-+	struct goku_udc				*dev;
-+	unsigned long				irqs;
-+
-+	unsigned				num:8,
-+						dma:1,
-+						is_in:1,
-+						stopped:1;
-+
-+	/* analogous to a host-side qh */
-+	struct list_head			queue;
-+	const struct usb_endpoint_descriptor	*desc;
-+
-+	u32					*reg_fifo;
-+	u32					*reg_mode;
-+	u32					*reg_status;
-+};
-+
-+struct goku_request {
-+	struct usb_request		req;
-+	struct list_head		queue;
-+
-+	unsigned			mapped:1;
-+};
-+
-+enum ep0state {
-+	EP0_DISCONNECT,		/* no host */
-+	EP0_IDLE,		/* between STATUS ack and SETUP report */
-+	EP0_IN, EP0_OUT, 	/* data stage */
-+	EP0_STATUS,		/* status stage */
-+	EP0_STALL,		/* data or status stages */
-+	EP0_SUSPEND,		/* usb suspend */
-+};
-+
-+struct goku_udc {
-+	/* each pci device provides one gadget, several endpoints */
-+	struct usb_gadget		gadget;
-+	spinlock_t			lock;
-+	struct goku_ep			ep[4];
-+	struct usb_gadget_driver 	*driver;
-+
-+	enum ep0state			ep0state;
-+	unsigned			got_irq:1,
-+					got_region:1,
-+					req_config:1,
-+					configured:1,
-+					enabled:1;
-+
-+	/* pci state used to access those endpoints */
-+	struct pci_dev			*pdev;
-+	struct goku_udc_regs		*regs;
-+	u32				int_enable;
-+
-+	/* statistics... */
-+	unsigned long			irqs;
-+};
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#define xprintk(dev,level,fmt,args...) \
-+	printk(level "%s %s: " fmt , driver_name , \
-+			pci_name(dev->pdev) , ## args)
-+
-+#ifdef 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
-+#define VDBG DBG
-+#else
-+#define VDBG(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)
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* 2.5 stuff that's sometimes missing in 2.4 */
-+
-+#ifndef container_of
-+#define	container_of	list_entry
-+#endif
-+
-+#ifndef likely
-+#define likely(x)	(x)
-+#define unlikely(x)	(x)
-+#endif
-+
-+#ifndef BUG_ON
-+#define BUG_ON(condition) do { if (unlikely((condition)!=0)) BUG(); } while(0)
-+#endif
-+
-+#ifndef WARN_ON
-+#define	WARN_ON(x)	do { } while (0)
-+#endif
-+
-+#ifndef	IRQ_NONE
-+typedef void irqreturn_t;
-+#define IRQ_NONE
-+#define IRQ_HANDLED
-+#define IRQ_RETVAL(x)
-+#endif
-+
-+#ifndef pci_name
-+#define pci_name(pdev)	((pdev)->slot_name)
-+#endif
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/gserial.c kernel/drivers/usb/gadget/gserial.c
---- /tmp/kernel/drivers/usb/gadget/gserial.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/gserial.c	2005-04-22 17:53:19.450536911 +0200
-@@ -0,0 +1,2301 @@
-+/*
-+ * g_serial.c -- USB gadget serial driver
-+ *
-+ * $Id: gserial.c,v 1.17 2003/10/01 06:31:57 borchers Exp $
-+ *
-+ * 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)
-+ *
-+ * 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 __KERNEL__
-+#define __KERNEL__
-+#endif
-+
-+#ifndef MODULE
-+#define MODULE
-+#endif
-+
-+
-+/* Includes */
-+
-+#include <linux/config.h>
-+#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/uts.h>
-+#include <linux/version.h>
-+#include <linux/wait.h>
-+#include <linux/list.h>
-+#include <linux/proc_fs.h>
-+#include <linux/tty_flip.h>
-+
-+#include <asm/byteorder.h>
-+#include <asm/io.h>
-+#include <asm/irq.h>
-+#include <asm/system.h>
-+#include <asm/unaligned.h>
-+#include <asm/uaccess.h>
-+
-+#include <linux/usb_ch9.h>
-+#include <linux/usb_gadget.h>
-+
-+#include "gadget_chips.h"
-+
-+
-+/* Wait Cond */
-+
-+#define __wait_cond_interruptible(wq, condition, lock, flags, ret)	\
-+do {									\
-+	wait_queue_t __wait;						\
-+	init_waitqueue_entry(&__wait, current);				\
-+									\
-+	add_wait_queue(&wq, &__wait);					\
-+	for (;;) {							\
-+		set_current_state(TASK_INTERRUPTIBLE);			\
-+		if (condition)						\
-+			break;						\
-+		if (!signal_pending(current)) {				\
-+			spin_unlock_irqrestore(lock, flags);		\
-+			schedule();					\
-+			spin_lock_irqsave(lock, flags);			\
-+			continue;					\
-+		}							\
-+		ret = -ERESTARTSYS;					\
-+		break;							\
-+	}								\
-+	current->state = TASK_RUNNING;					\
-+	remove_wait_queue(&wq, &__wait);				\
-+} while (0)
-+	
-+#define wait_cond_interruptible(wq, condition, lock, flags)		\
-+({									\
-+	int __ret = 0;							\
-+	if (!(condition))						\
-+		__wait_cond_interruptible(wq, condition, lock, flags,	\
-+						__ret);			\
-+	__ret;								\
-+})
-+
-+#define __wait_cond_interruptible_timeout(wq, condition, lock, flags, 	\
-+						timeout, ret)		\
-+do {									\
-+	signed long __timeout = timeout;				\
-+	wait_queue_t __wait;						\
-+	init_waitqueue_entry(&__wait, current);				\
-+									\
-+	add_wait_queue(&wq, &__wait);					\
-+	for (;;) {							\
-+		set_current_state(TASK_INTERRUPTIBLE);			\
-+		if (__timeout == 0)					\
-+			break;						\
-+		if (condition)						\
-+			break;						\
-+		if (!signal_pending(current)) {				\
-+			spin_unlock_irqrestore(lock, flags);		\
-+			__timeout = schedule_timeout(__timeout);	\
-+			spin_lock_irqsave(lock, flags);			\
-+			continue;					\
-+		}							\
-+		ret = -ERESTARTSYS;					\
-+		break;							\
-+	}								\
-+	current->state = TASK_RUNNING;					\
-+	remove_wait_queue(&wq, &__wait);				\
-+} while (0)
-+	
-+#define wait_cond_interruptible_timeout(wq, condition, lock, flags,	\
-+						timeout)		\
-+({									\
-+	int __ret = 0;							\
-+	if (!(condition))						\
-+		__wait_cond_interruptible_timeout(wq, condition, lock,	\
-+						flags, timeout, __ret);	\
-+	__ret;								\
-+})
-+
-+
-+/* Defines */
-+
-+#define GS_VERSION_STR			"v1.0"
-+#define GS_VERSION_NUM			0x0100
-+
-+#define GS_LONG_NAME			"Gadget Serial"
-+#define GS_SHORT_NAME			"g_serial"
-+
-+#define GS_MAJOR			127
-+#define GS_MINOR_START			0
-+
-+#define GS_NUM_PORTS			16
-+
-+#define GS_NUM_CONFIGS			1
-+#define GS_NO_CONFIG_ID			0
-+#define GS_BULK_CONFIG_ID		2
-+
-+#define GS_NUM_INTERFACES		1
-+#define GS_INTERFACE_ID			0
-+#define GS_ALT_INTERFACE_ID		0
-+
-+#define GS_NUM_ENDPOINTS		2
-+
-+#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
-+
-+/* debug macro */
-+#if G_SERIAL_DEBUG
-+
-+static int debug = G_SERIAL_DEBUG;
-+
-+#define gs_debug(format, arg...) \
-+	do { if(debug) printk( KERN_DEBUG format, ## arg ); } while(0)
-+#define gs_debug_level(level, format, arg...) \
-+	do { if(debug>=level) printk( KERN_DEBUG format, ## arg ); } while(0)
-+
-+#else
-+
-+#define gs_debug(format, arg...) \
-+	do { } while(0)
-+#define gs_debug_level(level, format, arg...) \
-+	do { } while(0)
-+
-+#endif /* G_SERIAL_DEBUG */
-+
-+
-+/* 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.
-+ */
-+#define GS_VENDOR_ID	0x0525		/* NetChip */
-+#define GS_PRODUCT_ID	0xa4a6		/* Linux-USB Serial Gadget */
-+
-+
-+/* Structures */
-+
-+struct gs_dev;
-+
-+/* circular buffer */
-+struct gs_buf {
-+	unsigned int		buf_size;
-+	char			*buf_buf;
-+	char			*buf_get;
-+	char			*buf_put;
-+};
-+
-+/* list of requests */
-+struct gs_req_entry {
-+	struct list_head	re_entry;
-+	struct usb_request	*re_req;
-+};
-+
-+/* 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;
-+};
-+
-+/* 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_in_ep;	/* address of in endpoint */
-+	struct usb_ep		*dev_out_ep;	/* address of out endpoint */
-+	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 */
-+};
-+
-+
-+/* Functions */
-+
-+/* module */
-+static int __init gs_module_init( void );
-+static void __exit gs_module_exit( void );
-+
-+/* tty driver */
-+static int gs_open( struct tty_struct *tty, struct file *file );
-+static void gs_close( struct tty_struct *tty, struct file *file );
-+static int gs_write( struct tty_struct *tty, int from_user,
-+	const unsigned char *buf, int count );
-+static void gs_put_char( struct tty_struct *tty, unsigned char ch );
-+static void gs_flush_chars( struct tty_struct *tty );
-+static int gs_write_room( struct tty_struct *tty );
-+static int gs_chars_in_buffer( struct tty_struct *tty );
-+static void gs_throttle( struct tty_struct * tty );
-+static void gs_unthrottle( struct tty_struct * tty );
-+static void gs_break( struct tty_struct *tty, int break_state );
-+static int  gs_ioctl( struct tty_struct *tty, struct file *file,
-+	unsigned int cmd, unsigned long arg );
-+static void gs_set_termios( struct tty_struct *tty, struct termios *old );
-+static int gs_read_proc( char *page, char **start, off_t off, int count,
-+	int *eof, void *data );
-+
-+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 */
-+static int gs_bind( struct usb_gadget *gadget );
-+static void gs_unbind( struct usb_gadget *gadget );
-+static int gs_setup( struct usb_gadget *gadget,
-+	const struct usb_ctrlrequest *ctrl );
-+static void gs_setup_complete( struct usb_ep *ep, struct usb_request *req );
-+static void gs_disconnect( struct usb_gadget *gadget );
-+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_desc( u8 *buf, enum usb_device_speed speed,
-+		u8 type, unsigned int index );
-+
-+static struct usb_request *gs_alloc_req( struct usb_ep *ep, unsigned int len,
-+	int kmalloc_flags );
-+static void gs_free_req( struct usb_ep *ep, struct usb_request *req );
-+
-+static struct gs_req_entry *gs_alloc_req_entry( struct usb_ep *ep, unsigned len,
-+	int kmalloc_flags );
-+static void gs_free_req_entry( struct usb_ep *ep, struct gs_req_entry *req );
-+
-+static int gs_alloc_ports( struct gs_dev *dev, int kmalloc_flags );
-+static void gs_free_ports( struct gs_dev *dev );
-+
-+/* circular buffer */
-+static struct gs_buf *gs_buf_alloc( unsigned int size, int 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 );
-+
-+/* external functions */
-+extern int net2280_set_fifo_mode(struct usb_gadget *gadget, int mode);
-+
-+
-+/* Globals */
-+
-+static struct gs_dev *gs_device;
-+
-+static const char *EP_IN_NAME;
-+static const char *EP_OUT_NAME;
-+
-+static struct semaphore	gs_open_close_sem[GS_NUM_PORTS];
-+
-+static unsigned int read_q_size = GS_DEFAULT_READ_Q_SIZE;
-+static unsigned int write_q_size = GS_DEFAULT_WRITE_Q_SIZE;
-+
-+static unsigned int write_buf_size = GS_DEFAULT_WRITE_BUF_SIZE;
-+
-+static unsigned char gs_tmp_buf[GS_TMP_BUF_SIZE];
-+static struct semaphore	gs_tmp_buf_sem;
-+
-+/* tty variables */
-+static int gs_refcount;
-+static struct tty_struct *gs_tty[GS_NUM_PORTS];
-+static struct termios *gs_termios[GS_NUM_PORTS];
-+static struct termios *gs_termios_locked[GS_NUM_PORTS];
-+
-+/* tty driver struct */
-+static struct tty_driver gs_tty_driver = {
-+	.magic =		TTY_DRIVER_MAGIC,
-+	.driver_name =		GS_SHORT_NAME,
-+	.name =			"ttygs",
-+	.major =		GS_MAJOR,
-+	.minor_start =		GS_MINOR_START,
-+	.num =			GS_NUM_PORTS,
-+	.type =			TTY_DRIVER_TYPE_SERIAL,
-+	.subtype =		SERIAL_TYPE_NORMAL,
-+	.flags =		TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS,
-+	.refcount =		&gs_refcount,
-+	.table =		gs_tty,
-+	.termios =		gs_termios,
-+	.termios_locked =	gs_termios_locked,
-+
-+	.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,
-+	.read_proc =		gs_read_proc,
-+};
-+
-+/* gadget driver struct */
-+static struct usb_gadget_driver gs_gadget_driver = {
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+	.speed =		USB_SPEED_HIGH,
-+#else
-+	.speed =		USB_SPEED_FULL,
-+#endif
-+	.function =		GS_LONG_NAME,
-+	.bind =			gs_bind,
-+	.unbind =		gs_unbind,
-+	.setup =		gs_setup,
-+	.disconnect =		gs_disconnect,
-+	.driver = {
-+		.name =		GS_SHORT_NAME,
-+		/* .shutdown = ... */
-+		/* .suspend = ...  */
-+		/* .resume = ...   */
-+	},
-+};
-+
-+
-+/* USB descriptors */
-+
-+#define GS_MANUFACTURER_STR_ID	1
-+#define GS_PRODUCT_STR_ID	2
-+#define GS_SERIAL_STR_ID	3
-+#define GS_CONFIG_STR_ID	4
-+
-+/* static strings, in iso 8859/1 */
-+static char manufacturer[40];
-+static struct usb_string gs_strings[] = {
-+	{ GS_MANUFACTURER_STR_ID, manufacturer },
-+	{ GS_PRODUCT_STR_ID, GS_LONG_NAME },
-+	{ GS_SERIAL_STR_ID, "0" },
-+	{ GS_CONFIG_STR_ID, "Bulk" },
-+	{  } /* end of list */
-+};
-+
-+static struct usb_gadget_strings gs_string_table = {
-+	.language =		0x0409,	/* en-us */
-+	.strings =		gs_strings,
-+};
-+
-+static struct usb_device_descriptor gs_device_desc = {
-+	.bLength =		USB_DT_DEVICE_SIZE,
-+	.bDescriptorType =	USB_DT_DEVICE,
-+	.bcdUSB =		__constant_cpu_to_le16(0x0200),
-+	.bDeviceClass =		USB_CLASS_VENDOR_SPEC,
-+	.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,
-+	.iSerialNumber =	GS_SERIAL_STR_ID,
-+	.bNumConfigurations =	GS_NUM_CONFIGS,
-+};
-+
-+static const struct usb_config_descriptor gs_config_desc = {
-+	.bLength =		USB_DT_CONFIG_SIZE,
-+	.bDescriptorType =	USB_DT_CONFIG,
-+	/* .wTotalLength set by gs_build_config_desc */
-+	.bNumInterfaces =	GS_NUM_INTERFACES,
-+	.bConfigurationValue =	GS_BULK_CONFIG_ID,
-+	.iConfiguration =	GS_CONFIG_STR_ID,
-+	.bmAttributes =		USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
-+	.bMaxPower =		1,
-+};
-+
-+static const struct usb_interface_descriptor gs_interface_desc = {
-+	.bLength =		USB_DT_INTERFACE_SIZE,
-+	.bDescriptorType =	USB_DT_INTERFACE,
-+	.bNumEndpoints =	GS_NUM_ENDPOINTS,
-+	.bInterfaceClass =	USB_CLASS_VENDOR_SPEC,
-+	.iInterface =		GS_CONFIG_STR_ID,
-+};
-+
-+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 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),
-+};
-+
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+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),
-+	.bDeviceClass =		USB_CLASS_VENDOR_SPEC,
-+	/* assumes ep0 uses the same value for both speeds ... */
-+	.bNumConfigurations =	GS_NUM_CONFIGS,
-+};
-+#endif
-+
-+
-+/* Module */
-+
-+MODULE_DESCRIPTION( GS_LONG_NAME );
-+MODULE_AUTHOR( "Al Borchers" );
-+MODULE_LICENSE( "GPL" );
-+
-+#if G_SERIAL_DEBUG
-+MODULE_PARM( debug, "i" );
-+MODULE_PARM_DESC( debug, "Enable debugging, 0=off, 1=on" );
-+#endif
-+
-+MODULE_PARM( read_q_size, "i" );
-+MODULE_PARM_DESC( read_q_size, "Read request queue size, default=32" );
-+
-+MODULE_PARM( write_q_size, "i" );
-+MODULE_PARM_DESC( write_q_size, "Write request queue size, default=32" );
-+
-+MODULE_PARM( write_buf_size, "i" );
-+MODULE_PARM_DESC( write_buf_size, "Write buffer size, default=8192" );
-+
-+module_init( gs_module_init );
-+module_exit( gs_module_exit );
-+
-+/*
-+*  gs_module_init
-+*
-+*  Register as a USB gadget driver and a tty driver.
-+*/
-+
-+static int __init gs_module_init( void )
-+{
-+
-+	int i,ret;
-+
-+
-+	if( (ret=usb_gadget_register_driver( &gs_gadget_driver )) ) {
-+		printk( KERN_ERR
-+		"gs_module_init: cannot register gadget driver, ret=%d\n",
-+			ret );
-+		return( ret );
-+	}
-+
-+	/* initial stty settings */
-+	gs_tty_driver.init_termios = tty_std_termios;
-+	gs_tty_driver.init_termios.c_cflag
-+		= B9600 | CS8 | CREAD | HUPCL | CLOCAL;
-+
-+	for( i=0; i<GS_NUM_PORTS; i++ )
-+		sema_init( &gs_open_close_sem[i], 1 );
-+
-+	sema_init( &gs_tmp_buf_sem, 1 );
-+
-+	if( (ret=tty_register_driver( &gs_tty_driver )) ) {
-+		usb_gadget_unregister_driver( &gs_gadget_driver );
-+		printk( KERN_ERR
-+			"gs_module_init: cannot register tty driver, ret=%d\n",
-+			ret );
-+		return( ret );
-+	} 
-+
-+	printk( KERN_INFO "gs_module_init: %s %s loaded\n", GS_LONG_NAME,
-+		GS_VERSION_STR );
-+
-+	return( 0 );        
-+
-+}
-+
-+
-+/*
-+* 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 );
-+	usb_gadget_unregister_driver( &gs_gadget_driver );
-+
-+	printk( KERN_INFO "gs_module_exit: %s %s unloaded\n",
-+		GS_LONG_NAME, GS_VERSION_STR );
-+
-+}
-+
-+
-+/* 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 semaphore *sem;
-+
-+
-+	port_num = MINOR( tty->device ) - GS_MINOR_START;
-+
-+	gs_debug( "gs_open: (%d,%p,%p)\n", port_num, tty, file );
-+
-+	tty->driver_data = NULL;
-+
-+	if( port_num < 0 || port_num >= GS_NUM_PORTS ) {
-+		printk( KERN_ERR "gs_open: (%d,%p,%p) invalid port number\n",
-+			port_num, tty, file );
-+		return( -ENODEV );
-+	}
-+
-+	dev = gs_device;
-+
-+	if( dev == NULL ) {
-+		printk( KERN_ERR "gs_open: (%d,%p,%p) NULL device pointer\n",
-+			port_num, tty, file );
-+		return( -ENODEV );
-+	}
-+
-+	sem = &gs_open_close_sem[port_num];
-+	if( down_interruptible( sem ) ) {
-+		printk( KERN_ERR
-+		"gs_open: (%d,%p,%p) interrupted waiting for semaphore\n",
-+			port_num, tty, file );
-+		return( -ERESTARTSYS );
-+	}
-+
-+	spin_lock_irqsave(&dev->dev_lock, flags );
-+
-+	if( dev->dev_config == GS_NO_CONFIG_ID ) {
-+		printk( KERN_ERR
-+			"gs_open: (%d,%p,%p) device is not connected\n",
-+			port_num, tty, file );
-+		spin_unlock_irqrestore(&dev->dev_lock, flags );
-+		up( sem );
-+		return( -ENODEV );
-+	}
-+
-+	port = dev->dev_port[port_num];
-+
-+	if( port == NULL ) {
-+		printk( KERN_ERR "gs_open: (%d,%p,%p) NULL port pointer\n",
-+			port_num, tty, file );
-+		spin_unlock_irqrestore(&dev->dev_lock, flags );
-+		up( sem );
-+		return( -ENODEV );
-+	}
-+
-+	spin_lock(&port->port_lock );
-+	spin_unlock(&dev->dev_lock );
-+
-+	if( port->port_dev == NULL ) {
-+		printk( KERN_ERR "gs_open: (%d,%p,%p) port disconnected (1)\n",
-+			port_num, tty, file );
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		up( sem );
-+		return( -EIO );
-+	}
-+
-+	if( port->port_open_count > 0 ) {
-+		++port->port_open_count;
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		gs_debug( "gs_open: (%d,%p,%p) already open\n",
-+			port_num, tty, file );
-+		up( sem );
-+		return( 0 );
-+	}
-+
-+	/* 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 ) {
-+			printk( KERN_ERR
-+				"gs_open: (%d,%p,%p) port disconnected (2)\n",
-+				port_num, tty, file );
-+			port->port_in_use = 0;
-+			spin_unlock_irqrestore(&port->port_lock, flags );
-+			up( sem );
-+			return( -EIO );
-+		}
-+
-+		if( (port->port_write_buf=buf) == NULL ) {
-+			printk( KERN_ERR "gs_open: (%d,%p,%p) cannot allocate port write buffer\n",
-+				port_num, tty, file );
-+			port->port_in_use = 0;
-+			spin_unlock_irqrestore(&port->port_lock, flags );
-+			up( sem );
-+			return( -ENOMEM );
-+		}
-+
-+	}
-+
-+	/* wait for carrier detect (not implemented) */
-+
-+	/* might have been disconnected while asleep, check */
-+	if( port->port_dev == NULL ) {
-+		printk( KERN_ERR "gs_open: (%d,%p,%p) port disconnected (3)\n",
-+			port_num, tty, file );
-+		port->port_in_use = 0;
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		up( sem );
-+		return( -EIO );
-+	}
-+
-+	tty->driver_data = port;
-+	port->port_tty = tty;
-+	port->port_open_count = 1;
-+	port->port_in_use = 0;
-+
-+	spin_unlock_irqrestore(&port->port_lock, flags );
-+	up( sem );
-+
-+	gs_debug( "gs_open: (%d,%p,%p) completed\n", port_num, tty, file );
-+
-+	return( 0 ); 
-+
-+}
-+
-+
-+/*
-+ * gs_close
-+ */
-+
-+static void gs_close( struct tty_struct *tty, struct file *file )
-+{
-+
-+	unsigned long flags;
-+	struct gs_port *port = tty->driver_data;
-+	struct semaphore *sem;
-+
-+
-+	if( port == NULL ) {
-+		printk( KERN_ERR "gs_close: NULL port pointer\n" );
-+		return;
-+	}
-+
-+	gs_debug( "gs_close: (%d,%p,%p)\n", port->port_num, tty, file );
-+
-+	sem = &gs_open_close_sem[port->port_num];
-+	down( sem );
-+
-+	spin_lock_irqsave(&port->port_lock, flags );
-+
-+	if( port->port_open_count == 0 ) {
-+		printk( KERN_ERR
-+			"gs_close: (%d,%p,%p) port is already closed\n",
-+			port->port_num, tty, file );
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		up( sem );
-+		return;
-+	}
-+
-+	if( port->port_open_count > 0 ) {
-+		--port->port_open_count;
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		up( sem );
-+		return;
-+	}
-+
-+	/* free disconnected port on final close */
-+	if( port->port_dev == NULL ) {
-+		kfree( port );
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		up( sem );
-+		return;
-+	}
-+
-+	/* 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 ) {
-+		wait_cond_interruptible_timeout( port->port_write_wait,
-+		port->port_dev == NULL
-+		|| gs_buf_data_avail(port->port_write_buf) == 0,
-+		&port->port_lock, flags, GS_CLOSE_TIMEOUT * HZ );
-+	}
-+
-+	/* free disconnected port on final close */
-+	/* (might have happened during the above sleep) */
-+	if( port->port_dev == NULL ) {
-+		kfree( port );
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		up( sem );
-+		return;
-+	}
-+
-+	gs_buf_clear( port->port_write_buf );
-+
-+	tty->driver_data = NULL;
-+	port->port_tty = NULL;
-+	port->port_in_use = 0;
-+
-+	spin_unlock_irqrestore(&port->port_lock, flags );
-+	up( sem );
-+
-+	gs_debug( "gs_close: (%d,%p,%p) completed\n",
-+		port->port_num, tty, file );
-+
-+}
-+
-+
-+/*
-+ * gs_write
-+ */
-+
-+static int gs_write( struct tty_struct *tty, int from_user,
-+	const unsigned char *buf, int count )
-+{
-+
-+	unsigned long flags;
-+	struct gs_port *port = tty->driver_data;
-+
-+
-+	if( port == NULL ) {
-+		printk( KERN_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 );
-+
-+	/* copy from user into tmp buffer, get tmp_buf semaphore */
-+	if( from_user ) {
-+		if( count > GS_TMP_BUF_SIZE )
-+			count = GS_TMP_BUF_SIZE;
-+		down( &gs_tmp_buf_sem );
-+		if( copy_from_user( gs_tmp_buf, buf, count ) != 0 ) {
-+			up( &gs_tmp_buf_sem );
-+			printk( KERN_ERR
-+			"gs_write: (%d,%p) cannot copy from user space\n",
-+				port->port_num, tty );
-+			return( -EFAULT );
-+		}
-+		buf = gs_tmp_buf;
-+	}
-+
-+	spin_lock_irqsave(&port->port_lock, flags );
-+
-+	if( port->port_dev == NULL ) {
-+		printk( KERN_ERR "gs_write: (%d,%p) port is not connected\n",
-+			port->port_num, tty );
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		if( from_user )
-+			up( &gs_tmp_buf_sem );
-+		return( -EIO );
-+	}
-+
-+	if( port->port_open_count == 0 ) {
-+		printk( KERN_ERR "gs_write: (%d,%p) port is closed\n",
-+			port->port_num, tty );
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		if( from_user )
-+			up( &gs_tmp_buf_sem );
-+		return( -EBADF );
-+	}
-+
-+	count = gs_buf_put( port->port_write_buf, buf, count );
-+
-+	spin_unlock_irqrestore(&port->port_lock, flags );
-+
-+	if( from_user )
-+		up( &gs_tmp_buf_sem );
-+
-+	gs_send( gs_device );
-+
-+	gs_debug( "gs_write: (%d,%p) wrote %d bytes\n", port->port_num, tty,
-+		count );
-+
-+	return( count );
-+
-+}
-+
-+
-+/*
-+ * gs_put_char
-+ */
-+
-+static void gs_put_char( struct tty_struct *tty, unsigned char ch )
-+{
-+
-+	unsigned long flags;
-+	struct gs_port *port = tty->driver_data;
-+
-+
-+	if( port == NULL ) {
-+		printk( KERN_ERR "gs_put_char: NULL port pointer\n" );
-+		return;
-+	}
-+
-+	gs_debug( "gs_put_char: (%d,%p) char=0x%x, called from %p, %p, %p\n", port->port_num, tty, ch, __builtin_return_address(0), __builtin_return_address(1), __builtin_return_address(2) );
-+
-+	spin_lock_irqsave(&port->port_lock, flags );
-+
-+	if( port->port_dev == NULL ) {
-+		printk( KERN_ERR "gs_put_char: (%d,%p) port is not connected\n",
-+			port->port_num, tty );
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		return;
-+	}
-+
-+	if( port->port_open_count == 0 ) {
-+		printk( KERN_ERR "gs_put_char: (%d,%p) port is closed\n",
-+			port->port_num, tty );
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		return;
-+	}
-+
-+	gs_buf_put( port->port_write_buf, &ch, 1 );
-+
-+	spin_unlock_irqrestore(&port->port_lock, flags );
-+
-+}
-+
-+
-+/*
-+ * 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 ) {
-+		printk( KERN_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 ) {
-+		printk( KERN_ERR
-+			"gs_flush_chars: (%d,%p) port is not connected\n",
-+			port->port_num, tty );
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		return;
-+	}
-+
-+	if( port->port_open_count == 0 ) {
-+		printk( KERN_ERR "gs_flush_chars: (%d,%p) port is closed\n",
-+			port->port_num, tty );
-+		spin_unlock_irqrestore(&port->port_lock, flags );
-+		return;
-+	}
-+
-+	spin_unlock_irqrestore(&port->port_lock, flags );
-+
-+	gs_send( gs_device );
-+
-+}
-+
-+
-+/*
-+ * 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 ) {
-+		printk( KERN_ERR "gs_ioctl: NULL port pointer\n" );
-+		return( -EIO );
-+	}
-+
-+	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 termios *old )
-+{
-+
-+}
-+
-+
-+/*
-+ * gs_read_proc
-+ */
-+
-+static int gs_read_proc( char *page, char **start, off_t off, int count,
-+	int *eof, void *data )
-+{
-+
-+	return( 0 );
-+
-+}
-+
-+
-+/*
-+* 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;
-+	struct gs_req_entry *req_entry;
-+
-+
-+	if( dev == NULL ) {
-+		printk( KERN_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_entry = list_entry( dev->dev_req_list.next,
-+			struct gs_req_entry, re_entry );
-+
-+		req = req_entry->re_req;
-+
-+		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_entry->re_entry );
-+			req->length = len;
-+			if( (ret=usb_ep_queue( ep, req, GFP_ATOMIC )) ) {
-+				printk( KERN_ERR
-+				"gs_send: cannot queue read request, ret=%d\n",
-+					ret );
-+				break;
-+			}
-+		} 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 ) {
-+		printk( KERN_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 ) {
-+		spin_unlock(&port->port_lock );
-+		return( 0 );
-+	}
-+
-+	size = gs_buf_get( port->port_write_buf, packet, size );
-+
-+	wake_up_interruptible( &port->port_tty->write_wait );
-+
-+	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;
-+
-+
-+	/* TEMPORARY -- only port 0 is supported right now */
-+	port = dev->dev_port[0];
-+
-+	if( port == NULL ) {
-+		printk( KERN_ERR "gs_recv_packet: port=%d, NULL port pointer\n",
-+			port->port_num );
-+		return( -EIO );
-+	}
-+
-+	spin_lock(&port->port_lock );
-+
-+	if( port->port_tty == NULL ) {
-+		printk( KERN_ERR "gs_recv_packet: port=%d, NULL tty pointer\n",
-+			port->port_num );
-+		spin_unlock(&port->port_lock );
-+		return( -EIO );
-+	}
-+
-+	if( port->port_tty->magic != TTY_MAGIC ) {
-+		printk( KERN_ERR "gs_recv_packet: port=%d, bad tty magic\n",
-+			port->port_num );
-+		spin_unlock(&port->port_lock );
-+		return( -EIO );
-+	}
-+
-+	len = (unsigned int)(TTY_FLIPBUF_SIZE - port->port_tty->flip.count);
-+	if( len < size )
-+		size = len;
-+
-+	if( size > 0 ) {
-+		memcpy( port->port_tty->flip.char_buf_ptr, packet, size );
-+		port->port_tty->flip.char_buf_ptr += size;
-+		port->port_tty->flip.count += size;
-+		tty_flip_buffer_push( port->port_tty );
-+		wake_up_interruptible( &port->port_tty->read_wait );
-+	}
-+
-+	spin_unlock(&port->port_lock );
-+
-+	return( 0 );
-+
-+}
-+
-+
-+/*
-+* gs_read_complete
-+*/
-+
-+static void gs_read_complete( struct usb_ep *ep, struct usb_request *req )
-+{
-+
-+	int ret;
-+	struct gs_dev *dev = ep->driver_data;
-+
-+
-+	if( dev == NULL ) {
-+		printk( KERN_ERR "gs_read_complete: NULL device pointer\n" );
-+		return;
-+	}
-+
-+	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 )) ) {
-+			printk( KERN_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 */
-+		printk( KERN_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;
-+	struct gs_req_entry *gs_req = req->context;
-+
-+
-+	if( dev == NULL ) {
-+		printk( KERN_ERR "gs_write_complete: NULL device pointer\n" );
-+		return;
-+	}
-+
-+	switch( req->status ) {
-+
-+	case 0:
-+		/* normal completion */
-+requeue:
-+		if( gs_req == NULL ) {
-+			printk( KERN_ERR
-+				"gs_write_complete: NULL request pointer\n" );
-+			return;
-+		}
-+
-+		spin_lock(&dev->dev_lock );
-+		list_add( &gs_req->re_entry, &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:
-+		printk( KERN_ERR
-+		"gs_write_complete: unexpected status error, status=%d\n",
-+			req->status );
-+		goto requeue;
-+		break;
-+
-+	}
-+
-+}
-+
-+
-+/* Gadget Driver */
-+
-+/*
-+ * gs_bind
-+ *
-+ * Called on module load.  Allocates and initializes the device
-+ * structure and a control request.
-+ */
-+static int gs_bind(struct usb_gadget *gadget)
-+{
-+	int ret;
-+	struct usb_ep *ep;
-+	struct gs_dev *dev;
-+
-+	usb_ep_autoconfig_reset(gadget);
-+
-+	ep = usb_ep_autoconfig(gadget, &gs_fullspeed_in_desc);
-+	if (!ep)
-+		goto autoconf_fail;
-+	EP_IN_NAME = ep->name;
-+	ep->driver_data = ep;	/* claim the endpoint */
-+
-+	ep = usb_ep_autoconfig(gadget, &gs_fullspeed_out_desc);
-+	if (!ep)
-+		goto autoconf_fail;
-+	EP_OUT_NAME = ep->name;
-+	ep->driver_data = ep;	/* claim the endpoint */
-+
-+	/* device specific bcdDevice value in device descriptor */
-+	if (gadget_is_net2280(gadget)) {
-+		gs_device_desc.bcdDevice =
-+			__constant_cpu_to_le16(GS_VERSION_NUM|0x0001);
-+	} else if (gadget_is_pxa(gadget)) {
-+		gs_device_desc.bcdDevice =
-+			__constant_cpu_to_le16(GS_VERSION_NUM|0x0002);
-+	} else if (gadget_is_sh(gadget)) {
-+		gs_device_desc.bcdDevice =
-+			__constant_cpu_to_le16(GS_VERSION_NUM|0x0003);
-+	} else if (gadget_is_sa1100(gadget)) {
-+		gs_device_desc.bcdDevice =
-+			__constant_cpu_to_le16(GS_VERSION_NUM|0x0004);
-+	} else if (gadget_is_goku(gadget)) {
-+		gs_device_desc.bcdDevice =
-+			__constant_cpu_to_le16(GS_VERSION_NUM|0x0005);
-+	} else if (gadget_is_mq11xx(gadget)) {
-+		gs_device_desc.bcdDevice =
-+			__constant_cpu_to_le16(GS_VERSION_NUM|0x0006);
-+	} else if (gadget_is_omap(gadget)) {
-+		gs_device_desc.bcdDevice =
-+			__constant_cpu_to_le16(GS_VERSION_NUM|0x0007);
-+	} else {
-+		printk(KERN_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);
-+	}
-+
-+	gs_device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+	/* 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_in_desc.bEndpointAddress =
-+		gs_fullspeed_in_desc.bEndpointAddress;
-+	gs_highspeed_out_desc.bEndpointAddress =
-+		gs_fullspeed_out_desc.bEndpointAddress;
-+#endif /* CONFIG_USB_GADGET_DUALSPEED */
-+
-+	usb_gadget_set_selfpowered(gadget);
-+
-+	gs_device = dev = kmalloc(sizeof(struct gs_dev), GFP_KERNEL);
-+	if (dev == NULL)
-+		return -ENOMEM;
-+
-+	snprintf (manufacturer, sizeof(manufacturer),
-+		UTS_SYSNAME " " UTS_RELEASE " with %s", gadget->name);
-+
-+	memset(dev, 0, sizeof(struct gs_dev));
-+	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) {
-+		printk(KERN_ERR "gs_bind: cannot allocate ports\n");
-+		gs_unbind(gadget);
-+		return ret;
-+	}
-+
-+	/* 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;
-+	}
-+	dev->dev_ctrl_req->complete = gs_setup_complete;
-+
-+	gadget->ep0->driver_data = dev;
-+
-+	printk(KERN_INFO "gs_bind: %s %s bound\n",
-+		GS_LONG_NAME, GS_VERSION_STR);
-+
-+	return 0;
-+
-+autoconf_fail:
-+	printk(KERN_ERR "gs_bind: cannot autoconfigure on %s\n", gadget->name);
-+	return -ENODEV;
-+}
-+
-+
-+/*
-+ * gs_unbind
-+ *
-+ * Called on module unload.  Frees the control request and device
-+ * structure.
-+ */
-+
-+static void gs_unbind( struct usb_gadget *gadget )
-+{
-+
-+	struct gs_dev *dev = get_gadget_data( gadget );
-+
-+
-+	gs_device = NULL;
-+
-+	/* 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 );
-+		gs_free_ports( dev );
-+		kfree( dev );
-+		set_gadget_data( gadget, NULL );
-+	}
-+
-+	printk( KERN_INFO "gs_unbind: %s %s unbound\n", GS_LONG_NAME,
-+		GS_VERSION_STR );
-+
-+}
-+
-+
-+/*
-+ * 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;
-+	unsigned int sv_config;
-+	struct gs_dev *dev = get_gadget_data( gadget );
-+	struct usb_request *req = dev->dev_ctrl_req;
-+
-+
-+	switch (ctrl->bRequest) {
-+
-+	case USB_REQ_GET_DESCRIPTOR:
-+
-+		if( ctrl->bRequestType != USB_DIR_IN )
-+			break;
-+
-+		switch (ctrl->wValue >> 8) {
-+
-+		case USB_DT_DEVICE:
-+			ret = min( ctrl->wLength,
-+				(u16)sizeof(struct usb_device_descriptor) );
-+			memcpy( req->buf, &gs_device_desc, ret );
-+			break;
-+
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+		case USB_DT_DEVICE_QUALIFIER:
-+			if (!gadget->is_dualspeed)
-+				break;
-+			ret = min( ctrl->wLength,
-+				(u16)sizeof(struct usb_qualifier_descriptor) );
-+			memcpy( req->buf, &gs_qualifier_desc, ret );
-+			break;
-+
-+		case USB_DT_OTHER_SPEED_CONFIG:
-+#endif /* CONFIG_USB_GADGET_DUALSPEED */
-+		case USB_DT_CONFIG:
-+			ret = gs_build_config_desc( req->buf, gadget->speed,
-+				ctrl->wValue >> 8, ctrl->wValue & 0xff );
-+			if( ret >= 0 )
-+				ret = min( ctrl->wLength, (u16)ret );
-+			break;
-+
-+		case USB_DT_STRING:
-+			/* wIndex == language code. */
-+			ret = usb_gadget_get_string( &gs_string_table,
-+				ctrl->wValue & 0xff, req->buf );
-+			if( ret >= 0 )
-+				ret = min( ctrl->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, ctrl->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( ctrl->wLength, (u16)1 );
-+		break;
-+
-+	case USB_REQ_SET_INTERFACE:
-+		if( ctrl->bRequestType != USB_RECIP_INTERFACE )
-+			break;
-+		spin_lock( &dev->dev_lock );
-+		if( dev->dev_config == GS_BULK_CONFIG_ID
-+		&& ctrl->wIndex == GS_INTERFACE_ID
-+		&& ctrl->wValue == GS_ALT_INTERFACE_ID ) {
-+			sv_config = dev->dev_config;
-+			/* since there is only one interface, setting the */
-+			/* interface is equivalent to setting the config */
-+			gs_reset_config( dev );
-+			gs_set_config( dev, sv_config );
-+			ret = 0;
-+		}
-+		spin_unlock( &dev->dev_lock );
-+		break;
-+
-+	case USB_REQ_GET_INTERFACE:
-+		if( ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE) )
-+			break;
-+		if( dev->dev_config == GS_NO_CONFIG_ID )
-+			break;
-+		if( ctrl->wIndex != GS_INTERFACE_ID ) {
-+			ret = -EDOM;
-+			break;
-+		}
-+		*(u8 *)req->buf = GS_ALT_INTERFACE_ID;
-+		ret = min( ctrl->wLength, (u16)1 );
-+		break;
-+
-+	default:
-+		printk( KERN_ERR "gs_setup: unknown request, type=%02x, request=%02x, value=%04x, index=%04x, length=%d\n",
-+			ctrl->bRequestType, ctrl->bRequest, ctrl->wValue,
-+			ctrl->wIndex, ctrl->wLength );
-+		break;
-+
-+	}
-+
-+	/* respond with data transfer before status phase? */
-+	if( ret >= 0 ) {
-+		req->length = ret;
-+		ret = usb_ep_queue( gadget->ep0, req, GFP_ATOMIC );
-+		if( ret < 0 ) {
-+			printk( KERN_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_setup_complete
-+ */
-+
-+static void gs_setup_complete( struct usb_ep *ep, struct usb_request *req )
-+{
-+	if( req->status || req->actual != req->length ) {
-+		printk( KERN_ERR "gs_setup_complete: status error, status=%d, actual=%d, length=%d\n",
-+			req->status, req->actual, req->length );
-+	}
-+}
-+
-+
-+/*
-+ * 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 )
-+		printk( KERN_ERR "gs_disconnect: cannot re-allocate ports\n" );
-+
-+	spin_unlock_irqrestore( &dev->dev_lock, flags );
-+
-+	printk( KERN_INFO "gs_disconnect: %s disconnected\n", GS_LONG_NAME );
-+
-+}
-+
-+
-+/*
-+ * 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 )
-+{
-+
-+	int i;
-+	int ret = 0;
-+	struct usb_gadget *gadget = dev->dev_gadget;
-+	struct usb_ep *ep;
-+	struct usb_request *req;
-+	struct gs_req_entry *req_entry;
-+
-+
-+	if( dev == NULL ) {
-+		printk( KERN_ERR "gs_set_config: NULL device pointer\n" );
-+		return( 0 );
-+	}
-+
-+	if( config == dev->dev_config )
-+		return( 0 );
-+
-+	gs_reset_config( dev );
-+
-+	if( config == GS_NO_CONFIG_ID )
-+		return( 0 );
-+
-+	if( config != GS_BULK_CONFIG_ID )
-+		return( -EINVAL );
-+
-+	/* device specific optimizations */
-+	if (gadget_is_net2280(gadget))
-+		net2280_set_fifo_mode(gadget, 1);
-+
-+	gadget_for_each_ep( ep, gadget ) {
-+
-+		if( strcmp( ep->name, EP_IN_NAME ) == 0 ) {
-+			ret = usb_ep_enable( ep,
-+				gadget->speed == USB_SPEED_HIGH ?
-+ 				&gs_highspeed_in_desc : &gs_fullspeed_in_desc );
-+			if( ret == 0 ) {
-+				ep->driver_data = dev;
-+				dev->dev_in_ep = ep;
-+			} else {
-+				printk( KERN_ERR "gs_set_config: cannot enable in endpoint %s, ret=%d\n",
-+					ep->name, ret );
-+				gs_reset_config( dev );
-+				return( ret );
-+			}
-+		}
-+
-+		else if( strcmp( ep->name, EP_OUT_NAME ) == 0 ) {
-+			ret = usb_ep_enable( ep,
-+				gadget->speed == USB_SPEED_HIGH ?
-+				&gs_highspeed_out_desc :
-+				&gs_fullspeed_out_desc );
-+			if( ret == 0 ) {
-+				ep->driver_data = dev;
-+				dev->dev_out_ep = ep;
-+			} else {
-+				printk( KERN_ERR "gs_set_config: cannot enable out endpoint %s, ret=%d\n",
-+					ep->name, ret );
-+				gs_reset_config( dev );
-+				return( ret );
-+			}
-+		}
-+
-+	}
-+
-+	if( dev->dev_in_ep == NULL || dev->dev_out_ep == NULL ) {
-+		gs_reset_config( dev );
-+		printk( KERN_ERR "gs_set_config: cannot find endpoints\n" );
-+		return( -ENODEV );
-+	}
-+
-+	/* 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 )) ) {
-+				printk( KERN_ERR "gs_set_config: cannot queue read request, ret=%d\n",
-+					ret );
-+			}
-+		} else {
-+			gs_reset_config( dev );
-+			printk( KERN_ERR
-+			"gs_set_config: cannot allocate read requests\n" );
-+			return( -ENOMEM );
-+		}
-+	}
-+
-+	/* allocate write requests, and put on free list */
-+	ep = dev->dev_in_ep;
-+	for( i=0; i<write_q_size; i++ ) {
-+		if( (req_entry=gs_alloc_req_entry( ep, ep->maxpacket,
-+		GFP_ATOMIC )) ) {
-+			req_entry->re_req->complete = gs_write_complete;
-+			list_add( &req_entry->re_entry, &dev->dev_req_list );
-+		} else {
-+			gs_reset_config( dev );
-+			printk( KERN_ERR
-+			"gs_set_config: cannot allocate write requests\n" );
-+			return( -ENOMEM );
-+		}
-+	}
-+
-+	dev->dev_config = config;
-+
-+	printk( KERN_INFO "gs_set_config: %s configured for %s speed\n",
-+		GS_LONG_NAME,
-+		gadget->speed == USB_SPEED_HIGH ? "high" : "full" );
-+
-+	return( 0 );
-+
-+}
-+
-+
-+/*
-+ * 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 gs_req_entry *req_entry;
-+
-+
-+	if( dev == NULL ) {
-+		printk( KERN_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_entry = list_entry( dev->dev_req_list.next,
-+			struct gs_req_entry, re_entry );
-+		list_del( &req_entry->re_entry );
-+		gs_free_req_entry( dev->dev_in_ep, req_entry );
-+	}
-+
-+	/* disable endpoints, forcing completion of pending i/o; */
-+	/* completion handlers free their requests in this case */
-+	if( dev->dev_in_ep ) {
-+		usb_ep_disable( dev->dev_in_ep );
-+		dev->dev_in_ep = NULL;
-+	}
-+	if( dev->dev_out_ep ) {
-+		usb_ep_disable( dev->dev_out_ep );
-+		dev->dev_out_ep = NULL;
-+	}
-+
-+}
-+
-+
-+/*
-+ * gs_build_config_desc
-+ *
-+ * Builds a config descriptor in the given buffer and returns the
-+ * length, or a negative error number.
-+ */
-+
-+static int gs_build_config_desc( u8 *buf, enum usb_device_speed speed,
-+		u8 type, unsigned int index )
-+{
-+
-+	int high_speed;
-+	int len = USB_DT_CONFIG_SIZE + USB_DT_INTERFACE_SIZE
-+				+ GS_NUM_ENDPOINTS * USB_DT_ENDPOINT_SIZE;
-+
-+
-+	/* only one config */
-+	if( index != 0 )
-+		return( -EINVAL );
-+
-+	memcpy( buf, &gs_config_desc, USB_DT_CONFIG_SIZE );
-+	((struct usb_config_descriptor *)buf)->bDescriptorType = type;
-+	((struct usb_config_descriptor *)buf)->wTotalLength =
-+		__constant_cpu_to_le16( len );
-+	buf += USB_DT_CONFIG_SIZE;
-+
-+	memcpy( buf, &gs_interface_desc, USB_DT_INTERFACE_SIZE );
-+	buf += USB_DT_INTERFACE_SIZE;
-+
-+	/* other speed switches high and full speed */
-+	high_speed = (speed == USB_SPEED_HIGH);
-+	if( type == USB_DT_OTHER_SPEED_CONFIG )
-+		high_speed = !high_speed;
-+
-+	memcpy( buf,
-+		high_speed ? &gs_highspeed_in_desc : &gs_fullspeed_in_desc,
-+		USB_DT_ENDPOINT_SIZE );
-+	buf += USB_DT_ENDPOINT_SIZE;
-+	memcpy( buf,
-+		high_speed ? &gs_highspeed_out_desc : &gs_fullspeed_out_desc,
-+		USB_DT_ENDPOINT_SIZE );
-+
-+	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,
-+	int 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 = usb_ep_alloc_buffer( ep, len, &req->dma,
-+			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.
-+ */
-+
-+static void gs_free_req( struct usb_ep *ep, struct usb_request *req )
-+{
-+	if( ep != NULL && req != NULL ) {
-+		if( req->buf != NULL )
-+			usb_ep_free_buffer( ep, req->buf, req->dma,
-+				req->length );
-+		usb_ep_free_request( ep, req );
-+	}
-+}
-+
-+
-+/*
-+ * gs_alloc_req_entry
-+ *
-+ * Allocates a request and its buffer, using the given
-+ * endpoint, buffer len, and kmalloc flags.
-+ */
-+
-+static struct gs_req_entry *gs_alloc_req_entry( struct usb_ep *ep,
-+	unsigned len, int kmalloc_flags )
-+{
-+
-+	struct gs_req_entry	*req;
-+
-+
-+	req = kmalloc( sizeof(struct gs_req_entry), kmalloc_flags );
-+	if( req == NULL )
-+		return( NULL );
-+
-+	req->re_req = gs_alloc_req( ep, len, kmalloc_flags );
-+	if( req->re_req == NULL ) {
-+		kfree( req );
-+		return( NULL );
-+	}
-+
-+	req->re_req->context = req;
-+
-+	return( req );
-+
-+}
-+
-+
-+/*
-+ * gs_free_req_entry
-+ *
-+ * Frees a request and its buffer.
-+ */
-+
-+static void gs_free_req_entry( struct usb_ep *ep, struct gs_req_entry *req )
-+{
-+	if( ep != NULL && req != NULL ) {
-+		if( req->re_req != NULL )
-+			gs_free_req( ep, req->re_req );
-+		kfree( 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, int kmalloc_flags )
-+{
-+
-+	int i;
-+	struct gs_port *port;
-+
-+
-+	if( dev == NULL )
-+		return( -EIO );
-+
-+	for( i=0; i<GS_NUM_PORTS; i++ ) {
-+
-+		if( (port=(struct gs_port *)kmalloc( sizeof(struct gs_port),
-+		kmalloc_flags )) == NULL )
-+			return( -ENOMEM );
-+
-+		memset( port, 0, sizeof( struct gs_port ) );
-+		port->port_dev = dev;
-+		port->port_num = i;
-+		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 );
-+				wake_up_interruptible( &port->port_tty->read_wait );
-+				wake_up_interruptible( &port->port_tty->write_wait );
-+			} else {
-+				kfree( port );
-+			}
-+
-+			spin_unlock_irqrestore(&port->port_lock, flags );
-+
-+		}
-+
-+	}
-+
-+}
-+
-+
-+/* Circular Buffer */
-+
-+/*
-+ * gs_buf_alloc
-+ *
-+ * Allocate a circular buffer and all associated memory.
-+ */
-+
-+static struct gs_buf *gs_buf_alloc( unsigned int size, int kmalloc_flags )
-+{
-+
-+	struct gs_buf *gb;
-+
-+
-+	if( size == 0 )
-+		return( NULL );
-+
-+	gb = (struct gs_buf *)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.
-+ */
-+
-+void gs_buf_free( struct gs_buf *gb )
-+{
-+	if( gb != NULL ) {
-+		if( gb->buf_buf != NULL )
-+			kfree( gb->buf_buf );
-+		kfree( gb );
-+	}
-+}
-+
-+
-+/*
-+ * gs_buf_clear
-+ *
-+ * Clear out all data in the circular buffer.
-+ */
-+
-+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.
-+ */
-+
-+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.
-+ */
-+
-+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.
-+ */
-+
-+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.
-+ */
-+
-+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 );
-+
-+}
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/inode.c kernel/drivers/usb/gadget/inode.c
---- /tmp/kernel/drivers/usb/gadget/inode.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/inode.c	2005-04-22 17:53:19.456535934 +0200
-@@ -0,0 +1,1807 @@
-+/*
-+ * inode.c -- user mode filesystem api for usb gadget controllers
-+ *
-+ * Copyright (C) 2003 David Brownell
-+ * Copyright (C) 2003 Agilent Technologies
-+ *
-+ * 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	DEBUG 1			/* data to help fault diagnosis */
-+// #define	VERBOSE		/* extra debug messages (success too) */
-+
-+#include <linux/init.h>
-+#include <linux/kernel.h>
-+#include <linux/module.h>
-+#include <linux/fs.h>
-+#include <linux/pagemap.h>
-+#include <linux/uts.h>
-+#include <linux/version.h>
-+#include <linux/wait.h>
-+#include <linux/compiler.h>
-+#include <asm/uaccess.h>
-+#include <linux/slab.h>
-+
-+#ifndef BUG_ON
-+#define BUG_ON(condition) do { if (unlikely((condition)!=0)) BUG(); } while(0)
-+#endif
-+
-+#include <linux/usb_gadgetfs.h>
-+#include <linux/usb_gadget.h>
-+
-+
-+/*
-+ * The gadgetfs API maps each endpoint to a file descriptor so that you
-+ * can use standard synchronous read/write calls for I/O.  There's some
-+ * O_NONBLOCK and O_ASYNC/FASYNC style i/o support.  Example usermode
-+ * drivers show how this works in practice.
-+ *
-+ * Key parts that must be USB-specific are protocols defining how the
-+ * read/write operations relate to the hardware state machines.  There
-+ * are two types of files.  One type is for the device, implementing ep0.
-+ * The other type is for each IN or OUT endpoint.  In both cases, the
-+ * user mode driver must configure the hardware before using it.
-+ *
-+ * - First, dev_config() is called when /dev/gadget/$CHIP is configured
-+ *   (by writing configuration and device descriptors).  Afterwards it
-+ *   may serve as a source of device events, used to handle all control
-+ *   requests other than basic enumeration.
-+ *
-+ * - Then either immediately, or after a SET_CONFIGURATION control request,
-+ *   ep_config() is called when each /dev/gadget/ep* file is configured
-+ *   (by writing endpoint descriptors).  Afterwards these files are used
-+ *   to write() IN data or to read() OUT data.  To halt the endpoint, a
-+ *   "wrong direction" request is issued (like reading an IN endpoint).
-+ *
-+ * Unlike "usbfs" the only ioctl()s are for things that are rare, and maybe
-+ * not possible on all hardware.  For example, precise fault handling with
-+ * respect to data left in endpoint fifos after aborted operations; or
-+ * selective clearing of endpoint halts, to implement SET_INTERFACE.
-+ */
-+
-+#define	DRIVER_DESC	"USB Gadget filesystem"
-+#define	DRIVER_VERSION	"20 Aug 2003"
-+
-+static const char driver_desc [] = DRIVER_DESC;
-+static const char shortname [] = "gadgetfs";
-+
-+MODULE_DESCRIPTION (DRIVER_DESC);
-+MODULE_AUTHOR ("David Brownell");
-+MODULE_LICENSE ("GPL");
-+
-+
-+/*----------------------------------------------------------------------*/
-+
-+#define GADGETFS_MAGIC		0xaee71ee7
-+#define DMA_ADDR_INVALID	(~(dma_addr_t)0)
-+
-+/* /dev/gadget/$CHIP represents ep0 and the whole device */
-+enum ep0_state {
-+	/* DISBLED is the initial state.
-+	 */
-+	STATE_DEV_DISABLED = 0,
-+
-+	/* Only one open() of /dev/gadget/$CHIP; only one file tracks
-+	 * ep0/device i/o modes and binding to the controller.  Driver
-+	 * must always write descriptors to initialize the device, then
-+	 * the device becomes UNCONNECTED until enumeration.
-+	 */
-+	STATE_OPENED,
-+
-+	/* From then on, ep0 fd is in either of two basic modes:
-+	 * - (UN)CONNECTED: read usb_gadgetfs_event(s) from it
-+	 * - SETUP: read/write will transfer control data and succeed;
-+	 *   or if "wrong direction", performs protocol stall
-+	 */
-+	STATE_UNCONNECTED,
-+	STATE_CONNECTED,
-+	STATE_SETUP,
-+
-+	/* UNBOUND means the driver closed ep0, so the device won't be
-+	 * accessible again (DEV_DISABLED) until all fds are closed.
-+	 */
-+	STATE_DEV_UNBOUND,
-+};
-+
-+/* enough for the whole queue: most events invalidate others */
-+#define	N_EVENT			5
-+
-+struct dev_data {
-+	spinlock_t			lock;
-+	atomic_t			count;
-+	enum ep0_state			state;
-+	struct usb_gadgetfs_event	event [N_EVENT];
-+	unsigned			ev_next;
-+	struct fasync_struct		*fasync;
-+	u8				current_config;
-+
-+	/* drivers reading ep0 MUST handle control requests (SETUP)
-+	 * reported that way; else the host will time out.
-+	 */
-+	unsigned			usermode_setup : 1,
-+					setup_in : 1,
-+					setup_can_stall : 1,
-+					setup_out_ready : 1,
-+					setup_out_error : 1,
-+					setup_abort : 1;
-+
-+	/* the rest is basically write-once */
-+	struct usb_config_descriptor	*config, *hs_config;
-+	struct usb_device_descriptor	*dev;
-+	struct usb_request		*req;
-+	struct usb_gadget		*gadget;
-+	struct list_head		epfiles;
-+	void				*buf;
-+	wait_queue_head_t		wait;
-+	struct super_block		*sb;
-+	struct dentry			*dentry;
-+
-+	/* except this scratch i/o buffer for ep0 */
-+	u8				rbuf [256];
-+};
-+
-+static inline void get_dev (struct dev_data *data)
-+{
-+	atomic_inc (&data->count);
-+}
-+
-+static void put_dev (struct dev_data *data)
-+{
-+	if (likely (!atomic_dec_and_test (&data->count)))
-+		return;
-+	/* needs no more cleanup */
-+	BUG_ON (waitqueue_active (&data->wait));
-+	kfree (data);
-+}
-+
-+static struct dev_data *dev_new (void)
-+{
-+	struct dev_data		*dev;
-+
-+	dev = kmalloc (sizeof *dev, GFP_KERNEL);
-+	if (!dev)
-+		return 0;
-+	memset (dev, 0, sizeof *dev);
-+	dev->state = STATE_DEV_DISABLED;
-+	atomic_set (&dev->count, 1);
-+	spin_lock_init (&dev->lock);
-+	INIT_LIST_HEAD (&dev->epfiles);
-+	init_waitqueue_head (&dev->wait);
-+	return dev;
-+}
-+
-+/*----------------------------------------------------------------------*/
-+
-+/* other /dev/gadget/$ENDPOINT files represent endpoints */
-+enum ep_state {
-+	STATE_EP_DISABLED = 0,
-+	STATE_EP_READY,
-+	STATE_EP_DEFER_ENABLE,
-+	STATE_EP_ENABLED,
-+	STATE_EP_UNBOUND,
-+};
-+
-+struct ep_data {
-+	struct semaphore		lock;
-+	enum ep_state			state;
-+	atomic_t			count;
-+	struct dev_data			*dev;
-+	/* must hold dev->lock before accessing ep or req */
-+	struct usb_ep			*ep;
-+	struct usb_request		*req;
-+	ssize_t				status;
-+	char				name [16];
-+	struct usb_endpoint_descriptor	desc, hs_desc;
-+	struct list_head		epfiles;
-+	wait_queue_head_t		wait;
-+	struct dentry			*dentry;
-+	struct inode			*inode;
-+};
-+
-+static inline void get_ep (struct ep_data *data)
-+{
-+	atomic_inc (&data->count);
-+}
-+
-+static void put_ep (struct ep_data *data)
-+{
-+	if (likely (!atomic_dec_and_test (&data->count)))
-+		return;
-+	put_dev (data->dev);
-+	/* needs no more cleanup */
-+	BUG_ON (!list_empty (&data->epfiles));
-+	BUG_ON (waitqueue_active (&data->wait));
-+	BUG_ON (down_trylock (&data->lock) != 0);
-+	kfree (data);
-+}
-+
-+/*----------------------------------------------------------------------*/
-+
-+/* most "how to use the hardware" policy choices are in userspace:
-+ * mapping endpoint roles the driver needs to the capabilities that
-+ * the usb controller exposes.
-+ */
-+
-+	// FIXME the 2.6 version just probes the controller
-+	// driver to find out the chip name; we should too.
-+
-+#ifdef	CONFIG_USB_GADGET_NET2280
-+#define CHIP			"net2280"
-+#define HIGHSPEED
-+#endif
-+
-+#ifdef	CONFIG_USB_GADGET_PXA2XX
-+#define CHIP			"pxa2xx_udc"
-+/* earlier hardware doesn't have UDCCFR, races set_{config,interface} */
-+#warning works best with pxa255 or newer
-+#endif
-+
-+#ifdef	CONFIG_USB_GADGET_GOKU
-+#define CHIP			"goku_udc"
-+#endif
-+
-+#ifdef	CONFIG_USB_GADGET_SA1100
-+#define CHIP			"sa1100"
-+#endif
-+
-+#ifdef	CONFIG_USB_GADGET_SUPERH
-+#define CHIP			"superh_udc"
-+#endif
-+
-+#ifdef CONFIG_USB_GADGET_N9604
-+#define CHIP			"n9604_udc"
-+#endif
-+
-+
-+/*----------------------------------------------------------------------*/
-+
-+/* NOTE:  don't use dev_printk calls before binding to the gadget
-+ * at the end of ep0 configuration, or after unbind.
-+ */
-+
-+/* too wordy: dev_printk(level , &(d)->gadget->dev , fmt , ## args) */
-+#define xprintk(d,level,fmt,args...) \
-+	printk(level "%s: " fmt , shortname , ## args)
-+
-+#ifdef 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
-+#define VDEBUG	DBG
-+#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)
-+
-+
-+/*----------------------------------------------------------------------*/
-+
-+/* SYNCHRONOUS ENDPOINT OPERATIONS (bulk/intr/iso)
-+ *
-+ * After opening, configure non-control endpoints.  Then use normal
-+ * stream read() and write() requests; and maybe ioctl() to get more
-+ * precise FIFO status when recovering from cancelation.
-+ */
-+
-+static void epio_complete (struct usb_ep *ep, struct usb_request *req)
-+{
-+	struct ep_data	*epdata = ep->driver_data;
-+
-+	if (!req->context)
-+		return;
-+	if (req->status)
-+		epdata->status = req->status;
-+	else
-+		epdata->status = req->actual;
-+	complete ((struct completion *)req->context);
-+}
-+
-+/* tasklock endpoint, returning when it's connected.
-+ * still need dev->lock to use epdata->ep.
-+ */
-+static int
-+get_ready_ep (unsigned f_flags, struct ep_data *epdata)
-+{
-+	int	val;
-+
-+	if (f_flags & O_NONBLOCK) {
-+		if (down_trylock (&epdata->lock) != 0)
-+			goto nonblock;
-+		if (epdata->state != STATE_EP_ENABLED) {
-+			up (&epdata->lock);
-+nonblock:
-+			val = -EAGAIN;
-+		} else
-+			val = 0;
-+		return val;
-+	}
-+
-+	if ((val = down_interruptible (&epdata->lock)) < 0)
-+		return val;
-+newstate:
-+	switch (epdata->state) {
-+	case STATE_EP_ENABLED:
-+		break;
-+	case STATE_EP_DEFER_ENABLE:
-+		DBG (epdata->dev, "%s wait for host\n", epdata->name);
-+		if ((val = wait_event_interruptible (epdata->wait, 
-+				epdata->state != STATE_EP_DEFER_ENABLE
-+				|| epdata->dev->state == STATE_DEV_UNBOUND
-+				)) < 0)
-+			goto fail;
-+		goto newstate;
-+	// case STATE_EP_DISABLED:		/* "can't happen" */
-+	// case STATE_EP_READY:			/* "can't happen" */
-+	default:				/* error! */
-+		pr_debug ("%s: ep %p not available, state %d\n",
-+				shortname, epdata, epdata->state);
-+		// FALLTHROUGH
-+	case STATE_EP_UNBOUND:			/* clean disconnect */
-+		val = -ENODEV;
-+fail:
-+		up (&epdata->lock);
-+	}
-+	return val;
-+}
-+
-+static ssize_t
-+ep_io (struct ep_data *epdata, void *buf, unsigned len)
-+{
-+	DECLARE_COMPLETION (done);
-+	int value;
-+
-+	spin_lock_irq (&epdata->dev->lock);
-+	if (likely (epdata->ep != NULL)) {
-+		struct usb_request	*req = epdata->req;
-+
-+		req->context = &done;
-+		req->complete = epio_complete;
-+		req->buf = buf;
-+		req->length = len;
-+		value = usb_ep_queue (epdata->ep, req, GFP_ATOMIC);
-+	} else
-+		value = -ENODEV;
-+	spin_unlock_irq (&epdata->dev->lock);
-+
-+	if (likely (value == 0)) {
-+		value = wait_event_interruptible (done.wait, done.done);
-+		if (value != 0) {
-+			spin_lock_irq (&epdata->dev->lock);
-+			if (likely (epdata->ep != NULL)) {
-+				DBG (epdata->dev, "%s i/o interrupted\n",
-+						epdata->name);
-+				usb_ep_dequeue (epdata->ep, epdata->req);
-+				spin_unlock_irq (&epdata->dev->lock);
-+
-+				wait_event (done.wait, done.done);
-+				if (epdata->status == -ECONNRESET)
-+					epdata->status = -EINTR;
-+			} else {
-+				spin_unlock_irq (&epdata->dev->lock);
-+
-+				DBG (epdata->dev, "endpoint gone\n");
-+				epdata->status = -ENODEV;
-+			}
-+		}
-+		return epdata->status;
-+	}
-+	return value;
-+}
-+
-+
-+/* handle a synchronous OUT bulk/intr/iso transfer */
-+static ssize_t
-+ep_read (struct file *fd, char *buf, size_t len, loff_t *ptr)
-+{
-+	struct ep_data		*data = fd->private_data;
-+	void			*kbuf;
-+	ssize_t			value;
-+
-+	if ((value = get_ready_ep (fd->f_flags, data)) < 0)
-+		return value;
-+
-+	/* halt any endpoint by doing a "wrong direction" i/o call */
-+	if (data->desc.bEndpointAddress & USB_DIR_IN) {
-+		if ((data->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
-+				== USB_ENDPOINT_XFER_ISOC)
-+			return -EINVAL;
-+		DBG (data->dev, "%s halt\n", data->name);
-+		spin_lock_irq (&data->dev->lock);
-+		if (likely (data->ep != NULL))
-+			usb_ep_set_halt (data->ep);
-+		spin_unlock_irq (&data->dev->lock);
-+		up (&data->lock);
-+		return -EBADMSG;
-+	}
-+
-+	/* FIXME readahead for O_NONBLOCK and poll(); careful with ZLPs */
-+
-+	value = -ENOMEM;
-+	kbuf = kmalloc (len, SLAB_KERNEL);
-+	if (unlikely (!kbuf))
-+		goto free1;
-+
-+	value = ep_io (data, kbuf, len);
-+	VDEBUG (data->dev, "%s read %d OUT, status %d\n",
-+		data->name, len, value);
-+	if (value >= 0 && copy_to_user (buf, kbuf, value))
-+		value = -EFAULT;
-+
-+free1:
-+	up (&data->lock);
-+	kfree (kbuf);
-+	return value;
-+}
-+
-+/* handle a synchronous IN bulk/intr/iso transfer */
-+static ssize_t
-+ep_write (struct file *fd, const char *buf, size_t len, loff_t *ptr)
-+{
-+	struct ep_data		*data = fd->private_data;
-+	void			*kbuf;
-+	ssize_t			value;
-+
-+	if ((value = get_ready_ep (fd->f_flags, data)) < 0)
-+		return value;
-+
-+	/* halt any endpoint by doing a "wrong direction" i/o call */
-+	if (!(data->desc.bEndpointAddress & USB_DIR_IN)) {
-+		if ((data->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
-+				== USB_ENDPOINT_XFER_ISOC)
-+			return -EINVAL;
-+		DBG (data->dev, "%s halt\n", data->name);
-+		spin_lock_irq (&data->dev->lock);
-+		if (likely (data->ep != NULL))
-+			usb_ep_set_halt (data->ep);
-+		spin_unlock_irq (&data->dev->lock);
-+		up (&data->lock);
-+		return -EBADMSG;
-+	}
-+
-+	/* FIXME writebehind for O_NONBLOCK and poll(), qlen = 1 */
-+
-+	value = -ENOMEM;
-+	kbuf = kmalloc (len, SLAB_KERNEL);
-+	if (!kbuf)
-+		goto free1;
-+	if (copy_from_user (kbuf, buf, len)) {
-+		value = -EFAULT;
-+		goto free1;
-+	}
-+
-+	value = ep_io (data, kbuf, len);
-+	VDEBUG (data->dev, "%s write %d IN, status %d\n",
-+		data->name, len, value);
-+free1:
-+	up (&data->lock);
-+	kfree (kbuf);
-+	return value;
-+}
-+
-+static int
-+ep_release (struct inode *inode, struct file *fd)
-+{
-+	struct ep_data		*data = fd->private_data;
-+
-+	/* clean up if this can be reopened */
-+	if (data->state != STATE_EP_UNBOUND) {
-+		data->state = STATE_EP_DISABLED;
-+		data->desc.bDescriptorType = 0;
-+		data->hs_desc.bDescriptorType = 0;
-+	}
-+	put_ep (data);
-+	return 0;
-+}
-+
-+static int ep_ioctl (struct inode *inode, struct file *fd,
-+		unsigned code, unsigned long value)
-+{
-+	struct ep_data		*data = fd->private_data;
-+	int			status;
-+
-+	if ((status = get_ready_ep (fd->f_flags, data)) < 0)
-+		return status;
-+
-+	spin_lock_irq (&data->dev->lock);
-+	if (likely (data->ep != NULL)) {
-+		switch (code) {
-+		case GADGETFS_FIFO_STATUS:
-+			status = usb_ep_fifo_status (data->ep);
-+			break;
-+		case GADGETFS_FIFO_FLUSH:
-+			usb_ep_fifo_flush (data->ep);
-+			break;
-+		case GADGETFS_CLEAR_HALT:
-+			status = usb_ep_clear_halt (data->ep);
-+			break;
-+		default:
-+			status = -ENOTTY;
-+		}
-+	} else
-+		status = -ENODEV;
-+	spin_unlock_irq (&data->dev->lock);
-+	up (&data->lock);
-+	return status;
-+}
-+
-+/* used after endpoint configuration */
-+static struct file_operations ep_io_operations = {
-+	.owner =	THIS_MODULE,
-+	.read =		ep_read,
-+	.write =	ep_write,
-+	.ioctl =	ep_ioctl,
-+	.release =	ep_release,
-+
-+	// .aio_read =	ep_aio_read,
-+	// .aio_write =	ep_aio_write,
-+};
-+
-+/* ENDPOINT INITIALIZATION
-+ *
-+ *     fd = open ("/dev/gadget/$ENDPOINT", O_RDWR)
-+ *     status = write (fd, descriptors, sizeof descriptors)
-+ *
-+ * That write establishes the endpoint configuration, configuring
-+ * the controller to process bulk, interrupt, or isochronous transfers
-+ * at the right maxpacket size, and so on.
-+ *
-+ * The descriptors are message type 1, identified by a host order u32
-+ * at the beginning of what's written.  Descriptor order is: full/low
-+ * speed descriptor, then optional high speed descriptor.
-+ */
-+static ssize_t
-+ep_config (struct file *fd, const char *buf, size_t len, loff_t *ptr)
-+{
-+	struct ep_data		*data = fd->private_data;
-+	struct usb_ep		*ep;
-+	u32			tag;
-+	int			value;
-+
-+	if ((value = down_interruptible (&data->lock)) < 0)
-+		return value;
-+
-+	if (data->state != STATE_EP_READY) {
-+		value = -EL2HLT;
-+		goto fail;
-+	}
-+
-+	value = len;
-+	if (len < USB_DT_ENDPOINT_SIZE + 4)
-+		goto fail0;
-+
-+	/* we might need to change message format someday */
-+	if (copy_from_user (&tag, buf, 4)) {
-+		goto fail1;
-+	}
-+	if (tag != 1) {
-+		DBG(data->dev, "config %s, bad tag %d\n", data->name, tag);
-+		goto fail0;
-+	}
-+	buf += 4;
-+	len -= 4;
-+
-+	/* NOTE:  audio endpoint extensions not accepted here;
-+	 * just don't include the extra bytes.
-+	 */
-+
-+	/* full/low speed descriptor, then high speed */
-+	if (copy_from_user (&data->desc, buf, USB_DT_ENDPOINT_SIZE)) {
-+		goto fail1;
-+	}
-+	if (data->desc.bLength != USB_DT_ENDPOINT_SIZE
-+			|| data->desc.bDescriptorType != USB_DT_ENDPOINT)
-+		goto fail0;
-+	if (len != USB_DT_ENDPOINT_SIZE) {
-+		if (len != 2 * USB_DT_ENDPOINT_SIZE)
-+			goto fail0;
-+		if (copy_from_user (&data->hs_desc, buf + USB_DT_ENDPOINT_SIZE,
-+					USB_DT_ENDPOINT_SIZE)) {
-+			goto fail1;
-+		}
-+		if (data->hs_desc.bLength != USB_DT_ENDPOINT_SIZE
-+				|| data->hs_desc.bDescriptorType
-+					!= USB_DT_ENDPOINT) {
-+			DBG(data->dev, "config %s, bad hs length or type\n",
-+					data->name);
-+			goto fail0;
-+		}
-+	}
-+	value = len;
-+
-+	spin_lock_irq (&data->dev->lock);
-+	if (data->dev->state == STATE_DEV_UNBOUND) {
-+		value = -ENOENT;
-+		goto gone;
-+	} else if ((ep = data->ep) == NULL) {
-+		value = -ENODEV;
-+		goto gone;
-+	}
-+	switch (data->dev->gadget->speed) {
-+	case USB_SPEED_LOW:
-+	case USB_SPEED_FULL:
-+		value = usb_ep_enable (ep, &data->desc);
-+		if (value == 0)
-+			data->state = STATE_EP_ENABLED;
-+		break;
-+#ifdef	HIGHSPEED
-+	case USB_SPEED_HIGH:
-+		/* fails if caller didn't provide that descriptor... */
-+		value = usb_ep_enable (ep, &data->hs_desc);
-+		if (value == 0)
-+			data->state = STATE_EP_ENABLED;
-+		break;
-+#endif
-+	default:
-+		DBG (data->dev, "unconnected, %s init deferred\n",
-+				data->name);
-+		data->state = STATE_EP_DEFER_ENABLE;
-+	}
-+	if (value == 0)
-+		fd->f_op = &ep_io_operations;
-+gone:
-+	spin_unlock_irq (&data->dev->lock);
-+	if (value < 0) {
-+fail:
-+		data->desc.bDescriptorType = 0;
-+		data->hs_desc.bDescriptorType = 0;
-+	}
-+	up (&data->lock);
-+	return value;
-+fail0:
-+	value = -EINVAL;
-+	goto fail;
-+fail1:
-+	value = -EFAULT;
-+	goto fail;
-+}
-+
-+static int
-+ep_open (struct inode *inode, struct file *fd)
-+{
-+	struct ep_data		*data = inode->u.generic_ip;
-+	int			value = -EBUSY;
-+
-+	if (down_interruptible (&data->lock) != 0)
-+		return -EINTR;
-+	spin_lock_irq (&data->dev->lock);
-+	if (data->dev->state == STATE_DEV_UNBOUND)
-+		value = -ENOENT;
-+	else if (data->state == STATE_EP_DISABLED) {
-+		value = 0;
-+		data->state = STATE_EP_READY;
-+		get_ep (data);
-+		fd->private_data = data;
-+		VDEBUG (data->dev, "%s ready\n", data->name);
-+	} else
-+		DBG (data->dev, "%s state %d\n",
-+			data->name, data->state);
-+	spin_unlock_irq (&data->dev->lock);
-+	up (&data->lock);
-+	return value;
-+}
-+
-+/* used before endpoint configuration */
-+static struct file_operations ep_config_operations = {
-+	.owner =	THIS_MODULE,
-+	.open =		ep_open,
-+	.write =	ep_config,
-+	.release =	ep_release,
-+};
-+
-+/*----------------------------------------------------------------------*/
-+
-+/* EP0 IMPLEMENTATION can be partly in userspace.
-+ *
-+ * Drivers that use this facility receive various events, including
-+ * control requests the kernel doesn't handle.  Drivers that don't
-+ * use this facility may be too simple-minded for real applications.
-+ */
-+
-+static inline void ep0_readable (struct dev_data *dev)
-+{
-+	wake_up (&dev->wait);
-+	kill_fasync (&dev->fasync, SIGIO, POLL_IN);
-+}
-+
-+static void clean_req (struct usb_ep *ep, struct usb_request *req)
-+{
-+	struct dev_data		*dev = ep->driver_data;
-+
-+	if (req->buf != dev->rbuf) {
-+		usb_ep_free_buffer (ep, req->buf, req->dma, req->length);
-+		req->buf = dev->rbuf;
-+		req->dma = DMA_ADDR_INVALID;
-+	}
-+	req->complete = epio_complete;
-+	dev->setup_out_ready = 0;
-+}
-+
-+static void ep0_complete (struct usb_ep *ep, struct usb_request *req)
-+{
-+	struct dev_data		*dev = ep->driver_data;
-+	int			free = 1;
-+
-+	/* for control OUT, data must still get to userspace */
-+	if (!dev->setup_in) {
-+		dev->setup_out_error = (req->status != 0);
-+		if (!dev->setup_out_error)
-+			free = 0;
-+		dev->setup_out_ready = 1;
-+		ep0_readable (dev);
-+	} else if (dev->state == STATE_SETUP)
-+		dev->state = STATE_CONNECTED;
-+
-+	/* clean up as appropriate */
-+	if (free && req->buf != &dev->rbuf)
-+		clean_req (ep, req);
-+	req->complete = epio_complete;
-+}
-+
-+static int setup_req (struct usb_ep *ep, struct usb_request *req, u16 len)
-+{
-+	struct dev_data	*dev = ep->driver_data;
-+
-+	if (dev->setup_out_ready) {
-+		DBG (dev, "ep0 request busy!\n");
-+		return -EBUSY;
-+	}
-+	if (len > sizeof (dev->rbuf))
-+		req->buf = usb_ep_alloc_buffer (ep, len, &req->dma, GFP_ATOMIC);
-+	if (req->buf == 0) {
-+		req->buf = dev->rbuf;
-+		return -ENOMEM;
-+	}
-+	req->complete = ep0_complete;
-+	req->length = len;
-+	return 0;
-+}
-+
-+static ssize_t
-+ep0_read (struct file *fd, char *buf, size_t len, loff_t *ptr)
-+{
-+	struct dev_data			*dev = fd->private_data;
-+	ssize_t				retval;
-+	enum ep0_state			state;
-+
-+	spin_lock_irq (&dev->lock);
-+
-+	/* report fd mode change before acting on it */
-+	if (dev->setup_abort) {
-+		dev->setup_abort = 0;
-+		retval = -EIDRM;
-+		goto done;
-+	}
-+
-+	/* control DATA stage */
-+	if ((state = dev->state) == STATE_SETUP) {
-+
-+		if (dev->setup_in) {		/* stall IN */
-+			VDEBUG(dev, "ep0in stall\n");
-+			(void) usb_ep_set_halt (dev->gadget->ep0);
-+			retval = -EL2HLT;
-+			dev->state = STATE_CONNECTED;
-+
-+		} else if (len == 0) {		/* ack SET_CONFIGURATION etc */
-+			struct usb_ep		*ep = dev->gadget->ep0;
-+			struct usb_request	*req = dev->req;
-+
-+			if ((retval = setup_req (ep, req, 0)) == 0)
-+				retval = usb_ep_queue (ep, req, GFP_ATOMIC);
-+			dev->state = STATE_CONNECTED;
-+
-+		} else {			/* collect OUT data */
-+			if ((fd->f_flags & O_NONBLOCK) != 0
-+					&& !dev->setup_out_ready) {
-+				retval = -EAGAIN;
-+				goto done;
-+			}
-+			spin_unlock_irq (&dev->lock);
-+			retval = wait_event_interruptible (dev->wait,
-+					dev->setup_out_ready != 0);
-+
-+			/* FIXME state could change from under us */
-+			spin_lock_irq (&dev->lock);
-+			if (retval)
-+				goto done;
-+			if (dev->setup_out_error)
-+				retval = -EIO;
-+			else {
-+				len = min (len, dev->req->actual);
-+// FIXME don't call this with the spinlock held ...
-+				if (copy_to_user (buf, &dev->req->buf, len))
-+					retval = -EFAULT;
-+				clean_req (dev->gadget->ep0, dev->req);
-+				/* NOTE userspace can't yet choose to stall */
-+			}
-+		}
-+		goto done;
-+	}
-+
-+	/* else normal: return event data */
-+	if (len < sizeof dev->event [0]) {
-+		retval = -EINVAL;
-+		goto done;
-+	}
-+	len -= len % sizeof (struct usb_gadgetfs_event);
-+	dev->usermode_setup = 1;
-+
-+scan:
-+	/* return queued events right away */
-+	if (dev->ev_next != 0) {
-+		unsigned		i, n;
-+		int			tmp = dev->ev_next;
-+
-+		len = min (len, tmp * sizeof (struct usb_gadgetfs_event));
-+		n = len / sizeof (struct usb_gadgetfs_event);
-+
-+		/* ep0 can't deliver events when STATE_SETUP */
-+		for (i = 0; i < n; i++) {
-+			if (dev->event [i].type == GADGETFS_SETUP) {
-+				len = n = i + 1;
-+				len *= sizeof (struct usb_gadgetfs_event);
-+				n = 0;
-+				break;
-+			}
-+		}
-+		spin_unlock_irq (&dev->lock);
-+		if (copy_to_user (buf, &dev->event, len))
-+			retval = -EFAULT;
-+		else
-+			retval = len;
-+		if (len > 0) {
-+			len /= sizeof (struct usb_gadgetfs_event);
-+
-+			/* NOTE this doesn't guard against broken drivers;
-+			 * concurrent ep0 readers may lose events.
-+			 */
-+			spin_lock_irq (&dev->lock);
-+			dev->ev_next -= len;
-+			if (dev->ev_next != 0)
-+				memmove (&dev->event, &dev->event [len],
-+					sizeof (struct usb_gadgetfs_event)
-+						* (tmp - len));
-+			if (n == 0)
-+				dev->state = STATE_SETUP;
-+			spin_unlock_irq (&dev->lock);
-+		}
-+		return retval;
-+	}
-+	if (fd->f_flags & O_NONBLOCK) {
-+		retval = -EAGAIN;
-+		goto done;
-+	}
-+
-+	switch (state) {
-+	default:
-+		DBG (dev, "fail %s, state %d\n", __FUNCTION__, state);
-+		retval = -ESRCH;
-+		break;
-+	case STATE_UNCONNECTED:
-+	case STATE_CONNECTED:
-+		spin_unlock_irq (&dev->lock);
-+		DBG (dev, "%s wait\n", __FUNCTION__);
-+
-+		/* wait for events */
-+		retval = wait_event_interruptible (dev->wait,
-+				dev->ev_next != 0);
-+		if (retval < 0)
-+			return retval;
-+		spin_lock_irq (&dev->lock);
-+		goto scan;
-+	}
-+
-+done:
-+	spin_unlock_irq (&dev->lock);
-+	return retval;
-+}
-+
-+static struct usb_gadgetfs_event *
-+next_event (struct dev_data *dev, enum usb_gadgetfs_event_type type)
-+{
-+	struct usb_gadgetfs_event	*event;
-+	unsigned			i;
-+
-+	switch (type) {
-+	/* these events purge the queue */
-+	case GADGETFS_DISCONNECT:
-+		if (dev->state == STATE_SETUP)
-+			dev->setup_abort = 1;
-+		// FALL THROUGH
-+	case GADGETFS_CONNECT:
-+		dev->ev_next = 0;
-+		break;
-+	case GADGETFS_SETUP:		/* previous request timed out */
-+	case GADGETFS_SUSPEND:		/* same effect */
-+		/* these events can't be repeated */
-+		for (i = 0; i != dev->ev_next; i++) {
-+			if (dev->event [i].type != type)
-+				continue;
-+			DBG (dev, "discard old event %d\n", type);
-+			dev->ev_next--;
-+			if (i == dev->ev_next)
-+				break;
-+			/* indices start at zero, for simplicity */
-+			memmove (&dev->event [i], &dev->event [i + 1],
-+				sizeof (struct usb_gadgetfs_event)
-+					* (dev->ev_next - i));
-+		}
-+		break;
-+	default:
-+		BUG ();
-+	}
-+	event = &dev->event [dev->ev_next++];
-+	BUG_ON (dev->ev_next > N_EVENT);
-+	VDEBUG (dev, "ev %d, next %d\n", type, dev->ev_next);
-+	memset (event, 0, sizeof *event);
-+	event->type = type;
-+	return event;
-+}
-+
-+static ssize_t
-+ep0_write (struct file *fd, const char *buf, size_t len, loff_t *ptr)
-+{
-+	struct dev_data		*dev = fd->private_data;
-+	ssize_t			retval = -ESRCH;
-+
-+	spin_lock_irq (&dev->lock);
-+
-+	/* report fd mode change before acting on it */
-+	if (dev->setup_abort) {
-+		dev->setup_abort = 0;
-+		retval = -EIDRM;
-+
-+	/* data and/or status stage for control request */
-+	} else if (dev->state == STATE_SETUP) {
-+
-+		/* IN DATA+STATUS caller makes len <= wLength */
-+		if (dev->setup_in) {
-+			retval = setup_req (dev->gadget->ep0, dev->req, len);
-+			if (retval == 0) {
-+				spin_unlock_irq (&dev->lock);
-+				if (copy_from_user (dev->req->buf, buf, len))
-+					retval = -EFAULT;
-+				else
-+					retval = usb_ep_queue (
-+						dev->gadget->ep0, dev->req,
-+						GFP_KERNEL);
-+				if (retval < 0) {
-+					spin_lock_irq (&dev->lock);
-+					clean_req (dev->gadget->ep0, dev->req);
-+					spin_unlock_irq (&dev->lock);
-+				} else
-+					retval = len;
-+
-+				return retval;
-+			}
-+
-+		/* can stall some OUT transfers */
-+		} else if (dev->setup_can_stall) {
-+			VDEBUG(dev, "ep0out stall\n");
-+			(void) usb_ep_set_halt (dev->gadget->ep0);
-+			retval = -EL2HLT;
-+			dev->state = STATE_CONNECTED;
-+		} else {
-+			DBG(dev, "bogus ep0out stall!\n");
-+		}
-+	} else
-+		DBG (dev, "fail %s, state %d\n", __FUNCTION__, dev->state);
-+
-+	spin_unlock_irq (&dev->lock);
-+	return retval;
-+}
-+
-+static int
-+ep0_fasync (int f, struct file *fd, int on)
-+{
-+	struct dev_data		*dev = fd->private_data;
-+	// caller must F_SETOWN before signal delivery happens
-+	VDEBUG (dev, "%s %s\n", __FUNCTION__, on ? "on" : "off");
-+	return fasync_helper (f, fd, on, &dev->fasync);
-+}
-+
-+static struct usb_gadget_driver gadgetfs_driver;
-+
-+static int
-+dev_release (struct inode *inode, struct file *fd)
-+{
-+	struct dev_data		*dev = fd->private_data;
-+
-+	/* closing ep0 === shutdown all */
-+
-+	usb_gadget_unregister_driver (&gadgetfs_driver);
-+
-+	/* at this point "good" hardware has disconnected the
-+	 * device from USB; the host won't see it any more.
-+	 * alternatively, all host requests will time out.
-+	 */
-+
-+	fasync_helper (-1, fd, 0, &dev->fasync);
-+	kfree (dev->buf);
-+	dev->buf = 0;
-+	put_dev (dev);
-+
-+	/* other endpoints were all decoupled from this device */
-+	dev->state = STATE_DEV_DISABLED;
-+	return 0;
-+}
-+
-+static int dev_ioctl (struct inode *inode, struct file *fd,
-+		unsigned code, unsigned long value)
-+{
-+	struct dev_data		*dev = fd->private_data;
-+	struct usb_gadget	*gadget = dev->gadget;
-+
-+	if (gadget->ops->ioctl)
-+		return gadget->ops->ioctl (gadget, code, value);
-+	return -ENOTTY;
-+}
-+
-+/* used after device configuration */
-+static struct file_operations ep0_io_operations = {
-+	.owner =	THIS_MODULE,
-+	.read =		ep0_read,
-+	.write =	ep0_write,
-+	.fasync =	ep0_fasync,
-+	// .poll =	ep0_poll,
-+	.ioctl =	dev_ioctl,
-+	.release =	dev_release,
-+};
-+
-+/*----------------------------------------------------------------------*/
-+
-+/* The in-kernel gadget driver handles most ep0 issues, in particular
-+ * enumerating the single configuration (as provided from user space).
-+ *
-+ * Unrecognized ep0 requests may be handled in user space.
-+ */
-+
-+#ifdef	HIGHSPEED
-+static void make_qualifier (struct dev_data *dev)
-+{
-+	struct usb_qualifier_descriptor		qual;
-+	struct usb_device_descriptor		*desc;
-+
-+	qual.bLength = sizeof qual;
-+	qual.bDescriptorType = USB_DT_DEVICE_QUALIFIER;
-+	qual.bcdUSB = __constant_cpu_to_le16 (0x0200);
-+
-+	desc = dev->dev;
-+	qual.bDeviceClass = desc->bDeviceClass;
-+	qual.bDeviceSubClass = desc->bDeviceSubClass;
-+	qual.bDeviceProtocol = desc->bDeviceProtocol;
-+
-+	/* assumes ep0 uses the same value for both speeds ... */
-+	qual.bMaxPacketSize0 = desc->bMaxPacketSize0;
-+
-+	qual.bNumConfigurations = 1;
-+	qual.bRESERVED = 0;
-+
-+	memcpy (dev->rbuf, &qual, sizeof qual);
-+}
-+#endif
-+
-+static int
-+config_buf (struct dev_data *dev, u8 type, unsigned index)
-+{
-+	int		len;
-+#ifdef HIGHSPEED
-+	int		hs;
-+#endif
-+
-+	/* only one configuration */
-+	if (index > 0)
-+		return -EINVAL;
-+
-+#ifdef HIGHSPEED
-+	hs = (dev->gadget->speed == USB_SPEED_HIGH);
-+	if (type == USB_DT_OTHER_SPEED_CONFIG)
-+		hs = !hs;
-+	if (hs) {
-+		dev->req->buf = dev->hs_config;
-+		len = le16_to_cpup (&dev->hs_config->wTotalLength);
-+	} else
-+#endif
-+	{
-+		dev->req->buf = dev->config;
-+		len = le16_to_cpup (&dev->config->wTotalLength);
-+	}
-+	((u8 *)dev->req->buf) [1] = type;
-+	return len;
-+}
-+
-+static int
-+gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
-+{
-+	struct dev_data			*dev = get_gadget_data (gadget);
-+	struct usb_request		*req = dev->req;
-+	int				value = -EOPNOTSUPP;
-+	struct usb_gadgetfs_event	*event;
-+
-+	spin_lock (&dev->lock);
-+	dev->setup_abort = 0;
-+	if (dev->state == STATE_UNCONNECTED) {
-+		struct usb_ep	*ep;
-+		struct ep_data	*data;
-+
-+		dev->state = STATE_CONNECTED;
-+		dev->dev->bMaxPacketSize0 = gadget->ep0->maxpacket;
-+
-+#ifdef	HIGHSPEED
-+		if (gadget->speed == USB_SPEED_HIGH && dev->hs_config == 0) {
-+			ERROR (dev, "no high speed config??\n");
-+			return -EINVAL;
-+		}
-+#endif	/* HIGHSPEED */
-+
-+		INFO (dev, "connected\n");
-+		event = next_event (dev, GADGETFS_CONNECT);
-+		event->u.speed = gadget->speed;
-+		ep0_readable (dev);
-+
-+		list_for_each_entry (ep, &gadget->ep_list, ep_list) {
-+			data = ep->driver_data;
-+			/* ... down_trylock (&data->lock) ... */
-+			if (data->state != STATE_EP_DEFER_ENABLE)
-+				continue;
-+#ifdef	HIGHSPEED
-+			if (gadget->speed == USB_SPEED_HIGH)
-+				value = usb_ep_enable (ep, &data->hs_desc);
-+			else
-+#endif	/* HIGHSPEED */
-+				value = usb_ep_enable (ep, &data->desc);
-+			if (value) {
-+				ERROR (dev, "deferred %s enable --> %d\n",
-+					data->name, value);
-+				continue;
-+			}
-+			data->state = STATE_EP_ENABLED;
-+			wake_up (&data->wait);
-+			DBG (dev, "woke up %s waiters\n", data->name);
-+		}
-+
-+	/* host may have given up waiting for response.  we can miss control
-+	 * requests handled lower down (device/endpoint status and features);
-+	 * then ep0_{read,write} will report the wrong status. controller
-+	 * driver will have aborted pending i/o.
-+	 */
-+	} else if (dev->state == STATE_SETUP)
-+		dev->setup_abort = 1;
-+
-+	req->buf = dev->rbuf;
-+	req->dma = DMA_ADDR_INVALID;
-+	req->context = 0;
-+	value = -EOPNOTSUPP;
-+	switch (ctrl->bRequest) {
-+
-+	case USB_REQ_GET_DESCRIPTOR:
-+		if (ctrl->bRequestType != USB_DIR_IN)
-+			goto unrecognized;
-+		switch (ctrl->wValue >> 8) {
-+
-+		case USB_DT_DEVICE:
-+			value = min (ctrl->wLength, (u16) sizeof *dev->dev);
-+			req->buf = dev->dev;
-+			break;
-+#ifdef	HIGHSPEED
-+		case USB_DT_DEVICE_QUALIFIER:
-+			if (!dev->hs_config)
-+				break;
-+			value = min (ctrl->wLength, (u16)
-+				sizeof (struct usb_qualifier_descriptor));
-+			make_qualifier (dev);
-+			break;
-+		case USB_DT_OTHER_SPEED_CONFIG:
-+			// FALLTHROUGH
-+#endif
-+		case USB_DT_CONFIG:
-+			value = config_buf (dev,
-+					ctrl->wValue >> 8,
-+					ctrl->wValue & 0xff);
-+			if (value >= 0)
-+				value = min (ctrl->wLength, (u16) value);
-+			break;
-+		case USB_DT_STRING:
-+			goto unrecognized;
-+
-+		default:		// all others are errors
-+			break;
-+		}
-+		break;
-+
-+	/* currently one config, two speeds */
-+	case USB_REQ_SET_CONFIGURATION:
-+		if (ctrl->bRequestType != 0)
-+			break;
-+		if (0 == (u8) ctrl->wValue) {
-+			value = 0;
-+			dev->current_config = 0;
-+			// user mode expected to disable endpoints
-+		} else {
-+			u8	config;
-+#ifdef	HIGHSPEED
-+			if (gadget->speed == USB_SPEED_HIGH)
-+				config = dev->hs_config->bConfigurationValue;
-+			else
-+#endif
-+				config = dev->config->bConfigurationValue;
-+
-+			if (config == (u8) ctrl->wValue) {
-+				value = 0;
-+				dev->current_config = config;
-+			}
-+		}
-+
-+		/* report SET_CONFIGURATION like any other control request,
-+		 * except that usermode may not stall this.  the next
-+		 * request mustn't be allowed start until this finishes:
-+		 * endpoints and threads set up, etc.
-+		 *
-+		 * NOTE:  older PXA hardware (before PXA 255: without UDCCFR)
-+		 * has bad/racey automagic that prevents synchronizing here.
-+		 * even kernel mode drivers often miss them.
-+		 */
-+		if (value == 0) {
-+			INFO (dev, "configuration #%d\n", dev->current_config);
-+			if (dev->usermode_setup) {
-+				dev->setup_can_stall = 0;
-+				goto delegate;
-+			}
-+		}
-+		break;
-+
-+#ifndef	CONFIG_USB_GADGETFS_PXA2XX
-+	/* PXA automagically handles this request too */
-+	case USB_REQ_GET_CONFIGURATION:
-+		if (ctrl->bRequestType != 0x80)
-+			break;
-+		*(u8 *)req->buf = dev->current_config;
-+		value = min (ctrl->wLength, (u16) 1);
-+		break;
-+#endif
-+
-+	default:
-+unrecognized:
-+		VDEBUG (dev, "%s req%02x.%02x v%04x i%04x l%d\n",
-+			dev->usermode_setup ? "delegate" : "fail",
-+			ctrl->bRequestType, ctrl->bRequest,
-+			ctrl->wValue, ctrl->wIndex, ctrl->wLength);
-+
-+		/* if there's an ep0 reader, don't stall */
-+		if (dev->usermode_setup) {
-+			dev->setup_can_stall = 1;
-+delegate:
-+			dev->setup_in = (ctrl->bRequestType & USB_DIR_IN)
-+						? 1 : 0;
-+			dev->setup_out_ready = 0;
-+			dev->setup_out_error = 0;
-+			value = 0;
-+
-+			/* read DATA stage for OUT right away */
-+			if (unlikely (!dev->setup_in && ctrl->wLength)) {
-+				value = setup_req (gadget->ep0, dev->req,
-+							ctrl->wLength);
-+				if (value < 0)
-+					break;
-+				value = usb_ep_queue (gadget->ep0, dev->req,
-+							GFP_ATOMIC);
-+				if (value < 0) {
-+					clean_req (gadget->ep0, dev->req);
-+					break;
-+				}
-+
-+				/* we can't currently stall these */
-+				dev->setup_can_stall = 0;
-+			}
-+
-+			/* state changes when reader collects event */
-+			event = next_event (dev, GADGETFS_SETUP);
-+			event->u.setup = *ctrl;
-+			ep0_readable (dev);
-+			spin_unlock (&dev->lock);
-+			return 0;
-+		}
-+	}
-+
-+	/* proceed with data transfer and status phases? */
-+	if (value >= 0 && dev->state != STATE_SETUP) {
-+		req->length = value;
-+		value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
-+		if (value < 0) {
-+			DBG (dev, "ep_queue --> %d\n", value);
-+			req->status = 0;
-+		}
-+	}
-+
-+	/* device stalls when value < 0 */
-+	spin_unlock (&dev->lock);
-+	return value;
-+}
-+
-+static void destroy_ep_files (struct dev_data *dev)
-+{
-+	struct list_head	*entry, *tmp;
-+
-+	DBG (dev, "%s %d\n", __FUNCTION__, dev->state);
-+
-+	/* dev->state must prevent interference */
-+restart:
-+	spin_lock_irq (&dev->lock);
-+	list_for_each_safe (entry, tmp, &dev->epfiles) {
-+		struct ep_data	*ep;
-+
-+		/* break link to FS */
-+		ep = list_entry (entry, struct ep_data, epfiles);
-+		list_del_init (&ep->epfiles);
-+
-+		/* break link to controller */
-+		if (ep->state == STATE_EP_ENABLED)
-+			(void) usb_ep_disable (ep->ep);
-+		ep->state = STATE_EP_UNBOUND;
-+		usb_ep_free_request (ep->ep, ep->req);
-+		ep->ep = 0;
-+		wake_up (&ep->wait);
-+		put_ep (ep);
-+
-+		spin_unlock_irq (&dev->lock);
-+
-+		/* fds may still be open */
-+		goto restart;
-+	}
-+	spin_unlock_irq (&dev->lock);
-+}
-+
-+
-+static int activate_ep_files (struct dev_data *dev)
-+{
-+	struct usb_ep	*ep;
-+
-+	gadget_for_each_ep (ep, dev->gadget) {
-+		struct ep_data	*data;
-+
-+		data = kmalloc (sizeof *data, GFP_KERNEL);
-+		if (!data)
-+			goto enomem;
-+		memset (data, 0, sizeof data);
-+		data->state = STATE_EP_DISABLED;
-+		init_MUTEX (&data->lock);
-+		init_waitqueue_head (&data->wait);
-+
-+		strncpy (data->name, ep->name, sizeof (data->name) - 1);
-+		atomic_set (&data->count, 1);
-+		data->dev = dev;
-+		get_dev (dev);
-+
-+		data->ep = ep;
-+		ep->driver_data = data;
-+
-+		data->req = usb_ep_alloc_request (ep, GFP_KERNEL);
-+		if (!data->req)
-+			goto enomem;
-+
-+		list_add_tail (&data->epfiles, &dev->epfiles);
-+	}
-+	return 0;
-+
-+enomem:
-+	DBG (dev, "%s enomem\n", __FUNCTION__);
-+	destroy_ep_files (dev);
-+	return -ENOMEM;
-+}
-+
-+static void
-+gadgetfs_unbind (struct usb_gadget *gadget)
-+{
-+	struct dev_data		*dev = get_gadget_data (gadget);
-+
-+	DBG (dev, "%s\n", __FUNCTION__);
-+
-+	spin_lock_irq (&dev->lock);
-+	dev->state = STATE_DEV_UNBOUND;
-+	spin_unlock_irq (&dev->lock);
-+
-+	destroy_ep_files (dev);
-+	gadget->ep0->driver_data = 0;
-+	set_gadget_data (gadget, 0);
-+
-+	/* we've already been disconnected ... no i/o is active */
-+	if (dev->req)
-+		usb_ep_free_request (gadget->ep0, dev->req);
-+	DBG (dev, "%s done\n", __FUNCTION__);
-+	put_dev (dev);
-+}
-+
-+static struct dev_data		*the_device;
-+
-+static int
-+gadgetfs_bind (struct usb_gadget *gadget)
-+{
-+	struct dev_data		*dev = the_device;
-+
-+	if (!dev)
-+		return -ESRCH;
-+	if (0 != strcmp (CHIP, gadget->name)) {
-+		printk (KERN_ERR "%s expected " CHIP " controller not %s\n",
-+			shortname, gadget->name);
-+		return -ENODEV;
-+	}
-+
-+	set_gadget_data (gadget, dev);
-+	dev->gadget = gadget;
-+	gadget->ep0->driver_data = dev;
-+	dev->dev->bMaxPacketSize0 = gadget->ep0->maxpacket;
-+
-+	/* preallocate control response and buffer */
-+	dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
-+	if (!dev->req)
-+		goto enomem;
-+	dev->req->context = 0;
-+	dev->req->complete = epio_complete;
-+
-+	if (activate_ep_files (dev) < 0)
-+		goto enomem;
-+
-+	INFO (dev, "bound to %s driver\n", gadget->name);
-+	dev->state = STATE_UNCONNECTED;
-+	get_dev (dev);
-+	return 0;
-+
-+enomem:
-+	gadgetfs_unbind (gadget);
-+	return -ENOMEM;
-+}
-+
-+static void
-+gadgetfs_disconnect (struct usb_gadget *gadget)
-+{
-+	struct dev_data		*dev = get_gadget_data (gadget);
-+
-+	if (dev->state == STATE_UNCONNECTED) {
-+		DBG (dev, "already unconnected\n");
-+		return;
-+	}
-+	dev->state = STATE_UNCONNECTED;
-+
-+	INFO (dev, "disconnected\n");
-+	spin_lock (&dev->lock);
-+	next_event (dev, GADGETFS_DISCONNECT);
-+	ep0_readable (dev);
-+	spin_unlock (&dev->lock);
-+}
-+
-+static void
-+gadgetfs_suspend (struct usb_gadget *gadget)
-+{
-+	struct dev_data		*dev = get_gadget_data (gadget);
-+
-+	INFO (dev, "suspended from state %d\n", dev->state);
-+	spin_lock (&dev->lock);
-+	switch (dev->state) {
-+	case STATE_SETUP:		// VERY odd... host died??
-+	case STATE_CONNECTED:
-+	case STATE_UNCONNECTED:
-+		next_event (dev, GADGETFS_SUSPEND);
-+		ep0_readable (dev);
-+		/* FALLTHROUGH */
-+	default:
-+		break;
-+	}
-+	spin_unlock (&dev->lock);
-+}
-+
-+static struct usb_gadget_driver gadgetfs_driver = {
-+#ifdef	HIGHSPEED
-+	.speed		= USB_SPEED_HIGH,
-+#else
-+	.speed		= USB_SPEED_FULL,
-+#endif
-+	.function	= (char *) driver_desc,
-+	.bind		= gadgetfs_bind,
-+	.unbind		= gadgetfs_unbind,
-+	.setup		= gadgetfs_setup,
-+	.disconnect	= gadgetfs_disconnect,
-+	.suspend	= gadgetfs_suspend,
-+
-+	.driver 	= {
-+		.name		= (char *) shortname,
-+		// .shutdown = ...
-+		// .suspend = ...
-+		// .resume = ...
-+	},
-+};
-+
-+/*----------------------------------------------------------------------*/
-+
-+/* DEVICE INITIALIZATION
-+ *
-+ *     fd = open ("/dev/gadget/$CHIP", O_RDWR)
-+ *     status = write (fd, descriptors, sizeof descriptors)
-+ *
-+ * That write establishes the device configuration, so the kernel can
-+ * bind to the controller ... guaranteeing it can handle enumeration
-+ * at all necessary speeds.  Descriptor order is:
-+ *
-+ * . message tag (u32, host order) ... for now, must be zero; it
-+ *	would change to support features like multi-config devices
-+ * . full/low speed config ... all wTotalLength bytes (with interface,
-+ *	class, altsetting, endpoint, and other descriptors)
-+ * . high speed config ... all descriptors, for high speed operation;
-+ * 	this one's optional except for high-speed hardware
-+ * . device descriptor
-+ *
-+ * Endpoints are not yet enabled. Drivers may want to immediately
-+ * initialize them, using the /dev/gadget/ep* files that are available
-+ * as soon as the kernel sees the configuration, or they can wait
-+ * until device configuration and interface altsetting changes create
-+ * the need to configure (or unconfigure) them.
-+ *
-+ * After initialization, the device stays active for as long as that
-+ * $CHIP file is open.  Events may then be read from that descriptor,
-+ * such configuration notifications.  More complex drivers will handle
-+ * some control requests in user space.
-+ */
-+
-+static int is_valid_config (struct usb_config_descriptor *config)
-+{
-+	return config->bDescriptorType == USB_DT_CONFIG
-+		&& config->bLength == USB_DT_CONFIG_SIZE
-+		&& config->bConfigurationValue != 0
-+		&& (config->bmAttributes & USB_CONFIG_ATT_ONE) != 0
-+		&& (config->bmAttributes & USB_CONFIG_ATT_WAKEUP) == 0;
-+	/* FIXME check lengths: walk to end */
-+}
-+
-+static ssize_t
-+dev_config (struct file *fd, const char *buf, size_t len, loff_t *ptr)
-+{
-+	struct dev_data		*dev = fd->private_data;
-+	ssize_t			value = len, length = len;
-+	unsigned		total;
-+	u32			tag;
-+	char			*kbuf;
-+
-+	if (dev->state != STATE_OPENED)
-+		return -EEXIST;
-+
-+	if (len < (USB_DT_CONFIG_SIZE + USB_DT_DEVICE_SIZE + 4))
-+		return -EINVAL;
-+
-+	/* we might need to change message format someday */
-+	if (copy_from_user (&tag, buf, 4))
-+		return -EFAULT;
-+	if (tag != 0)
-+		return -EINVAL;
-+	buf += 4;
-+	length -= 4;
-+
-+	kbuf = kmalloc (length, SLAB_KERNEL);
-+	if (!kbuf)
-+		return -ENOMEM;
-+	if (copy_from_user (kbuf, buf, length)) {
-+		kfree (kbuf);
-+		return -EFAULT;
-+	}
-+
-+	spin_lock_irq (&dev->lock);
-+	value = -EINVAL;
-+	if (dev->buf)
-+		goto fail;
-+	dev->buf = kbuf;
-+
-+	/* full or low speed config */
-+	dev->config = (void *) kbuf;
-+	total = le16_to_cpup (&dev->config->wTotalLength);
-+	if (!is_valid_config (dev->config) || total >= length)
-+		goto fail;
-+	kbuf += total;
-+	length -= total;
-+
-+	/* optional high speed config */
-+	if (kbuf [1] == USB_DT_CONFIG) {
-+		dev->hs_config = (void *) kbuf;
-+		total = le16_to_cpup (&dev->hs_config->wTotalLength);
-+		if (!is_valid_config (dev->hs_config) || total >= length)
-+			goto fail;
-+		kbuf += total;
-+		length -= total;
-+	}
-+
-+	/* could support multiple configs, using another encoding! */
-+
-+	/* device descriptor (tweaked for paranoia) */
-+	if (length != USB_DT_DEVICE_SIZE)
-+		goto fail;
-+	dev->dev = (void *)kbuf;
-+	if (dev->dev->bLength != USB_DT_DEVICE_SIZE
-+			|| dev->dev->bDescriptorType != USB_DT_DEVICE
-+			|| dev->dev->bNumConfigurations != 1)
-+		goto fail;
-+	dev->dev->bNumConfigurations = 1;
-+	dev->dev->bcdUSB = __constant_cpu_to_le16 (0x0200);
-+
-+	/* triggers gadgetfs_bind(); then we can enumerate. */
-+	spin_unlock_irq (&dev->lock);
-+	value = usb_gadget_register_driver (&gadgetfs_driver);
-+	if (value != 0) {
-+		kfree (dev->buf);
-+		dev->buf = 0;
-+	} else {
-+		/* at this point "good" hardware has for the first time
-+		 * let the USB the host see us.  alternatively, if users
-+		 * unplug/replug that will clear all the error state.
-+		 *
-+		 * note:  everything running before here was guaranteed
-+		 * to choke driver model style diagnostics.  from here
-+		 * on, they can work ... except in cleanup paths that
-+		 * kick in after the ep0 descriptor is closed.
-+		 */
-+		fd->f_op = &ep0_io_operations;
-+		value = len;
-+	}
-+	return value;
-+
-+fail:
-+	spin_unlock_irq (&dev->lock);
-+	pr_debug ("%s: %s fail %d, %p\n", shortname, __FUNCTION__, value, dev);
-+	kfree (dev->buf);
-+	dev->buf = 0;
-+	return value;
-+}
-+
-+static int
-+dev_open (struct inode *inode, struct file *fd)
-+{
-+	struct dev_data		*dev = inode->u.generic_ip;
-+	int			value = -EBUSY;
-+
-+	if (dev->state == STATE_DEV_DISABLED) {
-+		dev->ev_next = 0;
-+		dev->state = STATE_OPENED;
-+		fd->private_data = dev;
-+		get_dev (dev);
-+		value = 0;
-+	}
-+	return value;
-+}
-+
-+static struct file_operations dev_init_operations = {
-+	.owner =	THIS_MODULE,
-+	.open =		dev_open,
-+	.write =	dev_config,
-+	.fasync =	ep0_fasync,
-+	.ioctl =	dev_ioctl,
-+	.release =	dev_release,
-+};
-+
-+/*----------------------------------------------------------------------*/
-+
-+/*
-+ * implementation for 2.4 uses character special files
-+ *  ep0/device file	MKDEV (c_major, 0)
-+ *  first data ep	MKDEV (c_major, 1)
-+ *  second data ep	MKDEV (c_major, 2)
-+ *  ...
-+ *
-+ *  FIXME can do it as a real filesystem on 2.4 too, without libfs
-+ */
-+static int c_major = 240;	/* 240 is local/experimental */
-+MODULE_PARM (c_major, "i");
-+MODULE_PARM_DESC (c_major, "major number for char special files");
-+
-+static int gadget_open (struct inode *ino, struct file *fp)
-+{
-+	int			num = minor (ino->i_rdev);
-+	struct dev_data		*dev;
-+	struct file_operations	*ops;
-+
-+	/* ep0 file, "/dev/gadget/$CHIP" */
-+	if (num == 0) {
-+		int		status;
-+
-+		if (the_device != 0)
-+			return -EBUSY;
-+		the_device = dev_new ();
-+		if (the_device == 0)
-+			return -ENOMEM;
-+
-+		dev = the_device;
-+		ino->u.generic_ip = dev;
-+		ops = &dev_init_operations;
-+		fp->f_op = ops;
-+
-+		status = ops->open (ino, fp);
-+		if (status < 0) {
-+			put_dev (dev);
-+			the_device = 0;
-+		}
-+		return status;
-+
-+	/* ep files, "/dev/gadget/$ENDPOINT" */
-+	} else {
-+		struct list_head	*entry;
-+		struct ep_data		*data;
-+
-+		/* unavailable till device is initted */
-+		dev = the_device;
-+		if (dev == 0)
-+			return -ENODEV;
-+
-+		/* order in controller's name listing matters! */
-+		list_for_each (entry, &dev->epfiles) {
-+			if (--num == 0)
-+				goto found;
-+		}
-+		return -ENODEV;
-+found:
-+		data = list_entry (entry, struct ep_data, epfiles);
-+		ino->u.generic_ip = data;
-+		ops = &ep_config_operations;
-+		fp->f_op = ops;
-+
-+		return ops->open (ino, fp);
-+	}
-+}
-+
-+static struct file_operations gadget_fops = {
-+	.owner =	THIS_MODULE,
-+	.open =		gadget_open,
-+};
-+
-+/*----------------------------------------------------------------------*/
-+
-+static int __init init (void)
-+{
-+	int status;
-+
-+	status = register_chrdev (c_major, shortname, &gadget_fops);
-+	if (status < 0) {
-+		printk (KERN_WARNING "%s: can't get major %d\n",
-+			shortname, c_major);
-+		return status;
-+	}
-+
-+	/* dynamic assignment */
-+	if (c_major == 0)
-+		c_major = status;
-+	status = 0;
-+
-+	pr_info ("%s: using char major %d\n", shortname, c_major);
-+
-+	if (status == 0)
-+		pr_info ("%s: %s, version " DRIVER_VERSION "\n",
-+			shortname, driver_desc);
-+	return status;
-+}
-+module_init (init);
-+
-+static void __exit cleanup (void)
-+{
-+	pr_debug ("unregister %s\n", shortname);
-+	unregister_chrdev (c_major, shortname);
-+}
-+module_exit (cleanup);
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/n9604.c kernel/drivers/usb/gadget/n9604.c
---- /tmp/kernel/drivers/usb/gadget/n9604.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/n9604.c	2005-04-22 17:53:19.461535120 +0200
-@@ -0,0 +1,1088 @@
-+/*
-+ * National 9603/4 USB Device Controller driver
-+ * Copyright (C) 2004 Technical Solutions Inc. (support@techsol.ca)
-+ * ported from : The Goku-S driver
-+ * Copyright (C) 2003 MontaVista Software (source@mvista.com)
-+ *
-+ * This file is licensed under the terms of the GNU General Public
-+ * License version 2.  This program is licensed "as is" without any
-+ * warranty of any kind, whether express or implied.
-+ */
-+
-+/*
-+ * This device has ep0 and six semi-configurable bulk/interrupt endpoints.
-+ *
-+ *  - Endpoint numbering is fixed:
-+ *  Endpoint 0: ep0
-+ *  Endpoint 1: ep1in  (tx)
-+ *  Endpoint 2: ep2out (rx)
-+ *  Endpoint 3: ep3in  (tx)
-+ *  Endpoint 4: ep4out (rx)
-+ *  Endpoint 5: ep5in  (tx)
-+ *  Endpoint 6: ep6out (rx)
-+ */
-+
-+/*
-+ * The ep->stage information refers to the state of a setup transaction
-+ *
-+ * state 0: no setup packet has been received
-+ * state 1: setup packet has been received
-+ * state 2: data has been sent/received
-+ * state 3: ZLP has been received/sent
-+ */
-+
-+#include <linux/config.h>
-+#include <linux/kernel.h>
-+#include <linux/module.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/usb_ch9.h>
-+#include <linux/usb_gadget.h>
-+
-+#include <asm/byteorder.h>
-+#include <asm/io.h>
-+#include <asm/irq.h>
-+#include <asm/system.h>
-+#include <asm/unaligned.h>
-+
-+#include "n9604.h"
-+#include "n9604regs.h"
-+
-+inline void Flush_and_enable(u8 control_reg) {
-+	write_9604(RXC_FLUSH, control_reg);
-+	while (read_9604(control_reg) & RXC_FLUSH);
-+	write_9604(RXC_RX_EN, control_reg);
-+}
-+inline void Flush(u8 control_reg) {
-+	write_9604(RXC_FLUSH, control_reg);
-+	while (read_9604(control_reg) & RXC_FLUSH);
-+}
-+
-+#define	DRIVER_DESC		"N9604 USB Device Controller"
-+#define	DRIVER_VERSION		"29-Oct 2004"
-+
-+static const char driver_name [] = "n9604_udc";
-+static const char driver_desc [] = DRIVER_DESC;
-+
-+MODULE_AUTHOR("support@techsol.ca");
-+MODULE_DESCRIPTION(DRIVER_DESC);
-+MODULE_LICENSE("GPL");
-+
-+static void nuke(struct n9604_ep *ep, int status);
-+inline void send_zero_length(int endpoint, struct n9604_udc *dev);
-+
-+u8 * USBN9604_Offset; //device virtual address
-+
-+/* FIXME all the IRQ stuff is board-specific
-+ */
-+
-+#define h7201_readl	readl
-+#define h7201_writel	writel
-+
-+#define ETHER_IRQ_IP_OFFSET	0
-+#define ETHER_IRQ_BIT_POS	0
-+#define ETHER_IRQ_IM_OFFSET	0
-+
-+#define IRQ_GPIOC		-1
-+
-+#define USBD_ENABLE_IRQ {h7201_writel( h7201_readl(ETHER_IRQ_IP_OFFSET) | (1 << ETHER_IRQ_BIT_POS), ETHER_IRQ_IP_OFFSET);  h7201_writel( h7201_readl(ETHER_IRQ_IM_OFFSET) |  (1 << ETHER_IRQ_BIT_POS), ETHER_IRQ_IM_OFFSET);}
-+#define USBD_DISABLE_IRQ h7201_writel( h7201_readl(ETHER_IRQ_IM_OFFSET) & ~(1 << ETHER_IRQ_BIT_POS), ETHER_IRQ_IM_OFFSET);
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+//enable an end point, of description desc
-+static int n9604_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) {
-+	struct n9604_udc *dev;
-+	struct n9604_ep  *ep;
-+	u16              max;
-+
-+	ep = container_of(_ep, struct n9604_ep, ep);
-+
-+	if (!_ep || !desc || ep->desc || desc->bDescriptorType != USB_DT_ENDPOINT)
-+		return -EINVAL;
-+
-+	dev = ep->dev;
-+	if (!ep->num) 
-+		return -EINVAL;
-+	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
-+		return -ESHUTDOWN;
-+	if (ep->num && !(desc->bEndpointAddress & 0x0f))
-+		return -EINVAL;
-+	
-+	switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
-+		case USB_ENDPOINT_XFER_BULK:
-+		case USB_ENDPOINT_XFER_INT:
-+			break;
-+		default:
-+			return -EINVAL;
-+	}
-+
-+	write_9604((ep->numActual & EPC_EP_MASK) | EPC_EP_EN | (EPC_ISO * ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_ISOC)), ep->control);
-+	if (ep->is_in)
-+		Flush(ep->command);
-+	else
-+		Flush_and_enable(ep->command);
-+	
-+	max = le16_to_cpu(get_unaligned(&desc->wMaxPacketSize));
-+	ep->ep.maxpacket = min_t(u16, max, MAX_FIFO_SIZE);
-+	ep->desc = desc;
-+	
-+	return 0;
-+}
-+
-+static int n9604_ep_disable(struct usb_ep *_ep)//ep > 0
-+{
-+	struct n9604_ep		*ep;
-+	struct n9604_udc	*dev;
-+	unsigned long		flags;
-+
-+	ep = container_of(_ep, struct n9604_ep, ep);
-+
-+	if (!_ep || !ep->desc)
-+		return -ENODEV;
-+	dev = ep->dev;
-+
-+	spin_lock_irqsave(&dev->lock, flags);
-+	nuke(ep, -ESHUTDOWN);
-+	write_9604(0, ep->command);
-+	ep->desc = NULL;
-+	spin_unlock_irqrestore(&dev->lock, flags);
-+
-+	return 0;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static struct usb_request *
-+n9604_alloc_request(struct usb_ep *_ep, int gfp_flags)
-+{
-+	struct n9604_request	*req;
-+
-+	if (!_ep)
-+		return 0;
-+	req = kmalloc(sizeof *req, gfp_flags);
-+	if (!req)
-+		return 0;
-+
-+	memset(req, 0, sizeof *req);
-+	INIT_LIST_HEAD(&req->queue);
-+	return &req->req;
-+}
-+
-+static void
-+n9604_free_request(struct usb_ep *_ep, struct usb_request *_req)
-+{
-+	struct n9604_request	*req;
-+
-+	if (!_ep || !_req)
-+		return;
-+
-+	req = container_of(_req, struct n9604_request, req);
-+	WARN_ON(!list_empty(&req->queue));
-+	kfree(req);
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void done(struct n9604_ep *ep, struct n9604_request *req, int status);
-+
-+static inline int
-+write_packet(struct n9604_ep *ep, u8 *buf, struct n9604_request *req)
-+{
-+	unsigned        written_length, desired_length, available_length, maximum_length, flags, loop_length;
-+
-+	u8 fifo = ep->fifo;
-+	u8 command = ep->command;
-+	u8 status = ep->status;
-+	if (!ep->num) {
-+		fifo = TXD0;
-+		command = TXC0;
-+		status = TXS0;
-+	}
-+	
-+	if (read_9604(command) & TXC_TX_EN)
-+		return -EBUSY;
-+	ep->packets++;
-+	
-+	desired_length = req->req.length - req->req.actual;
-+	available_length = read_9604(status) & TXS_TCOUNT_MASK;//might be greater
-+	written_length = 0;
-+	if (ep->num)
-+		maximum_length = MAX_FIFO_SIZE;
-+	else
-+		maximum_length = MAX_EP0_SIZE;
-+
-+	while ((loop_length = min(min(available_length, desired_length), maximum_length))) {
-+		int i = loop_length;
-+		while (i) { write_9604(*buf++,fifo); i--; }
-+		written_length += loop_length;
-+		desired_length -= loop_length;
-+		maximum_length -= loop_length;
-+		if (desired_length && maximum_length)//check if really need to read the chip again
-+			available_length = (read_9604(status) & TXS_TCOUNT_MASK);
-+	}
-+	
-+	req->req.actual += written_length;
-+
-+	flags = TXC_TX_EN;
-+	if (ep->num)
-+		flags |= TXC_LAST;
-+	if (ep->toggle)
-+		flags |= TXC_TOGGLE;
-+	write_9604(flags, command);
-+	ep->toggle = !(ep->toggle);
-+	if (!written_length) req->req.zero = 0;//just wrote zero bytes, there is no more need for req.zero 
-+	return written_length;
-+}       
-+
-+// return:  0 = still running, 1 = completed, negative = errno
-+static int write_fifo(struct n9604_ep *ep, struct n9604_request *req)
-+{
-+	struct n9604_udc *dev = ep->dev;
-+	u8              *buf;
-+	unsigned        count;
-+	int             is_last;
-+
-+	buf = req->req.buf + req->req.actual;
-+	prefetch(buf);
-+	
-+	dev = ep->dev;
-+
-+	count = write_packet(ep, buf, req);
-+	if (count < 0)
-+		return count;
-+	
-+	/* last packet often short (sometimes a zlp, especially on ep0) */
-+	if ((req->req.length != req->req.actual) || req->req.zero)
-+		is_last = 0;
-+	else
-+		is_last = 1;
-+	
-+	/* requests complete when all IN data is in the FIFO,
-+	 * or sometimes later, if a zlp was needed.
-+	 */
-+	if (is_last) {
-+		done(ep, req, 0);
-+		return 1;
-+	}
-+	return 0;
-+}
-+
-+static inline void pio_irq_enable(struct n9604_ep *ep);
-+
-+static int read_fifo(struct n9604_ep *ep, struct n9604_request *req)
-+{
-+	u32                     size;
-+	u8                      *buf;
-+	int			bufferspace_available, fifospace_left, num_bytes_read;
-+	int 			fifo, status;
-+	ep->packets++;
-+	if (!ep->num) { 
-+		fifo = RXD0;
-+		status = RXS0;
-+	} else {
-+		fifo = ep->fifo;
-+		status = ep->status;
-+	}
-+	num_bytes_read = 0;
-+	buf = req->req.buf + req->req.actual;
-+	bufferspace_available = req->req.length - req->req.actual;
-+	size = read_9604(status) & (RXS_RCOUNTMASK | RXS_RX_ERR);//number of bytes ready to be read (15 if greater than 15)
-+	if (ep->num && (size & RXS_RX_ERR)) {
-+		ERROR(ep->dev, "DATA ERROR!!!! on ep%d\nFlushing Fifo", ep->num);
-+		Flush_and_enable(ep->command);
-+		goto leave;
-+	}
-+	size = size & ~RXS_RX_ERR;//clear the bit
-+	if (ep->num)	fifospace_left = MAX_FIFO_SIZE;
-+	else		fifospace_left = MAX_EP0_SIZE;
-+loop:
-+	/* read all bytes from this packet */
-+	while (size-- != 0) {
-+		u8 byte = read_9604(fifo);
-+		if (unlikely(bufferspace_available == 0)) {
-+			/* this happens when the driver's buffer
-+			 * is smaller than what the host sent.
-+			 * discard the extra data in this packet.
-+			 */
-+			done(ep, req, -EOVERFLOW);
-+			return 1;
-+		} else {
-+			*buf++ = byte;
-+			bufferspace_available--;
-+			fifospace_left--;
-+			num_bytes_read++;
-+		}
-+	}
-+	if ((size = (read_9604(status) & RXS_RCOUNTMASK))) {
-+		goto loop;//since there is more data
-+	}
-+	/* completion */
-+	req->req.actual = req->req.actual + num_bytes_read;
-+	if (fifospace_left || req->req.actual == req->req.length) {
-+		done(ep, req, 0);
-+		return 1;
-+	}
-+leave:
-+	pio_irq_enable(ep);//turn the interrupt back on
-+	return 0;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static inline void
-+pio_irq_enable(struct n9604_ep *ep)
-+{
-+	if (ep->is_in) 
-+		write_9604(read_9604(TXMSK) | 1 << ep->fifoNum | 0x10 << ep->fifoNum, TXMSK);
-+	else {
-+		u8 command = ep->command;
-+		if (!ep->num) command = RXC0;
-+		write_9604(read_9604(RXMSK) | 1 << ep->fifoNum | 0x10 << ep->fifoNum, RXMSK);
-+		write_9604(RXC_RX_EN | RXC_RFWL0 | RXC_RFWL1, command);
-+	}
-+}
-+
-+static inline void
-+pio_irq_disable(struct n9604_ep *ep)//epnum != 0
-+{
-+	if (ep->is_in)
-+		write_9604(read_9604(TXMSK) & ~(1 << ep->fifoNum) & ~(0x10 << ep->fifoNum), TXMSK);
-+	else
-+		write_9604(read_9604(RXMSK) & ~(1 << ep->fifoNum) & ~(0x10 << ep->fifoNum), RXMSK);
-+}
-+
-+static int request_voodoo = 0;//number of bytes the host requested
-+
-+static inline void
-+pio_advance(struct n9604_ep *ep)
-+{
-+	struct n9604_request     *req;
-+
-+	if (list_empty (&ep->queue)) {
-+		if (!ep->num) {
-+			if (ep->is_in && (ep->stage == 2)) {
-+				ep->is_in = 0;//switch modes
-+				Flush_and_enable(RXC0);//needed to receive a ZLP after tx
-+				ep->stage++;//and bump the stage number 
-+			} else if (ep->stage == 3) {
-+				ep->stage = 0;
-+			}
-+		}
-+		return;
-+	}
-+	req = list_entry(ep->queue.next, struct n9604_request, queue);
-+	(ep->is_in ? write_fifo : read_fifo)(ep, req);
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void * n9604_alloc_buffer(struct usb_ep *_ep, unsigned bytes, dma_addr_t *dma, int  gfp_flags)
-+{
-+	return kmalloc(bytes, gfp_flags);
-+}
-+
-+static void n9604_free_buffer(struct usb_ep *_ep, void *buf, dma_addr_t dma, unsigned bytes)
-+{
-+	kfree (buf);
-+}
-+
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void
-+done(struct n9604_ep *ep, struct n9604_request *req, int status)
-+{
-+	struct n9604_udc         *dev;
-+
-+	list_del_init(&req->queue);
-+	ep->queue_active--;
-+	
-+	if (req->req.status == -EINPROGRESS)
-+		req->req.status = status;
-+	else
-+		status = req->req.status;
-+	
-+	dev = ep->dev;
-+	
-+	/* don't modify queue heads during completion callback */
-+	if (ep->num)
-+		pio_irq_disable(ep);
-+	else if (!ep->nuking) {
-+		ep->stage++;
-+		ep->toggle = 1;//other endpoints stay in their flipping mode between transactions
-+		if (ep->stage == 2) {//we are in stage 2 now
-+			if (!ep->is_in) {
-+				ep->is_in = 1;//switch modes
-+				request_voodoo = 1;//prevents n9604_queue from calling us again before doing anything
-+				send_zero_length(0, dev);
-+			} else {//we have to receive a ZLP
-+				//this will happen when the tx is complete, the pio_advance fcn will activate it for us
-+			}
-+		}
-+	}
-+		
-+	req->req.complete(&ep->ep, &req->req);
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int
-+n9604_queue(struct usb_ep *_ep, struct usb_request *_req, int gfp_flags)
-+{
-+	struct n9604_request	*req;
-+	struct n9604_ep		*ep;
-+	struct n9604_udc	*dev;
-+	unsigned long		flags;
-+	int			status;
-+
-+	req = container_of(_req, struct n9604_request, req);
-+	if (unlikely(!_req || !_req->complete
-+			|| !_req->buf || !list_empty(&req->queue)))
-+		return -EINVAL;
-+	ep = container_of(_ep, struct n9604_ep, ep);
-+	if (unlikely(!_ep || (!ep->desc && ep->num != 0)))
-+		return -EINVAL;
-+	dev = ep->dev;
-+	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
-+		return -ESHUTDOWN;
-+	}
-+	if (ep->nuking)
-+		return -ESHUTDOWN;
-+
-+	spin_lock_irqsave(&dev->lock, flags);
-+
-+	ep->queue_reqs++;
-+	ep->queue_active++;
-+
-+	_req->status = -EINPROGRESS;
-+	_req->actual = 0;
-+
-+	/* for ep0 IN without premature status, zlp is required and
-+	 * writing EOP starts the status stage (OUT).
-+	 */
-+	if (ep->num == 0) {
-+		if ((request_voodoo > _req->length) && !(_req->length % MAX_EP0_SIZE) && (_req->length != 0)) {
-+			_req->zero = 1;
-+		}
-+		if (!request_voodoo && !ep->is_in) {//this is a zero length request
-+			spin_unlock_irqrestore(&dev->lock, flags);//David
-+			done(ep, req, 0);//this doesn't check if the list is empty (probably not an issue)
-+			return 0;	//shouldn't this be handled by the rx irq fcn, and passed to pio_advance
-+		}//that may conflict with the voodoo stuff, maybe best to leave it
-+	}
-+	
-+	/* kickstart this i/o queue? */
-+	status = 0;
-+	if (list_empty(&ep->queue) && ep->is_in) {
-+		status = write_fifo(ep, req);
-+		if (status == -EBUSY)
-+			;//we should queue up the request then
-+		else {
-+			if (status != 0) {
-+				if (status > 0)
-+					status = 0;
-+				req = 0;
-+			}
-+		}
-+	} /* else pio or dma irq handler advances the queue. */
-+
-+	if (req != 0) {
-+		list_add_tail(&req->queue, &ep->queue);
-+		pio_irq_enable(ep);
-+	}
-+
-+	spin_unlock_irqrestore(&dev->lock, flags);
-+	return status;
-+}
-+
-+/* dequeue ALL requests */
-+static void nuke(struct n9604_ep *ep, int status)
-+{
-+	struct n9604_request	*req;
-+	
-+	if (list_empty(&ep->queue))
-+		return;
-+	ep->nuking = 1;
-+	while (!list_empty(&ep->queue)) {
-+		req = list_entry(ep->queue.next, struct n9604_request, queue);
-+		done(ep, req, status);
-+	}
-+	ep->nuking = 0;
-+}
-+
-+/* dequeue JUST ONE request */
-+static int n9604_dequeue(struct usb_ep *_ep, struct usb_request *_req)
-+{
-+	struct n9604_request	*req;
-+	struct n9604_ep		*ep;
-+	struct n9604_udc	*dev;
-+	unsigned long		flags;
-+
-+	ep = container_of(_ep, struct n9604_ep, ep);
-+	if (!_ep || !_req || (!ep->desc && ep->num != 0))
-+		return -EINVAL;
-+	dev = ep->dev;
-+
-+	if (!dev->driver)
-+		return -ESHUTDOWN;
-+
-+	spin_lock_irqsave(&dev->lock, 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) {
-+		spin_unlock_irqrestore (&dev->lock, flags);
-+		return -EINVAL;
-+	}
-+
-+	spin_unlock_irqrestore(&dev->lock, flags);
-+
-+	return req ? 0 : -EOPNOTSUPP;
-+}
-+
-+static int n9604_clear_halt(struct usb_ep *_ep) {
-+	struct n9604_ep *ep;
-+	ep = container_of (_ep, struct n9604_ep, ep);
-+
-+	write_9604(read_9604(ep->control) & ~EPC_STALL, ep->control);
-+	pio_advance(ep);
-+	return 0;
-+}
-+
-+static int n9604_set_halt(struct usb_ep *_ep, int value) {
-+	struct n9604_ep *ep;
-+	unsigned long   flags;
-+	int             retval = 0;
-+
-+	if (!_ep) {
-+		retval = -ENODEV; goto exit;
-+	}
-+	ep = container_of (_ep, struct n9604_ep, ep);
-+
-+	if (ep->num == 0) {//is this valid?
-+		if (!value) {
-+			 retval = -EINVAL; goto exit; }
-+
-+	/* don't change EPxSTATUS_EP_INVALID to READY */
-+	} else if (!ep->desc) {
-+		retval = -EINVAL; goto exit;
-+	}
-+
-+	spin_lock_irqsave(&ep->dev->lock, flags);
-+	if (!list_empty(&ep->queue))
-+		retval = -EAGAIN;
-+	else if (!value)
-+		n9604_clear_halt(_ep);
-+	else {
-+		write_9604(read_9604(ep->control) | EPC_STALL, ep->control);
-+	}
-+	spin_unlock_irqrestore(&ep->dev->lock, flags);
-+exit:
-+	return retval;
-+}
-+
-+static int n9604_fifo_status(struct usb_ep *_ep) {//not implemented
-+	return -1;
-+}
-+
-+static void n9604_fifo_flush(struct usb_ep *_ep) {//not implemented
-+	struct n9604_ep *ep;
-+	ep = container_of (_ep, struct n9604_ep, ep);
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static struct usb_ep_ops n9604_ep_ops = {
-+	.enable         = n9604_ep_enable,
-+	.disable        = n9604_ep_disable,
-+
-+	.alloc_request  = n9604_alloc_request,//io request objects called struct usb_request
-+	.free_request   = n9604_free_request,
-+
-+	.alloc_buffer   = n9604_alloc_buffer,
-+	.free_buffer    = n9604_free_buffer,
-+
-+	.queue          = n9604_queue,//submit a struct usb_request object to an endpoint
-+	.dequeue        = n9604_dequeue,
-+
-+	.set_halt       = n9604_set_halt,//halts an endpoint
-+	.fifo_status    = n9604_fifo_status,//bytes in FIFO + data ready to go in FIFO
-+	.fifo_flush     = n9604_fifo_flush,//flush all the data, endpoint is probably been reconfigured
-+};
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int n9604_get_frame(struct usb_gadget *_gadget)
-+{
-+	return -EOPNOTSUPP;
-+}
-+
-+static const struct usb_gadget_ops n9604_ops = {
-+	.get_frame	= n9604_get_frame,
-+};
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void udc_reinit (struct n9604_udc *dev)
-+{
-+	static char *names [] = { "ep0", "ep1in", "ep2out", "ep3in", "ep4out", "ep5in", "ep6out" };
-+	unsigned i;
-+
-+	INIT_LIST_HEAD (&dev->gadget.ep_list);
-+	dev->gadget.ep0 = &dev->ep [0].ep;
-+	dev->gadget.speed = USB_SPEED_UNKNOWN;
-+	dev->irqs = 0;
-+	dev->configured = 0;
-+
-+	//for (i = 0; i < 7; i++) {
-+	for (i = 0; i < ARRAY_SIZE(names); i++) {
-+		struct n9604_ep	*ep = &dev->ep[i];
-+		ep->num = i;
-+		ep->numActual = i; 
-+		ep->ep.name = names[i];
-+		ep->irqs = 0;
-+		if (i) {
-+			ep->fifo = (i * 4) + RXD0;	//each FIFO address is 4 bytes away.  TXD0 is the first
-+			ep->control = ep->fifo - 1;
-+			ep->status = ep->fifo + 1;
-+			ep->command = ep->fifo + 2;
-+			Flush(ep->command);//flush any data in the fifo//we don't care about the previous state
-+			read_9604(ep->status);
-+			ep->ep.maxpacket = MAX_FIFO_SIZE;
-+		} else {//were are endpoint 0
-+			ep->fifo = ep->control = ep->status = ep->command = 0xff;//this should force an error
-+										//we need to do this since we don't know if 
-+										//this is tx or rx
-+			read_9604(TXS0);
-+			Flush(TXC0);
-+			Flush(RXC0);//we could potentially (probably) overwriting a pending setup packet
-+			if (ep->stage)//if we get a setup packet before we have a chance to finish the reset we have a problem
-+				read_9604(RXS0);//fix this by sending stalls or something
-+			ep->stage = 0;
-+			ep->ep.maxpacket = MAX_EP0_SIZE;
-+		}
-+		ep->is_in = i % 2;
-+		ep->fifoNum = (i + ep->is_in) / 2;//ignored for endpoint 0
-+		ep->ep.ops = &n9604_ep_ops;
-+		list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
-+		ep->dev = dev;
-+		INIT_LIST_HEAD (&ep->queue);
-+		ep->nuking=0;
-+		ep->queue_reqs = 0;
-+		ep->queue_active = 0;
-+		ep->packets = 0;
-+		ep->desc = 0;
-+		ep->irqs = 0;
-+	}
-+
-+	list_del_init (&dev->ep[0].ep.ep_list);
-+
-+	write_9604(~WKUP_PNDUSB & ~WKUP_PNDUC & read_9604(WKUP), WKUP);//clear the bits, we've done a reset
-+	write_9604(FAR_AD_EN, FAR);//enable the chip to answer requests//address 0
-+	dev->address = 0;
-+	write_9604(0, EPC0);//clear the control register
-+	write_9604(NFSR_NodeOperational, NFSR);//we're going for gold
-+}
-+
-+static void udc_reset(struct n9604_udc *dev)
-+{
-+	//USBD_DISABLE_IRQ; This disables all interrupts sharing that line
-+	write_9604(MCNTRL_SRST,MCNTRL);//software reset -- this also prevents pullup
-+	write_9604(0x00, MAMSK); //disable interrupts
-+}
-+
-+
-+
-+static void udc_enable(struct n9604_udc *dev)
-+{
-+	udc_reset(dev); //this is to prevent a pullup resistor
-+	udc_reinit (dev);
-+
-+	dev->gadget.speed = USB_SPEED_FULL;
-+
-+	// enable ep0 interrupts
-+	dev->ep[0].is_in = 0;
-+	
-+	write_9604(MAMSK_WARN | MAMSK_ALT | MAMSK_TX_EV | MAMSK_RX_EV | MAMSK_INTR, MAMSK);//for now we turn it all on, except frames & ULD & NAK
-+	write_9604(ALTMSK_RESET, ALTMSK);//just turn on reset
-+	write_9604(0x11, TXMSK);
-+	write_9604(0x11, RXMSK);
-+	write_9604(0x0, NAKMSK);
-+	write_9604(0x0, FWMSK);
-+	write_9604(MCNTRL_NAT | MCNTRL_INTOC_ActHigh, MCNTRL);//this activates the pull-up and turns on interrupts
-+	USBD_ENABLE_IRQ;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* keeping it simple:
-+ * - one bus driver, initted first;
-+ * - one function driver, initted second
-+ */
-+
-+static struct n9604_udc        *the_controller;
-+
-+/* 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 n9604_udc	*dev = the_controller;
-+	int			retval;
-+
-+	if (!driver
-+			|| driver->speed != USB_SPEED_FULL
-+			|| !driver->bind
-+			|| !driver->unbind
-+			|| !driver->disconnect
-+			|| !driver->setup)
-+		return -EINVAL;
-+	if (!dev)
-+		return -ENODEV;
-+	if (dev->driver)
-+		return -EBUSY;
-+
-+	/* hook up the driver */
-+	dev->driver = driver;
-+	retval = driver->bind(&dev->gadget);
-+	if (retval) {
-+		dev->driver = 0;
-+		return retval;
-+	}
-+
-+	/* then enable host detection and ep0; and we're ready
-+	 * for set_configuration as well as eventual disconnect.
-+	 */
-+	udc_enable(dev);
-+
-+	return 0;
-+}
-+EXPORT_SYMBOL(usb_gadget_register_driver);
-+
-+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
-+{
-+	struct n9604_udc	*dev = the_controller;
-+	unsigned long	flags;
-+	int i;
-+
-+	if (!dev)
-+		return -ENODEV;
-+	if (!driver || driver != dev->driver)
-+		return -EINVAL;
-+
-+	spin_lock_irqsave(&dev->lock, flags);
-+	dev->driver = 0;
-+	
-+	udc_reset(dev);//reset & diable irqs
-+	for (i = 0; i < ARRAY_SIZE(dev->ep); i++)
-+		nuke(&dev->ep [i], -ESHUTDOWN);
-+	spin_unlock_irqrestore(&dev->lock, flags);
-+
-+	if (dev->gadget.speed != USB_SPEED_UNKNOWN)
-+		driver->disconnect(&dev->gadget);
-+	driver->unbind(&dev->gadget);
-+
-+	return 0;
-+}
-+EXPORT_SYMBOL(usb_gadget_unregister_driver);
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+inline u8 tx_ev_irq(struct n9604_udc *dev) {
-+	u8      mask;
-+
-+	mask = read_9604(TXEV) & read_9604(TXMSK);
-+
-+	if (mask & TXEV_FIFO0) {
-+		write_9604(0, EPC0);//make sure we are not stalled, & not using the default address
-+		read_9604(TXS0);//should really check for error conditions
-+		dev->ep[0].irqs++;
-+		pio_advance(&dev->ep[0]);
-+	}
-+	if (mask & TXEV_FIFO1) {
-+		read_9604(TXS1);
-+		dev->ep[1].irqs++;
-+		pio_advance(&dev->ep[1]);
-+	}
-+	if (mask & TXEV_FIFO2) {
-+		read_9604(TXS2);
-+		dev->ep[3].irqs++;
-+		pio_advance(&dev->ep[3]);
-+	}
-+	if (mask & TXEV_FIFO3) {
-+		read_9604(TXS3);
-+		dev->ep[5].irqs++;
-+		pio_advance(&dev->ep[5]);
-+	}
-+	return mask;
-+}
-+
-+static void my_req_complete(struct usb_ep *_ep, struct usb_request *req) {//this was for the setup packet, but I guess I could use it for anything
-+	n9604_free_buffer(_ep, req->buf, req->dma, req->length);
-+	n9604_free_request(_ep, req);
-+}
-+
-+inline void send_dummy_packet(int endpoint, struct n9604_udc *dev, int length) {
-+	struct usb_request *my_req;
-+	my_req = n9604_alloc_request(&dev->ep[endpoint].ep, GFP_ATOMIC);
-+	my_req->length = length;
-+	my_req->buf = n9604_alloc_buffer(&dev->ep[endpoint].ep, length, &my_req->dma, GFP_ATOMIC);
-+	my_req->complete = my_req_complete;
-+	n9604_queue(&dev->ep[endpoint].ep, my_req, GFP_ATOMIC);
-+}
-+
-+inline void send_zero_length(int endpoint, struct n9604_udc *dev) {
-+	send_dummy_packet(endpoint, dev, 0);
-+}
-+
-+inline void rx_ev_irq(struct n9604_udc *dev) {
-+	u8	mask;
-+	struct n9604_ep *ep;
-+
-+	mask = read_9604(RXEV) & read_9604(RXMSK);
-+
-+	if (mask & RXEV_FIFO0) {
-+		static int read_mode = 0;
-+		u8 rxs_mask = read_9604(RXS0);
-+		ep = &dev->ep[0];
-+		ep->irqs++;
-+		if (rxs_mask & RXS_SETUP) {
-+			struct usb_ctrlrequest ctrl;
-+			ep->packets++;
-+			write_9604(0x40, ALTMSK);//someone is talking to us.  Make sure we can be reset if we lose this communication
-+			ep->stage = 1;
-+			rxs_mask = read_9604(RXS0);//2nd read (1st one is for zero length packet)
-+			ctrl.bRequestType = read_9604(RXD0);
-+			ctrl.bRequest = read_9604(RXD0);
-+			ctrl.wValue = read_9604(RXD0) + (read_9604(RXD0) << 8);
-+			ctrl.wIndex = read_9604(RXD0) + (read_9604(RXD0) << 8);
-+			ctrl.wLength = read_9604(RXD0) + (read_9604(RXD0) << 8);
-+			ep->toggle = 1;
-+			request_voodoo = ctrl.wLength;
-+			if (ctrl.bRequestType & 0x80) {//This is an IN transaction
-+				ep->is_in = 1;//David: is this correct for both cases//check with n9604_queue
-+				read_mode = 0;
-+				if (ctrl.wLength) {//should be followed by ZLP out packet
-+				} else {//host expects ZLP out packet
-+					ep->stage = 2;
-+				}
-+			} else {//This is an out transaction
-+				if (ctrl.wLength) {
-+					ep->is_in = 0;
-+					read_mode = 1;
-+				} else {//host expects ZLP in packet
-+					read_mode = 0;
-+					ep->stage = 2;
-+					ep->is_in = 1;
-+				}
-+			}
-+			switch (ctrl.bRequest) {
-+				case USB_REQ_SET_ADDRESS:
-+					write_9604(EPC_DEF, EPC0);//we still want to respond to the default address
-+					write_9604(((dev->address = (ctrl.wValue & FAR_AD_MASK))) | FAR_AD_EN, FAR);
-+					send_zero_length(0, dev);
-+					dev->configured = 1;//we can send longer packets now :)
-+					read_9604(ALTEV);
-+					write_9604(ALTMSK_RESET, ALTMSK);//we also listen to reset requests too
-+					break;
-+				case USB_REQ_CLEAR_FEATURE:
-+					if (ctrl.wValue == 0 && ctrl.bRequestType == 2) {//endpoint halt
-+						int i;
-+						for (i = 0; i < ARRAY_SIZE(dev->ep); i++) 
-+							if ((ctrl.wIndex & 0xF) == dev->ep[i].numActual)
-+								n9604_clear_halt(&dev->ep[i].ep);
-+						send_zero_length(0, dev);
-+						break;
-+					}
-+				case USB_REQ_SET_DESCRIPTOR:
-+				case USB_REQ_SYNCH_FRAME:
-+				case USB_REQ_GET_STATUS:
-+				case USB_REQ_SET_FEATURE:
-+				case USB_REQ_SET_CONFIGURATION:
-+				case USB_REQ_GET_DESCRIPTOR:
-+				case USB_REQ_GET_CONFIGURATION:
-+				case USB_REQ_SET_INTERFACE:
-+				case USB_REQ_GET_INTERFACE:
-+				default:
-+					if (dev->driver->setup(&dev->gadget, &ctrl) < 0)//there was an error
-+						if (((ctrl.bRequestType & 0x80) && ctrl.wLength) || (!(ctrl.bRequestType & 0x80) && !ctrl.wLength))
-+							send_zero_length(0, dev);
-+			}//crtl.bRequest
-+		}//setup
-+		else if (read_mode)
-+			pio_advance(ep);
-+		else {
-+			ep->stage = 0;
-+			ep->packets++;
-+		}
-+	}//fifo 0
-+	if (mask & RXEV_FIFO1) {
-+		ep = &dev->ep[2];
-+		pio_advance(ep);
-+		ep->irqs++;
-+	}
-+	if (mask & RXEV_FIFO2) {
-+		ep = &dev->ep[4];
-+		pio_advance(ep);
-+		ep->irqs++;
-+	}
-+	if (mask & RXEV_FIFO3) {
-+		ep = &dev->ep[6];
-+		pio_advance(ep);
-+		ep->irqs++;
-+	}
-+}
-+
-+inline void alt_ev_irq(struct n9604_udc *dev) {
-+	u8      mask;
-+
-+	mask = read_9604(ALTEV) & read_9604(ALTMSK);
-+
-+	if (mask & ALTEV_EOP);
-+	if (mask & ALTEV_SD3);
-+	if (mask & ALTEV_SD5);
-+	if (mask & ALTEV_RESET) {
-+		int i;
-+		udelay(1200);//no idea why this is needed, but it makes things work
-+		write_9604(0x0, FAR);//lets not respond to any packets until we are ready
-+		write_9604(NFSR_NodeReset, NFSR);
-+		dev->driver->disconnect(&dev->gadget);
-+		for (i = 0; i < ARRAY_SIZE(dev->ep); i++)
-+			nuke(&dev->ep [i], -ESHUTDOWN);//this should be handled above by disconnect
-+		write_9604(0x00, ALTMSK);//make sure reset is turned off, or we will constantly be interrupted
-+		write_9604(0x11, TXMSK);
-+		write_9604(0x11, RXMSK);
-+		udc_reinit(dev);
-+		dev->gadget.speed = USB_SPEED_FULL;
-+		dev->ep[0].is_in = 0;
-+	}
-+	if (mask & ALTEV_RESUME); //write_9604(NFSR_NodeOperational, NFSR);
-+	if (mask & ALTEV_WKUP);//we don't really sleep
-+	if (mask & ALTEV_DMA);
-+}
-+
-+static void n9604_irq(int irq, void *_dev, struct pt_regs *r) {
-+	struct n9604_udc         *dev = _dev;
-+	u8			mask;
-+
-+	mask = read_9604(MAEV) & read_9604(MAMSK);
-+	if (!mask)
-+		return;
-+
-+	if (mask & MAEV_ALT) {
-+		alt_ev_irq(dev);
-+		mask = read_9604(MAEV) & read_9604(MAMSK);//force a re-read of the current pending interrupts
-+	}
-+	if (mask & MAEV_TX_EV)
-+		tx_ev_irq(dev);
-+	if (mask & MAEV_RX_EV)
-+		rx_ev_irq(dev);
-+	dev->irqs++;
-+	return;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int __init init (void)
-+{
-+	struct n9604_udc	*dev;
-+	int ret;
-+	u8 * addr;
-+
-+	if (the_controller) 
-+		return -EBUSY;
-+
-+	addr = ioremap(USBN9604_PHYS, 0x2);//ioremap will bump this to 1 page size
-+	if (!addr) {
-+		ERROR(dev, KERN_ERR "Unable to remap address\n");
-+		return -EINVAL;
-+	}
-+
-+	USBN9604_Offset = addr;
-+	
-+	if ((read_9604(RID) & 0xF) != 0x2) { //0x2 is the identifier for 9603/4
-+		iounmap(addr);
-+		return -ENODEV;
-+	}
-+	
-+	/* alloc, and start init */
-+	dev = kmalloc(sizeof *dev, SLAB_KERNEL);
-+	if (dev == NULL){
-+		WARN(dev, "No memory");
-+		iounmap(addr);
-+		return -ENOMEM;
-+	}
-+	memset(dev, 0, sizeof *dev);
-+	spin_lock_init(&dev->lock);
-+	dev->gadget.ops = &n9604_ops;
-+	dev->gadget.is_dualspeed = 0;
-+
-+	/* the "gadget" abstracts/virtualizes the controller */
-+	dev->gadget.dev.bus_id = "gadget";
-+	dev->gadget.name = driver_name;
-+
-+	/* initialize the hardware */
-+
-+	udc_reset(dev);
-+
-+	write_9604(CCONF_CODIS | 11, CCONF);
-+
-+	udc_reinit(dev);//this is necessary as it sets up the epx functions
-+	
-+	the_controller = dev;
-+
-+	if ((ret=request_irq(IRQ_GPIOC, n9604_irq, SA_SHIRQ, driver_name,dev))) {
-+		WARN(dev, "Can't get IRQ\n");
-+		iounmap(addr);
-+		return ret;
-+	}
-+
-+	return 0;
-+}
-+module_init (init);
-+
-+static void __exit cleanup (void)
-+{
-+	struct n9604_udc	*dev = the_controller;
-+
-+	//first kill the interrupts
-+	udc_reset(dev);
-+	free_irq(IRQ_GPIOC, dev);
-+	
-+	/* start with the driver above us */
-+	if (dev->driver) {
-+		/* should have been done already by driver model core */
-+		WARN(dev, "Warning: Driver '%s' is still registered\n",
-+				dev->driver->driver.name);
-+		usb_gadget_unregister_driver(dev->driver);
-+	}
-+	kfree(dev);
-+	iounmap(USBN9604_Offset);
-+	the_controller = 0;
-+
-+}
-+module_exit (cleanup);
-+
-+MODULE_PARM_DESC (delayTime, "Delays after reads and writes to the USB chip");
-+MODULE_PARM (delayTime, "i");
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/n9604.h kernel/drivers/usb/gadget/n9604.h
---- /tmp/kernel/drivers/usb/gadget/n9604.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/n9604.h	2005-04-22 17:53:19.463534794 +0200
-@@ -0,0 +1,112 @@
-+/*
-+ * National 9604 USB device controller driver
-+ *
-+ * Copyright 2003 Technical Solutions Inc.
-+ *
-+ * ported from:
-+ * 
-+ * Toshiba TC86C001 ("Goku-S") USB Device Controller driver
-+ *
-+ * Copyright (C) 2000-2002 Lineo
-+ *      by Stuart Lynne, Tom Rushworth, and Bruce Balden
-+ * Copyright (C) 2002 Toshiba Corporation
-+ * Copyright (C) 2003 MontaVista Software (source@mvista.com)
-+ *
-+ * This file is licensed under the terms of the GNU General Public
-+ * License version 2.  This program is licensed "as is" without any
-+ * warranty of any kind, whether express or implied.
-+ */
-+
-+#define MAX_FIFO_SIZE   64
-+#define MAX_EP0_SIZE    8
-+
-+struct n9604_ep {
-+	struct usb_ep                           ep;
-+	struct n9604_udc			*dev;
-+	unsigned long				irqs;
-+	int					acct_req_lengths[4];
-+	int					acct_req_dir[4];//direction
-+	unsigned long				queue_reqs;//how many times has n9604_queue been called
-+	unsigned long				queue_active;//how many current requests
-+	unsigned long				packets;//counter of raw packets
-+	unsigned				num:4,
-+						numActual:4,
-+						fifoNum:2,
-+						is_in:1,
-+						stage:2,//for ep0, 0 = unused, 1 = got setup, 2 = done transfer/ready to send/receive ZLP
-+						toggle:1,
-+						nuking:1;//are we killing on off this endpoint//only used for ep0 to help with stages
-+	/* analogous to a host-side qh */
-+	struct list_head			queue;
-+	const struct usb_endpoint_descriptor	*desc;
-+
-+	u8					control;
-+	u8					fifo;
-+	u8					status;
-+	u8					command;
-+};
-+
-+struct n9604_request {
-+	struct usb_request		req;
-+	struct list_head		queue;
-+	int				complete;//this is added for tx requests
-+						//if set the entire request has been written to the fifo, just waiting for confirmation
-+						//from the interrupt that it has been sent
-+
-+	unsigned			mapped:1;
-+};
-+
-+struct n9604_udc {
-+	struct usb_gadget		gadget;
-+	spinlock_t			lock;
-+	struct n9604_ep			ep[7];
-+	struct usb_gadget_driver	*driver;
-+	int				configured;
-+
-+	u8				address;
-+
-+	/* statistics... */
-+	unsigned long			irqs;
-+};
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#define xprintk(dev,level,fmt,args...) \
-+	printk(level "%s %s: " fmt , driver_name , \
-+			"S2410 gadget" , ## args)
-+
-+#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)
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* 2.5 stuff that's sometimes missing in 2.4 */
-+
-+#ifndef container_of
-+#define	container_of	list_entry
-+#endif
-+
-+#ifndef likely
-+#define likely(x)	(x)
-+#define unlikely(x)	(x)
-+#endif
-+
-+#ifndef BUG_ON
-+#define BUG_ON(condition) do { if (unlikely((condition)!=0)) BUG(); } while(0)
-+#endif
-+
-+#ifndef WARN_ON
-+#define	WARN_ON(x)	do { } while (0)
-+#endif
-+
-+#ifndef	IRQ_NONE
-+typedef void irqreturn_t;
-+#define IRQ_NONE
-+#define IRQ_HANDLED
-+#define IRQ_RETVAL(x)
-+#endif
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/n9604regs.h kernel/drivers/usb/gadget/n9604regs.h
---- /tmp/kernel/drivers/usb/gadget/n9604regs.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/n9604regs.h	2005-04-22 17:53:19.466534306 +0200
-@@ -0,0 +1,248 @@
-+/* National 9604 registers */
-+
-+#define USBN9604_PHYS	0x08000000
-+
-+extern u8 * USBN9604_Offset;
-+
-+static u8 last_address = 255;//an invalid address
-+
-+inline u8 read_9604(u8 addr) {
-+	u8 tmp;
-+	if (addr != last_address) {
-+		outb(addr, USBN9604_Offset + 1);
-+		last_address = addr;
-+	}
-+	tmp = inb(USBN9604_Offset);
-+	return tmp;
-+}
-+
-+inline void write_9604(u8 value, u8 addr) {
-+	if (addr != last_address) {
-+		outb(addr, USBN9604_Offset + 1);
-+		last_address = addr;
-+	}
-+	outb(value, USBN9604_Offset);
-+}
-+
-+
-+	
-+#define MCNTRL		0x00
-+#define CCONF		0x01
-+
-+#define RID		0x03
-+#define FAR		0x04
-+#define NFSR		0x05
-+#define MAEV		0x06
-+#define MAMSK		0x07
-+#define ALTEV		0x08
-+#define ALTMSK		0x09
-+#define TXEV		0x0A
-+#define TXMSK		0x0B
-+#define RXEV		0x0C
-+#define RXMSK		0x0D
-+#define NAKEV		0x0E
-+#define NAKMSK		0x0F
-+#define FWEV		0x10
-+#define FWMSK		0x11
-+#define FNH		0x12
-+#define FNL		0x13
-+#define DMACNTRL	0x14
-+#define DMAEV		0x15
-+#define DMAMSK		0x16
-+#define MIR		0x17
-+#define DMACNT		0x18
-+#define DMAERR		0x19
-+
-+#define WKUP		0x1B
-+
-+
-+
-+
-+#define EPC0		0x20
-+#define TXD0		0x21
-+#define TXS0		0x22
-+#define TXC0		0x23
-+
-+#define RXD0		0x25
-+#define RXS0		0x26
-+#define RXC0		0x27
-+#define EPC1		0x28
-+#define TXD1		0x29
-+#define TXS1		0x2A
-+#define TXC1		0x2B
-+#define EPC2		0x2C
-+#define RXD1		0x2D
-+#define RXS1		0x2E
-+#define RXC1		0x2F
-+#define EPC3		0x30
-+#define TXD2		0x31
-+#define TXS2		0x32
-+#define TXC2		0x33
-+#define EPC4		0x34
-+#define RXD2		0x35
-+#define RXS2		0x36
-+#define RXC2		0x37
-+#define EPC5		0x38 
-+#define TXD3		0x39
-+#define TXS3		0x3A
-+#define TXC3		0x3B
-+#define EPC6		0x3C
-+#define RXD3		0x3D
-+#define RXS3		0x3E
-+#define RXC3		0x3F
-+
-+
-+/* MCNTRL values */
-+#define MCNTRL_SRST		(1 << 0)
-+#define MCNTRL_VGE		(1 << 2)
-+#define MCNTRL_NAT		(1 << 3)
-+#define MCNTRL_INTOC_MASK	(3 << 6)
-+#define MCNTRL_INTOC_DISABLE	0
-+#define MCNTRL_INTOC_ActLowOpen	(1 << 6)
-+#define MCNTRL_INTOC_ActHigh	(2 << 6)
-+#define MCNTRL_INTOC_ActLowPP	(3 << 6)
-+
-+/* CCONF values */
-+#define CCONF_CLKDIV_MASK	0x0F
-+#define CCONF_CODIS		(1 << 7)
-+
-+/* FAR values */
-+#define FAR_AD_MASK		0x7F
-+#define FAR_AD_EN		0x80
-+
-+/* NFSR values */
-+#define NFSR_NodeReset		0x0
-+#define NFSR_NodeResume		0x1
-+#define NFSR_NodeOperational	0x2
-+#define NFSR_NodeSuspend	0x3
-+
-+/* MAEV values */
-+#define MAEV_WARN		(1 << 0)
-+#define MAEV_ALT		(1 << 1)
-+#define MAEV_TX_EV		(1 << 2)
-+#define MAEV_FRAME		(1 << 3)
-+#define MAEV_NAK		(1 << 4)
-+#define MAEV_ULD		(1 << 5)
-+#define MAEV_RX_EV		(1 << 6)
-+#define MAEV_INTR		(1 << 7)
-+
-+/* MAMSK values */
-+#define MAMSK_WARN		(1 << 0)
-+#define MAMSK_ALT		(1 << 1)
-+#define MAMSK_TX_EV		(1 << 2)
-+#define MAMSK_FRAME		(1 << 3)
-+#define MAMSK_NAK		(1 << 4)
-+#define MAMSK_ULD		(1 << 5)
-+#define MAMSK_RX_EV		(1 << 6)
-+#define MAMSK_INTR		(1 << 7)
-+
-+/* ALTEV values */
-+
-+#define ALTEV_WKUP		(1 << 1)
-+#define ALTEV_DMA		(1 << 2)
-+#define ALTEV_EOP		(1 << 3)
-+#define ALTEV_SD3		(1 << 4)
-+#define ALTEV_SD5		(1 << 5)
-+#define ALTEV_RESET		(1 << 6)
-+#define ALTEV_RESUME		(1 << 7)
-+
-+/* ALTMSK values */
-+
-+#define ALTMSK_WKUP		(1 << 1)
-+#define ALTMSK_DMA		(1 << 2)
-+#define ALTMSK_EOP		(1 << 3)
-+#define ALTMSK_SD3		(1 << 4)
-+#define ALTMSK_SD5		(1 << 5)
-+#define ALTMSK_RESET		(1 << 6)
-+#define ALTMSK_RESUME		(1 << 7)
-+
-+/* NAKEV values */
-+
-+#define NAKEV_TXFIFO0		(1 << 0)
-+#define NAKEV_TXFIFO1		(1 << 1)
-+#define NAKEV_TXFIFO2		(1 << 2)
-+#define NAKEV_TXFIFO3		(1 << 3)
-+#define NAKEV_RXFIFO0		(1 << 4)
-+#define NAKEV_RXFIFO1		(1 << 5)
-+#define NAKEV_RXFIFO2		(1 << 6)
-+#define NAKEV_RXFIFO3		(1 << 7)
-+
-+
-+/* WKUP values */
-+#define WKUP_PNDUSB		(1 << 0)
-+#define WKUP_PNDUC		(1 << 1)
-+#define WKUP_ENUSB		(1 << 2)
-+#define WKUP_ENUC		(1 << 3)
-+#define WKUP_WKMODE		(1 << 5)
-+#define WKUP_HOS		(1 << 6)
-+#define WKUP_FHT		(1 << 7)
-+
-+/* EPC values */
-+
-+#define EPC_EP_MASK		0x0F    //EP0 == 0
-+#define EPC_EP_EN		(1 << 4)//not EP0
-+#define EPC_ISO			(1 << 5)//not EP0
-+#define EPC_DEF			(1 << 6)//EP0 only
-+#define EPC_STALL		(1 << 7)
-+
-+/* TXS values */
-+
-+#define TXS_TCOUNT_MASK		0x1F
-+#define TXS_TX_DONE		(1 << 5)
-+#define TXS_ACK_STAT		(1 << 6)
-+#define TXS_TX_URUN		(1 << 7)
-+
-+/* TXC values */
-+
-+#define TXC_TX_EN		(1 << 0)
-+#define TXC_LAST		(1 << 1)//not for endpoint 0
-+#define TXC_TOGGLE		(1 << 2)//sets DATA1 when set
-+#define TXC_FLUSH		(1 << 3)
-+#define TXC_IGN_IN		(1 << 4)//only endpoint 0
-+#define TXC_RFF			(1 << 4)//not for endpoint 0
-+#define TXC_TFWL0		(1 << 5)//"
-+#define TXC_TFWL1		(1 << 6)//"
-+#define TXC_IGN_ISOMSK		(1 << 7)//"
-+
-+/* TXEV values */
-+
-+#define TXEV_FIFO0		(1 << 0)
-+#define TXEV_FIFO1		(1 << 1)
-+#define TXEV_FIFO2		(1 << 2)
-+#define TXEV_FIFO3		(1 << 3)
-+#define TXEV_UDRRN0		(1 << 4)
-+#define TXEV_UDRRN1		(1 << 5)
-+#define TXEV_UDRRN2		(1 << 6)
-+#define TXEV_UDRRN3		(1 << 7)
-+
-+
-+/* RXEV values */
-+
-+#define RXEV_FIFO0		(1 << 0)
-+#define RXEV_FIFO1		(1 << 1)
-+#define RXEV_FIFO2		(1 << 2)
-+#define RXEV_FIFO3		(1 << 3)
-+#define RXEV_OVRRN0		(1 << 4)
-+#define RXEV_OVRRN1		(1 << 5)
-+#define RXEV_OVRRN2		(1 << 6)
-+#define RXEV_OVRRN3		(1 << 7)
-+
-+/* RXC values */
-+
-+#define RXC_RX_EN		(1 << 0)
-+#define RXC_IGN_OUT		(1 << 1)
-+#define RXC_IGN_SETUP		(1 << 2)
-+#define RXC_FLUSH		(1 << 3)
-+#define RXC_RFWL0		(1 << 5)
-+#define RXC_RFWL1		(1 << 6)
-+
-+/* RXS values */
-+
-+#define RXS_RCOUNTMASK		0xF
-+#define RXS_RX_LAST		(1 << 4)
-+#define RXS_TOGGLE		(1 << 5)
-+#define RXS_SETUP		(1 << 6)
-+#define RXS_RX_ERR		(1 << 7)
-+
-+
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/ndis.h kernel/drivers/usb/gadget/ndis.h
---- /tmp/kernel/drivers/usb/gadget/ndis.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/ndis.h	2005-04-22 17:53:19.469533817 +0200
-@@ -0,0 +1,217 @@
-+/*
-+ * ndis.h 
-+ * 
-+ * ntddndis.h modified by Benedikt Spranger <b.spranger@pengutronix.de>
-+ * 
-+ * 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
-+ * use, modify or distribute it freely.
-+ *
-+ * This code is distributed in the hope that it will be useful but
-+ * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
-+ * DISCLAIMED. This includes but is not limited to warranties of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-+ *
-+ */
-+
-+#ifndef _LINUX_NDIS_H
-+#define _LINUX_NDIS_H
-+
-+
-+#define NDIS_STATUS_MULTICAST_FULL	  0xC0010009
-+#define NDIS_STATUS_MULTICAST_EXISTS      0xC001000A
-+#define NDIS_STATUS_MULTICAST_NOT_FOUND   0xC001000B
-+
-+enum NDIS_DEVICE_POWER_STATE {
-+	NdisDeviceStateUnspecified = 0,
-+	NdisDeviceStateD0,
-+	NdisDeviceStateD1,
-+	NdisDeviceStateD2,
-+	NdisDeviceStateD3,
-+	NdisDeviceStateMaximum
-+};
-+
-+struct NDIS_PM_WAKE_UP_CAPABILITIES {
-+	enum NDIS_DEVICE_POWER_STATE  MinMagicPacketWakeUp;
-+	enum NDIS_DEVICE_POWER_STATE  MinPatternWakeUp;
-+	enum NDIS_DEVICE_POWER_STATE  MinLinkChangeWakeUp;
-+};
-+
-+/* NDIS_PNP_CAPABILITIES.Flags constants */
-+#define NDIS_DEVICE_WAKE_UP_ENABLE                0x00000001
-+#define NDIS_DEVICE_WAKE_ON_PATTERN_MATCH_ENABLE  0x00000002
-+#define NDIS_DEVICE_WAKE_ON_MAGIC_PACKET_ENABLE   0x00000004
-+
-+struct NDIS_PNP_CAPABILITIES {
-+	u32					Flags;
-+	struct NDIS_PM_WAKE_UP_CAPABILITIES	WakeUpCapabilities;
-+};
-+
-+struct NDIS_PM_PACKET_PATTERN {
-+	u32	Priority;
-+	u32	Reserved;
-+	u32	MaskSize;
-+	u32	PatternOffset;
-+	u32	PatternSize;
-+	u32	PatternFlags;
-+};
-+
-+
-+/* Required Object IDs (OIDs) */
-+#define OID_GEN_SUPPORTED_LIST            0x00010101
-+#define OID_GEN_HARDWARE_STATUS           0x00010102
-+#define OID_GEN_MEDIA_SUPPORTED           0x00010103
-+#define OID_GEN_MEDIA_IN_USE              0x00010104
-+#define OID_GEN_MAXIMUM_LOOKAHEAD         0x00010105
-+#define OID_GEN_MAXIMUM_FRAME_SIZE        0x00010106
-+#define OID_GEN_LINK_SPEED                0x00010107
-+#define OID_GEN_TRANSMIT_BUFFER_SPACE     0x00010108
-+#define OID_GEN_RECEIVE_BUFFER_SPACE      0x00010109
-+#define OID_GEN_TRANSMIT_BLOCK_SIZE       0x0001010A
-+#define OID_GEN_RECEIVE_BLOCK_SIZE        0x0001010B
-+#define OID_GEN_VENDOR_ID                 0x0001010C
-+#define OID_GEN_VENDOR_DESCRIPTION        0x0001010D
-+#define OID_GEN_CURRENT_PACKET_FILTER     0x0001010E
-+#define OID_GEN_CURRENT_LOOKAHEAD         0x0001010F
-+#define OID_GEN_DRIVER_VERSION            0x00010110
-+#define OID_GEN_MAXIMUM_TOTAL_SIZE        0x00010111
-+#define OID_GEN_PROTOCOL_OPTIONS          0x00010112
-+#define OID_GEN_MAC_OPTIONS               0x00010113
-+#define OID_GEN_MEDIA_CONNECT_STATUS      0x00010114
-+#define OID_GEN_MAXIMUM_SEND_PACKETS      0x00010115
-+#define OID_GEN_VENDOR_DRIVER_VERSION     0x00010116
-+#define OID_GEN_SUPPORTED_GUIDS           0x00010117
-+#define OID_GEN_NETWORK_LAYER_ADDRESSES   0x00010118
-+#define OID_GEN_TRANSPORT_HEADER_OFFSET   0x00010119
-+#define OID_GEN_MACHINE_NAME              0x0001021A
-+#define OID_GEN_RNDIS_CONFIG_PARAMETER    0x0001021B
-+#define OID_GEN_VLAN_ID                   0x0001021C
-+
-+/* Optional OIDs */
-+#define OID_GEN_MEDIA_CAPABILITIES        0x00010201
-+#define OID_GEN_PHYSICAL_MEDIUM           0x00010202
-+
-+/* Required statistics OIDs */
-+#define OID_GEN_XMIT_OK                   0x00020101
-+#define OID_GEN_RCV_OK                    0x00020102
-+#define OID_GEN_XMIT_ERROR                0x00020103
-+#define OID_GEN_RCV_ERROR                 0x00020104
-+#define OID_GEN_RCV_NO_BUFFER             0x00020105
-+
-+/* Optional statistics OIDs */
-+#define OID_GEN_DIRECTED_BYTES_XMIT       0x00020201
-+#define OID_GEN_DIRECTED_FRAMES_XMIT      0x00020202
-+#define OID_GEN_MULTICAST_BYTES_XMIT      0x00020203
-+#define OID_GEN_MULTICAST_FRAMES_XMIT     0x00020204
-+#define OID_GEN_BROADCAST_BYTES_XMIT      0x00020205
-+#define OID_GEN_BROADCAST_FRAMES_XMIT     0x00020206
-+#define OID_GEN_DIRECTED_BYTES_RCV        0x00020207
-+#define OID_GEN_DIRECTED_FRAMES_RCV       0x00020208
-+#define OID_GEN_MULTICAST_BYTES_RCV       0x00020209
-+#define OID_GEN_MULTICAST_FRAMES_RCV      0x0002020A
-+#define OID_GEN_BROADCAST_BYTES_RCV       0x0002020B
-+#define OID_GEN_BROADCAST_FRAMES_RCV      0x0002020C
-+#define OID_GEN_RCV_CRC_ERROR             0x0002020D
-+#define OID_GEN_TRANSMIT_QUEUE_LENGTH     0x0002020E
-+#define OID_GEN_GET_TIME_CAPS             0x0002020F
-+#define OID_GEN_GET_NETCARD_TIME          0x00020210
-+#define OID_GEN_NETCARD_LOAD              0x00020211
-+#define OID_GEN_DEVICE_PROFILE            0x00020212
-+#define OID_GEN_INIT_TIME_MS              0x00020213
-+#define OID_GEN_RESET_COUNTS              0x00020214
-+#define OID_GEN_MEDIA_SENSE_COUNTS        0x00020215
-+#define OID_GEN_FRIENDLY_NAME             0x00020216
-+#define OID_GEN_MINIPORT_INFO             0x00020217
-+#define OID_GEN_RESET_VERIFY_PARAMETERS   0x00020218
-+
-+/* IEEE 802.3 (Ethernet) OIDs */
-+#define NDIS_802_3_MAC_OPTION_PRIORITY    0x00000001
-+
-+#define OID_802_3_PERMANENT_ADDRESS       0x01010101
-+#define OID_802_3_CURRENT_ADDRESS         0x01010102
-+#define OID_802_3_MULTICAST_LIST          0x01010103
-+#define OID_802_3_MAXIMUM_LIST_SIZE       0x01010104
-+#define OID_802_3_MAC_OPTIONS             0x01010105
-+#define OID_802_3_RCV_ERROR_ALIGNMENT     0x01020101
-+#define OID_802_3_XMIT_ONE_COLLISION      0x01020102
-+#define OID_802_3_XMIT_MORE_COLLISIONS    0x01020103
-+#define OID_802_3_XMIT_DEFERRED           0x01020201
-+#define OID_802_3_XMIT_MAX_COLLISIONS     0x01020202
-+#define OID_802_3_RCV_OVERRUN             0x01020203
-+#define OID_802_3_XMIT_UNDERRUN           0x01020204
-+#define OID_802_3_XMIT_HEARTBEAT_FAILURE  0x01020205
-+#define OID_802_3_XMIT_TIMES_CRS_LOST     0x01020206
-+#define OID_802_3_XMIT_LATE_COLLISIONS    0x01020207
-+
-+/* OID_GEN_MINIPORT_INFO constants */
-+#define NDIS_MINIPORT_BUS_MASTER                      0x00000001
-+#define NDIS_MINIPORT_WDM_DRIVER                      0x00000002
-+#define NDIS_MINIPORT_SG_LIST                         0x00000004
-+#define NDIS_MINIPORT_SUPPORTS_MEDIA_QUERY            0x00000008
-+#define NDIS_MINIPORT_INDICATES_PACKETS               0x00000010
-+#define NDIS_MINIPORT_IGNORE_PACKET_QUEUE             0x00000020
-+#define NDIS_MINIPORT_IGNORE_REQUEST_QUEUE            0x00000040
-+#define NDIS_MINIPORT_IGNORE_TOKEN_RING_ERRORS        0x00000080
-+#define NDIS_MINIPORT_INTERMEDIATE_DRIVER             0x00000100
-+#define NDIS_MINIPORT_IS_NDIS_5                       0x00000200
-+#define NDIS_MINIPORT_IS_CO                           0x00000400
-+#define NDIS_MINIPORT_DESERIALIZE                     0x00000800
-+#define NDIS_MINIPORT_REQUIRES_MEDIA_POLLING          0x00001000
-+#define NDIS_MINIPORT_SUPPORTS_MEDIA_SENSE            0x00002000
-+#define NDIS_MINIPORT_NETBOOT_CARD                    0x00004000
-+#define NDIS_MINIPORT_PM_SUPPORTED                    0x00008000
-+#define NDIS_MINIPORT_SUPPORTS_MAC_ADDRESS_OVERWRITE  0x00010000
-+#define NDIS_MINIPORT_USES_SAFE_BUFFER_APIS           0x00020000
-+#define NDIS_MINIPORT_HIDDEN                          0x00040000
-+#define NDIS_MINIPORT_SWENUM                          0x00080000
-+#define NDIS_MINIPORT_SURPRISE_REMOVE_OK              0x00100000
-+#define NDIS_MINIPORT_NO_HALT_ON_SUSPEND              0x00200000
-+#define NDIS_MINIPORT_HARDWARE_DEVICE                 0x00400000
-+#define NDIS_MINIPORT_SUPPORTS_CANCEL_SEND_PACKETS    0x00800000
-+#define NDIS_MINIPORT_64BITS_DMA                      0x01000000
-+
-+#define NDIS_MEDIUM_802_3		0x00000000
-+#define NDIS_MEDIUM_802_5		0x00000001
-+#define NDIS_MEDIUM_FDDI		0x00000002
-+#define NDIS_MEDIUM_WAN			0x00000003
-+#define NDIS_MEDIUM_LOCAL_TALK		0x00000004
-+#define NDIS_MEDIUM_DIX			0x00000005
-+#define NDIS_MEDIUM_ARCENT_RAW		0x00000006
-+#define NDIS_MEDIUM_ARCENT_878_2	0x00000007
-+#define NDIS_MEDIUM_ATM			0x00000008
-+#define NDIS_MEDIUM_WIRELESS_LAN	0x00000009
-+#define NDIS_MEDIUM_IRDA		0x0000000A
-+#define NDIS_MEDIUM_BPC			0x0000000B
-+#define NDIS_MEDIUM_CO_WAN		0x0000000C
-+#define NDIS_MEDIUM_1394		0x0000000D
-+
-+#define NDIS_PACKET_TYPE_DIRECTED	0x00000001
-+#define NDIS_PACKET_TYPE_MULTICAST	0x00000002
-+#define NDIS_PACKET_TYPE_ALL_MULTICAST	0x00000004
-+#define NDIS_PACKET_TYPE_BROADCAST	0x00000008
-+#define NDIS_PACKET_TYPE_SOURCE_ROUTING	0x00000010
-+#define NDIS_PACKET_TYPE_PROMISCUOUS	0x00000020
-+#define NDIS_PACKET_TYPE_SMT		0x00000040
-+#define NDIS_PACKET_TYPE_ALL_LOCAL	0x00000080
-+#define NDIS_PACKET_TYPE_GROUP		0x00000100
-+#define NDIS_PACKET_TYPE_ALL_FUNCTIONAL	0x00000200
-+#define NDIS_PACKET_TYPE_FUNCTIONAL	0x00000400
-+#define NDIS_PACKET_TYPE_MAC_FRAME	0x00000800
-+
-+#define NDIS_MEDIA_STATE_CONNECTED	0x00000000
-+#define NDIS_MEDIA_STATE_DISCONNECTED	0x00000001
-+
-+#define NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA     0x00000001
-+#define NDIS_MAC_OPTION_RECEIVE_SERIALIZED      0x00000002
-+#define NDIS_MAC_OPTION_TRANSFERS_NOT_PEND      0x00000004
-+#define NDIS_MAC_OPTION_NO_LOOPBACK             0x00000008
-+#define NDIS_MAC_OPTION_FULL_DUPLEX             0x00000010
-+#define NDIS_MAC_OPTION_EOTX_INDICATION         0x00000020
-+#define NDIS_MAC_OPTION_8021P_PRIORITY          0x00000040
-+#define NDIS_MAC_OPTION_RESERVED                0x80000000
-+
-+#endif /* _LINUX_NDIS_H */
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/net2280.c kernel/drivers/usb/gadget/net2280.c
---- /tmp/kernel/drivers/usb/gadget/net2280.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/net2280.c	2005-04-22 17:53:19.478532352 +0200
-@@ -0,0 +1,2918 @@
-+/*
-+ * Driver for the NetChip 2280 USB device controller.
-+ * Specs and errata are available from <http://www.netchip.com>.
-+ *
-+ * NetChip Technology Inc. supported the development of this driver.
-+ *
-+ *
-+ * CODE STATUS HIGHLIGHTS
-+ *
-+ * This driver should work well with most "gadget" drivers, including
-+ * the File Storage, Serial, and Ethernet/RNDIS gadget drivers
-+ * as well as Gadget Zero and Gadgetfs.
-+ *
-+ * DMA is enabled by default.  Drivers using transfer queues might use
-+ * DMA chaining to remove IRQ latencies between transfers.  (Except when
-+ * short OUT transfers happen.)  Drivers can use the req->no_interrupt
-+ * hint to completely eliminate some IRQs, if a later IRQ is guaranteed
-+ * and DMA chaining is enabled.
-+ *
-+ * Note that almost all the errata workarounds here are only needed for
-+ * rev1 chips.  Rev1a silicon (0110) fixes almost all of them.
-+ */
-+
-+/*
-+ * Copyright (C) 2003 David Brownell
-+ * Copyright (C) 2003 NetChip Technologies
-+ *
-+ * 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
-+ */
-+
-+#undef	DEBUG		/* messages on error and most fault paths */
-+#undef	VERBOSE		/* extra debug messages (success too) */
-+
-+#include <linux/config.h>
-+#include <linux/module.h>
-+#include <linux/pci.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/usb_ch9.h>
-+#include <linux/usb_gadget.h>
-+
-+#include <asm/byteorder.h>
-+#include <asm/io.h>
-+#include <asm/irq.h>
-+#include <asm/system.h>
-+#include <asm/unaligned.h>
-+
-+
-+#define	DRIVER_DESC		"NetChip 2280 USB Peripheral Controller"
-+#define	DRIVER_VERSION		"2004 Jan 14"
-+
-+#define	DMA_ADDR_INVALID	(~(dma_addr_t)0)
-+#define	EP_DONTUSE		13	/* nonzero */
-+
-+#define USE_RDK_LEDS		/* GPIO pins control three LEDs */
-+
-+
-+static const char driver_name [] = "net2280";
-+static const char driver_desc [] = DRIVER_DESC;
-+
-+static const char ep0name [] = "ep0";
-+static const char *ep_name [] = {
-+	ep0name,
-+	"ep-a", "ep-b", "ep-c", "ep-d",
-+	"ep-e", "ep-f",
-+};
-+
-+/* use_dma -- general goodness, fewer interrupts, less cpu load (vs PIO)
-+ * use_dma_chaining -- dma descriptor queueing gives even more irq reduction
-+ *
-+ * The net2280 DMA engines are not tightly integrated with their FIFOs;
-+ * not all cases are (yet) handled well in this driver or the silicon.
-+ * Some gadget drivers work better with the dma support here than others.
-+ * These two parameters let you use PIO or more aggressive DMA.
-+ */
-+static int use_dma = 1;
-+static int use_dma_chaining = 0;
-+
-+MODULE_PARM (use_dma, "i");
-+MODULE_PARM_DESC (use_dma, "true to use dma controllers");
-+
-+MODULE_PARM (use_dma_chaining, "i");
-+MODULE_PARM_DESC (use_dma_chaining, "true to use dma descriptor queues");
-+
-+
-+/* mode 0 == ep-{a,b,c,d} 1K fifo each
-+ * mode 1 == ep-{a,b} 2K fifo each, ep-{c,d} unavailable
-+ * mode 2 == ep-a 2K fifo, ep-{b,c} 1K each, ep-d unavailable
-+ */
-+static ushort fifo_mode = 0;
-+
-+MODULE_PARM (fifo_mode, "h");
-+MODULE_PARM_DESC (fifo_mode, "net2280 fifo mode");
-+
-+
-+#define	DIR_STRING(bAddress) (((bAddress) & USB_DIR_IN) ? "in" : "out")
-+
-+#if defined(USE_SYSFS_DEBUG_FILES) || defined (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 "net2280.h"
-+
-+#define valid_bit	__constant_cpu_to_le32 (1 << VALID_BIT)
-+#define dma_done_ie	__constant_cpu_to_le32 (1 << DMA_DONE_INTERRUPT_ENABLE)
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int
-+net2280_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
-+{
-+	struct net2280		*dev;
-+	struct net2280_ep	*ep;
-+	u32			max, tmp;
-+	unsigned long		flags;
-+
-+	ep = container_of (_ep, struct net2280_ep, ep);
-+	if (!_ep || !desc || ep->desc || _ep->name == ep0name
-+			|| desc->bDescriptorType != USB_DT_ENDPOINT)
-+		return -EINVAL;
-+	dev = ep->dev;
-+	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
-+		return -ESHUTDOWN;
-+
-+	/* erratum 0119 workaround ties up an endpoint number */
-+	if ((desc->bEndpointAddress & 0x0f) == EP_DONTUSE)
-+		return -EDOM;
-+
-+	/* sanity check ep-e/ep-f since their fifos are small */
-+	max = le16_to_cpu (desc->wMaxPacketSize) & 0x1fff;
-+	if (ep->num > 4 && max > 64)
-+		return -ERANGE;
-+
-+	spin_lock_irqsave (&dev->lock, flags);
-+	_ep->maxpacket = max & 0x7ff;
-+	ep->desc = desc;
-+
-+	/* ep_reset() has already been called */
-+	ep->stopped = 0;
-+	ep->out_overflow = 0;
-+
-+	/* set speed-dependent max packet; may kick in high bandwidth */
-+	set_idx_reg (dev->regs, REG_EP_MAXPKT (dev, ep->num), max);
-+
-+	/* FIFO lines can't go to different packets.  PIO is ok, so
-+	 * use it instead of troublesome (non-bulk) multi-packet DMA.
-+	 */
-+	if (ep->dma && (max % 4) != 0 && use_dma_chaining) {
-+		DEBUG (ep->dev, "%s, no dma for maxpacket %d\n",
-+			ep->ep.name, ep->ep.maxpacket);
-+		ep->dma = NULL;
-+	}
-+
-+	/* set type, direction, address; reset fifo counters */
-+	writel ((1 << FIFO_FLUSH), &ep->regs->ep_stat);
-+	tmp = (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
-+	if (tmp == USB_ENDPOINT_XFER_INT) {
-+		/* erratum 0105 workaround prevents hs NYET */
-+		if (dev->chiprev == 0100
-+				&& dev->gadget.speed == USB_SPEED_HIGH
-+				&& !(desc->bEndpointAddress & USB_DIR_IN))
-+			writel ((1 << CLEAR_NAK_OUT_PACKETS_MODE),
-+				&ep->regs->ep_rsp);
-+	} else if (tmp == USB_ENDPOINT_XFER_BULK) {
-+		/* catch some particularly blatant driver bugs */
-+		if ((dev->gadget.speed == USB_SPEED_HIGH
-+					&& max != 512)
-+				|| (dev->gadget.speed == USB_SPEED_FULL
-+					&& max > 64)) {
-+			spin_unlock_irqrestore (&dev->lock, flags);
-+			return -ERANGE;
-+		}
-+	}
-+	ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC) ? 1 : 0;
-+	tmp <<= ENDPOINT_TYPE;
-+	tmp |= desc->bEndpointAddress;
-+	tmp |= (4 << ENDPOINT_BYTE_COUNT);	/* default full fifo lines */
-+	tmp |= 1 << ENDPOINT_ENABLE;
-+	wmb ();
-+
-+	/* for OUT transfers, block the rx fifo until a read is posted */
-+	ep->is_in = (tmp & USB_DIR_IN) != 0;
-+	if (!ep->is_in)
-+		writel ((1 << SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
-+
-+	writel (tmp, &ep->regs->ep_cfg);
-+
-+	/* enable irqs */
-+	if (!ep->dma) {				/* pio, per-packet */
-+		tmp = (1 << ep->num) | readl (&dev->regs->pciirqenb0);
-+		writel (tmp, &dev->regs->pciirqenb0);
-+
-+		tmp = (1 << DATA_PACKET_RECEIVED_INTERRUPT_ENABLE)
-+			| (1 << DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE)
-+			| readl (&ep->regs->ep_irqenb);
-+		writel (tmp, &ep->regs->ep_irqenb);
-+	} else {				/* dma, per-request */
-+		tmp = (1 << (8 + ep->num));	/* completion */
-+		tmp |= readl (&dev->regs->pciirqenb1);
-+		writel (tmp, &dev->regs->pciirqenb1);
-+
-+		/* for short OUT transfers, dma completions can't
-+		 * advance the queue; do it pio-style, by hand.
-+		 * NOTE erratum 0112 workaround #2
-+		 */
-+		if ((desc->bEndpointAddress & USB_DIR_IN) == 0) {
-+			tmp = (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT_ENABLE);
-+			writel (tmp, &ep->regs->ep_irqenb);
-+
-+			tmp = (1 << ep->num) | readl (&dev->regs->pciirqenb0);
-+			writel (tmp, &dev->regs->pciirqenb0);
-+		}
-+	}
-+
-+	tmp = desc->bEndpointAddress;
-+	DEBUG (dev, "enabled %s (ep%d%s-%s) %s max %04x\n",
-+		_ep->name, tmp & 0x0f, DIR_STRING (tmp),
-+		type_string (desc->bmAttributes),
-+		ep->dma ? "dma" : "pio", max);
-+
-+	/* pci writes may still be posted */
-+	spin_unlock_irqrestore (&dev->lock, flags);
-+	return 0;
-+}
-+
-+static int handshake (u32 *ptr, u32 mask, u32 done, int usec)
-+{
-+	u32	result;
-+
-+	do {
-+		result = readl (ptr);
-+		if (result == ~(u32)0)		/* "device unplugged" */
-+			return -ENODEV;
-+		result &= mask;
-+		if (result == done)
-+			return 0;
-+		udelay (1);
-+		usec--;
-+	} while (usec > 0);
-+	return -ETIMEDOUT;
-+}
-+
-+static struct usb_ep_ops net2280_ep_ops;
-+
-+static void ep_reset (struct net2280_regs *regs, struct net2280_ep *ep)
-+{
-+	u32		tmp;
-+
-+	ep->desc = NULL;
-+	INIT_LIST_HEAD (&ep->queue);
-+
-+	ep->ep.maxpacket = ~0;
-+	ep->ep.ops = &net2280_ep_ops;
-+
-+	/* disable the dma, irqs, endpoint... */
-+	if (ep->dma) {
-+		writel (0, &ep->dma->dmactl);
-+		writel (  (1 << DMA_SCATTER_GATHER_DONE_INTERRUPT)
-+			| (1 << DMA_TRANSACTION_DONE_INTERRUPT)
-+			| (1 << DMA_ABORT)
-+			, &ep->dma->dmastat);
-+
-+		tmp = readl (&regs->pciirqenb0);
-+		tmp &= ~(1 << ep->num);
-+		writel (tmp, &regs->pciirqenb0);
-+	} else {
-+		tmp = readl (&regs->pciirqenb1);
-+		tmp &= ~(1 << (8 + ep->num));	/* completion */
-+		writel (tmp, &regs->pciirqenb1);
-+	}
-+	writel (0, &ep->regs->ep_irqenb);
-+
-+	/* init to our chosen defaults, notably so that we NAK OUT
-+	 * packets until the driver queues a read (+note erratum 0112)
-+	 */
-+	writel (  (1 << SET_NAK_OUT_PACKETS_MODE)
-+		| (1 << SET_NAK_OUT_PACKETS)
-+		| (1 << CLEAR_EP_HIDE_STATUS_PHASE)
-+		| (1 << CLEAR_INTERRUPT_MODE)
-+		| (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
-+		| (1 << CLEAR_ENDPOINT_TOGGLE)
-+		| (1 << CLEAR_ENDPOINT_HALT)
-+		, &ep->regs->ep_rsp);
-+
-+	/* scrub most status bits, and flush any fifo state */
-+	writel (  (1 << TIMEOUT)
-+		| (1 << USB_STALL_SENT)
-+		| (1 << USB_IN_NAK_SENT)
-+		| (1 << USB_IN_ACK_RCVD)
-+		| (1 << USB_OUT_PING_NAK_SENT)
-+		| (1 << USB_OUT_ACK_SENT)
-+		| (1 << FIFO_OVERFLOW)
-+		| (1 << FIFO_UNDERFLOW)
-+		| (1 << FIFO_FLUSH)
-+		| (1 << SHORT_PACKET_OUT_DONE_INTERRUPT)
-+		| (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)
-+		| (1 << DATA_PACKET_RECEIVED_INTERRUPT)
-+		| (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)
-+		| (1 << DATA_OUT_PING_TOKEN_INTERRUPT)
-+		| (1 << DATA_IN_TOKEN_INTERRUPT)
-+		, &ep->regs->ep_stat);
-+
-+	/* fifo size is handled separately */
-+}
-+
-+static void nuke (struct net2280_ep *);
-+
-+static int net2280_disable (struct usb_ep *_ep)
-+{
-+	struct net2280_ep	*ep;
-+	unsigned long		flags;
-+
-+	ep = container_of (_ep, struct net2280_ep, ep);
-+	if (!_ep || !ep->desc || _ep->name == ep0name)
-+		return -EINVAL;
-+
-+	spin_lock_irqsave (&ep->dev->lock, flags);
-+	nuke (ep);
-+	ep_reset (ep->dev->regs, ep);
-+
-+	VDEBUG (ep->dev, "disabled %s %s\n",
-+			ep->dma ? "dma" : "pio", _ep->name);
-+
-+	/* synch memory views with the device */
-+	(void) readl (&ep->regs->ep_cfg);
-+
-+	if (use_dma && !ep->dma && ep->num >= 1 && ep->num <= 4)
-+		ep->dma = &ep->dev->dma [ep->num - 1];
-+
-+	spin_unlock_irqrestore (&ep->dev->lock, flags);
-+	return 0;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static struct usb_request *
-+net2280_alloc_request (struct usb_ep *_ep, int gfp_flags)
-+{
-+	struct net2280_ep	*ep;
-+	struct net2280_request	*req;
-+
-+	if (!_ep)
-+		return NULL;
-+	ep = container_of (_ep, struct net2280_ep, ep);
-+
-+	req = kmalloc (sizeof *req, gfp_flags);
-+	if (!req)
-+		return NULL;
-+
-+	memset (req, 0, sizeof *req);
-+	req->req.dma = DMA_ADDR_INVALID;
-+	INIT_LIST_HEAD (&req->queue);
-+
-+	/* this dma descriptor may be swapped with the previous dummy */
-+	if (ep->dma) {
-+		struct net2280_dma	*td;
-+
-+		td = pci_pool_alloc (ep->dev->requests, gfp_flags,
-+				&req->td_dma);
-+		if (!td) {
-+			kfree (req);
-+			return NULL;
-+		}
-+		td->dmacount = 0;	/* not VALID */
-+		td->dmaaddr = __constant_cpu_to_le32 (DMA_ADDR_INVALID);
-+		td->dmadesc = td->dmaaddr;
-+		req->td = td;
-+	}
-+	return &req->req;
-+}
-+
-+static void
-+net2280_free_request (struct usb_ep *_ep, struct usb_request *_req)
-+{
-+	struct net2280_ep	*ep;
-+	struct net2280_request	*req;
-+
-+	ep = container_of (_ep, struct net2280_ep, ep);
-+	if (!_ep || !_req)
-+		return;
-+
-+	req = container_of (_req, struct net2280_request, req);
-+	WARN_ON (!list_empty (&req->queue));
-+	if (req->td)
-+		pci_pool_free (ep->dev->requests, req->td, req->td_dma);
-+	kfree (req);
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#undef USE_KMALLOC
-+
-+/* many common platforms have dma-coherent caches, which means that it's
-+ * safe to use kmalloc() memory for all i/o buffers without using any
-+ * cache flushing calls.  (unless you're trying to share cache lines
-+ * between dma and non-dma activities, which is a slow idea in any case.)
-+ *
-+ * other platforms need more care, with 2.5 having a moderately general
-+ * solution (which falls down for allocations smaller than one page)
-+ * that improves significantly on the 2.4 PCI allocators by removing
-+ * the restriction that memory never be freed in_interrupt().
-+ */
-+#if	defined(CONFIG_X86)
-+#define USE_KMALLOC
-+
-+#elif	defined(CONFIG_PPC) && !defined(CONFIG_NOT_COHERENT_CACHE)
-+#define USE_KMALLOC
-+
-+#elif	defined(CONFIG_MIPS) && !defined(CONFIG_NONCOHERENT_IO)
-+#define USE_KMALLOC
-+
-+/* FIXME there are other cases, including an x86-64 one ...  */
-+#endif
-+
-+/* allocating buffers this way eliminates dma mapping overhead, which
-+ * on some platforms will mean eliminating a per-io buffer copy.  with
-+ * some kinds of system caches, further tweaks may still be needed.
-+ */
-+static void *
-+net2280_alloc_buffer (
-+	struct usb_ep		*_ep,
-+	unsigned		bytes,
-+	dma_addr_t		*dma,
-+	int			gfp_flags
-+)
-+{
-+	void			*retval;
-+	struct net2280_ep	*ep;
-+
-+	ep = container_of (_ep, struct net2280_ep, ep);
-+	if (!_ep)
-+		return NULL;
-+	*dma = DMA_ADDR_INVALID;
-+
-+#if	defined(USE_KMALLOC)
-+	retval = kmalloc(bytes, gfp_flags);
-+	if (retval)
-+		*dma = virt_to_phys(retval);
-+#else
-+	if (ep->dma) {
-+		/* one problem with this call is that it wastes memory on
-+		 * typical 1/N page allocations: it allocates 1..N pages.
-+		 * another is that it always uses GFP_ATOMIC.
-+		 */
-+#warning Using pci_alloc_consistent even with buffers smaller than a page.
-+		retval = pci_alloc_consistent(ep->dev->pdev, bytes, dma);
-+	} else
-+		retval = kmalloc(bytes, gfp_flags);
-+#endif
-+	return retval;
-+}
-+
-+static void
-+net2280_free_buffer (
-+	struct usb_ep *_ep,
-+	void *buf,
-+	dma_addr_t dma,
-+	unsigned bytes
-+) {
-+	/* free memory into the right allocator */
-+#ifndef	USE_KMALLOC
-+	if (dma != DMA_ADDR_INVALID) {
-+		struct net2280_ep	*ep;
-+
-+		ep = container_of(_ep, struct net2280_ep, ep);
-+		if (!_ep)
-+			return;
-+		/* one problem with this call is that some platforms
-+		 * don't allow it to be used in_irq().
-+		 */
-+		pci_free_consistent(ep->dev->pdev, bytes, buf, dma);
-+	} else
-+#endif
-+		kfree (buf);
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* load a packet into the fifo we use for usb IN transfers.
-+ * works for all endpoints.
-+ *
-+ * NOTE: pio with ep-a..ep-d could stuff multiple packets into the fifo
-+ * at a time, but this code is simpler because it knows it only writes
-+ * one packet.  ep-a..ep-d should use dma instead.
-+ */
-+static void
-+write_fifo (struct net2280_ep *ep, struct usb_request *req)
-+{
-+	struct net2280_ep_regs	*regs = ep->regs;
-+	u8			*buf;
-+	u32			tmp;
-+	unsigned		count, total;
-+
-+	/* INVARIANT:  fifo is currently empty. (testable) */
-+
-+	if (req) {
-+		buf = req->buf + req->actual;
-+		prefetch (buf);
-+		total = req->length - req->actual;
-+	} else {
-+		total = 0;
-+		buf = NULL;
-+	}
-+
-+	/* write just one packet at a time */
-+	count = ep->ep.maxpacket;
-+	if (count > total)	/* min() cannot be used on a bitfield */
-+		count = total;
-+
-+	VDEBUG (ep->dev, "write %s fifo (IN) %d bytes%s req %p\n",
-+			ep->ep.name, count,
-+			(count != ep->ep.maxpacket) ? " (short)" : "",
-+			req);
-+	while (count >= 4) {
-+		/* NOTE be careful if you try to align these. fifo lines
-+		 * should normally be full (4 bytes) and successive partial
-+		 * lines are ok only in certain cases.
-+		 */
-+		tmp = get_unaligned ((u32 *)buf);
-+		cpu_to_le32s (&tmp);
-+		writel (tmp, &regs->ep_data);
-+		buf += 4;
-+		count -= 4;
-+	}
-+
-+	/* last fifo entry is "short" unless we wrote a full packet.
-+	 * also explicitly validate last word in (periodic) transfers
-+	 * when maxpacket is not a multiple of 4 bytes.
-+	 */
-+	if (count || total < ep->ep.maxpacket) {
-+		tmp = count ? get_unaligned ((u32 *)buf) : count;
-+		cpu_to_le32s (&tmp);
-+		set_fifo_bytecount (ep, count & 0x03);
-+		writel (tmp, &regs->ep_data);
-+	}
-+
-+	/* pci writes may still be posted */
-+}
-+
-+/* work around erratum 0106: PCI and USB race over the OUT fifo.
-+ * caller guarantees chiprev 0100, out endpoint is NAKing, and
-+ * there's no real data in the fifo.
-+ *
-+ * NOTE:  also used in cases where that erratum doesn't apply:
-+ * where the host wrote "too much" data to us.
-+ */
-+static void out_flush (struct net2280_ep *ep)
-+{
-+	u32	*statp, tmp;
-+
-+	ASSERT_OUT_NAKING (ep);
-+
-+	statp = &ep->regs->ep_stat;
-+	writel (  (1 << DATA_OUT_PING_TOKEN_INTERRUPT)
-+		| (1 << DATA_PACKET_RECEIVED_INTERRUPT)
-+		, statp);
-+	writel ((1 << FIFO_FLUSH), statp);
-+	mb ();
-+	tmp = readl (statp);
-+	if (tmp & (1 << DATA_OUT_PING_TOKEN_INTERRUPT)
-+			/* high speed did bulk NYET; fifo isn't filling */
-+			&& ep->dev->gadget.speed == USB_SPEED_FULL) {
-+		unsigned	usec;
-+
-+		usec = 50;		/* 64 byte bulk/interrupt */
-+		handshake (statp, (1 << USB_OUT_PING_NAK_SENT),
-+				(1 << USB_OUT_PING_NAK_SENT), usec);
-+		/* NAK done; now CLEAR_NAK_OUT_PACKETS is safe */
-+	}
-+}
-+
-+/* unload packet(s) from the fifo we use for usb OUT transfers.
-+ * returns true iff the request completed, because of short packet
-+ * or the request buffer having filled with full packets.
-+ *
-+ * for ep-a..ep-d this will read multiple packets out when they
-+ * have been accepted.
-+ */
-+static int
-+read_fifo (struct net2280_ep *ep, struct net2280_request *req)
-+{
-+	struct net2280_ep_regs	*regs = ep->regs;
-+	u8			*buf = req->req.buf + req->req.actual;
-+	unsigned		count, tmp, is_short;
-+	unsigned		cleanup = 0, prevent = 0;
-+
-+	/* erratum 0106 ... packets coming in during fifo reads might
-+	 * be incompletely rejected.  not all cases have workarounds.
-+	 */
-+	if (ep->dev->chiprev == 0x0100
-+			&& ep->dev->gadget.speed == USB_SPEED_FULL) {
-+		udelay (1);
-+		tmp = readl (&ep->regs->ep_stat);
-+		if ((tmp & (1 << NAK_OUT_PACKETS)))
-+			cleanup = 1;
-+		else if ((tmp & (1 << FIFO_FULL))) {
-+			start_out_naking (ep);
-+			prevent = 1;
-+		}
-+		/* else: hope we don't see the problem */
-+	}
-+
-+	/* never overflow the rx buffer. the fifo reads packets until
-+	 * it sees a short one; we might not be ready for them all.
-+	 */
-+	prefetchw (buf);
-+	count = readl (&regs->ep_avail);
-+	if (unlikely (count == 0)) {
-+		udelay (1);
-+		tmp = readl (&ep->regs->ep_stat);
-+		count = readl (&regs->ep_avail);
-+		/* handled that data already? */
-+		if (count == 0 && (tmp & (1 << NAK_OUT_PACKETS)) == 0)
-+			return 0;
-+	}
-+
-+	tmp = req->req.length - req->req.actual;
-+	if (count > tmp) {
-+		/* as with DMA, data overflow gets flushed */
-+		if ((tmp % ep->ep.maxpacket) != 0) {
-+			ERROR (ep->dev,
-+				"%s out fifo %d bytes, expected %d\n",
-+				ep->ep.name, count, tmp);
-+			req->req.status = -EOVERFLOW;
-+			cleanup = 1;
-+			/* NAK_OUT_PACKETS will be set, so flushing is safe;
-+			 * the next read will start with the next packet
-+			 */
-+		} /* else it's a ZLP, no worries */
-+		count = tmp;
-+	}
-+	req->req.actual += count;
-+
-+	is_short = (count == 0) || ((count % ep->ep.maxpacket) != 0);
-+
-+	VDEBUG (ep->dev, "read %s fifo (OUT) %d bytes%s%s%s req %p %d/%d\n",
-+			ep->ep.name, count, is_short ? " (short)" : "",
-+			cleanup ? " flush" : "", prevent ? " nak" : "",
-+			req, req->req.actual, req->req.length);
-+
-+	while (count >= 4) {
-+		tmp = readl (&regs->ep_data);
-+		cpu_to_le32s (&tmp);
-+		put_unaligned (tmp, (u32 *)buf);
-+		buf += 4;
-+		count -= 4;
-+	}
-+	if (count) {
-+		tmp = readl (&regs->ep_data);
-+		/* LE conversion is implicit here: */
-+		do {
-+			*buf++ = (u8) tmp;
-+			tmp >>= 8;
-+		} while (--count);
-+	}
-+	if (cleanup)
-+		out_flush (ep);
-+	if (prevent) {
-+		writel ((1 << CLEAR_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
-+		(void) readl (&ep->regs->ep_rsp);
-+	}
-+
-+	return is_short || ((req->req.actual == req->req.length)
-+				&& !req->req.zero);
-+}
-+
-+/* fill out dma descriptor to match a given request */
-+static void
-+fill_dma_desc (struct net2280_ep *ep, struct net2280_request *req, int valid)
-+{
-+	struct net2280_dma	*td = req->td;
-+	u32			dmacount = req->req.length;
-+
-+	/* don't let DMA continue after a short OUT packet,
-+	 * so overruns can't affect the next transfer.
-+	 * in case of overruns on max-size packets, we can't
-+	 * stop the fifo from filling but we can flush it.
-+	 */
-+	if (ep->is_in)
-+		dmacount |= (1 << DMA_DIRECTION);
-+	else if ((dmacount % ep->ep.maxpacket) != 0)
-+		dmacount |= (1 << END_OF_CHAIN);
-+
-+	req->valid = valid;
-+	if (valid)
-+		dmacount |= (1 << VALID_BIT);
-+	if (likely(!req->req.no_interrupt || !use_dma_chaining))
-+		dmacount |= (1 << DMA_DONE_INTERRUPT_ENABLE);
-+
-+	/* td->dmadesc = previously set by caller */
-+	td->dmaaddr = cpu_to_le32p (&req->req.dma);
-+
-+	/* 2280 may be polling VALID_BIT through ep->dma->dmadesc */
-+	wmb ();
-+	td->dmacount = cpu_to_le32p (&dmacount);
-+}
-+
-+static const u32 dmactl_default =
-+		  (1 << DMA_SCATTER_GATHER_DONE_INTERRUPT)
-+		| (1 << DMA_CLEAR_COUNT_ENABLE)
-+		/* erratum 0116 workaround part 1 (use POLLING) */
-+		| (POLL_100_USEC << DESCRIPTOR_POLLING_RATE)
-+		| (1 << DMA_VALID_BIT_POLLING_ENABLE)
-+		| (1 << DMA_VALID_BIT_ENABLE)
-+		| (1 << DMA_SCATTER_GATHER_ENABLE)
-+		/* erratum 0116 workaround part 2 (no AUTOSTART) */
-+		| (1 << DMA_ENABLE);
-+
-+static inline void spin_stop_dma (struct net2280_dma_regs *dma)
-+{
-+	handshake (&dma->dmactl, (1 << DMA_ENABLE), 0, 50);
-+}
-+
-+static inline void stop_dma (struct net2280_dma_regs *dma)
-+{
-+	writel (readl (&dma->dmactl) & ~(1 << DMA_ENABLE), &dma->dmactl);
-+	spin_stop_dma (dma);
-+}
-+
-+static void start_queue (struct net2280_ep *ep, u32 dmactl, u32 td_dma)
-+{
-+	struct net2280_dma_regs	*dma = ep->dma;
-+
-+	writel ((1 << VALID_BIT) | (ep->is_in << DMA_DIRECTION),
-+			&dma->dmacount);
-+	writel (readl (&dma->dmastat), &dma->dmastat);
-+
-+	writel (td_dma, &dma->dmadesc);
-+	writel (dmactl, &dma->dmactl);
-+
-+	/* erratum 0116 workaround part 3:  pci arbiter away from net2280 */
-+	(void) readl (&ep->dev->pci->pcimstctl);
-+
-+	writel ((1 << DMA_START), &dma->dmastat);
-+
-+	if (!ep->is_in)
-+		stop_out_naking (ep);
-+}
-+
-+static void start_dma (struct net2280_ep *ep, struct net2280_request *req)
-+{
-+	u32			tmp;
-+	struct net2280_dma_regs	*dma = ep->dma;
-+
-+	/* FIXME can't use DMA for ZLPs */
-+
-+	/* on this path we "know" there's no dma active (yet) */
-+	WARN_ON (readl (&dma->dmactl) & (1 << DMA_ENABLE));
-+	writel (0, &ep->dma->dmactl);
-+
-+	/* previous OUT packet might have been short */
-+	if (!ep->is_in && ((tmp = readl (&ep->regs->ep_stat))
-+		 		& (1 << NAK_OUT_PACKETS)) != 0) {
-+		writel ((1 << SHORT_PACKET_TRANSFERRED_INTERRUPT),
-+			&ep->regs->ep_stat);
-+
-+		tmp = readl (&ep->regs->ep_avail);
-+		if (tmp) {
-+			writel (readl (&dma->dmastat), &dma->dmastat);
-+
-+			/* transfer all/some fifo data */
-+			writel (req->req.dma, &dma->dmaaddr);
-+			tmp = min (tmp, req->req.length);
-+
-+			/* dma irq, faking scatterlist status */
-+			req->td->dmacount = cpu_to_le32 (req->req.length - tmp);
-+			writel ((1 << DMA_DONE_INTERRUPT_ENABLE)
-+				| tmp, &dma->dmacount);
-+			req->td->dmadesc = 0;
-+			req->valid = 1;
-+
-+			writel ((1 << DMA_ENABLE), &dma->dmactl);
-+			writel ((1 << DMA_START), &dma->dmastat);
-+			return;
-+		}
-+	}
-+
-+	tmp = dmactl_default;
-+
-+	/* force packet boundaries between dma requests, but prevent the
-+	 * controller from automagically writing a last "short" packet
-+	 * (zero length) unless the driver explicitly said to do that.
-+	 */
-+	if (ep->is_in) {
-+		if (likely ((req->req.length % ep->ep.maxpacket) != 0
-+				|| req->req.zero)) {
-+			tmp |= (1 << DMA_FIFO_VALIDATE);
-+			ep->in_fifo_validate = 1;
-+		} else
-+			ep->in_fifo_validate = 0;
-+	}
-+
-+	/* init req->td, pointing to the current dummy */
-+	req->td->dmadesc = cpu_to_le32 (ep->td_dma);
-+	fill_dma_desc (ep, req, 1);
-+
-+	if (!use_dma_chaining)
-+		req->td->dmacount |= __constant_cpu_to_le32 (1 << END_OF_CHAIN);
-+
-+	start_queue (ep, tmp, req->td_dma);
-+}
-+
-+static inline void
-+queue_dma (struct net2280_ep *ep, struct net2280_request *req, int valid)
-+{
-+	struct net2280_dma	*end;
-+	dma_addr_t		tmp;
-+
-+	/* swap new dummy for old, link; fill and maybe activate */
-+	end = ep->dummy;
-+	ep->dummy = req->td;
-+	req->td = end;
-+
-+	tmp = ep->td_dma;
-+	ep->td_dma = req->td_dma;
-+	req->td_dma = tmp;
-+
-+	end->dmadesc = cpu_to_le32 (ep->td_dma);
-+
-+	fill_dma_desc (ep, req, valid);
-+}
-+
-+static void
-+done (struct net2280_ep *ep, struct net2280_request *req, int status)
-+{
-+	struct net2280		*dev;
-+	unsigned		stopped = ep->stopped;
-+
-+	list_del_init (&req->queue);
-+
-+	if (req->req.status == -EINPROGRESS)
-+		req->req.status = status;
-+	else
-+		status = req->req.status;
-+
-+	dev = ep->dev;
-+	if (req->mapped) {
-+		pci_unmap_single (dev->pdev, req->req.dma, req->req.length,
-+			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-+		req->req.dma = DMA_ADDR_INVALID;
-+		req->mapped = 0;
-+	}
-+
-+	if (status && status != -ESHUTDOWN)
-+		VDEBUG (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;
-+	spin_unlock (&dev->lock);
-+	req->req.complete (&ep->ep, &req->req);
-+	spin_lock (&dev->lock);
-+	ep->stopped = stopped;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int
-+net2280_queue (struct usb_ep *_ep, struct usb_request *_req, int gfp_flags)
-+{
-+	struct net2280_request	*req;
-+	struct net2280_ep	*ep;
-+	struct net2280		*dev;
-+	unsigned long		flags;
-+
-+	/* we always require a cpu-view buffer, so that we can
-+	 * always use pio (as fallback or whatever).
-+	 */
-+	req = container_of (_req, struct net2280_request, req);
-+	if (!_req || !_req->complete || !_req->buf
-+			|| !list_empty (&req->queue))
-+		return -EINVAL;
-+	if (_req->length > (~0 & DMA_BYTE_COUNT_MASK))
-+		return -EDOM;
-+	ep = container_of (_ep, struct net2280_ep, ep);
-+	if (!_ep || (!ep->desc && ep->num != 0))
-+		return -EINVAL;
-+	dev = ep->dev;
-+	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
-+		return -ESHUTDOWN;
-+
-+	/* FIXME implement PIO fallback for ZLPs with DMA */
-+	if (ep->dma && _req->length == 0)
-+		return -EOPNOTSUPP;
-+
-+	/* set up dma mapping in case the caller didn't */
-+	if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
-+		_req->dma = pci_map_single (dev->pdev, _req->buf, _req->length,
-+			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-+		req->mapped = 1;
-+	}
-+
-+#if 0
-+	VDEBUG (dev, "%s queue req %p, len %d buf %p\n",
-+			_ep->name, _req, _req->length, _req->buf);
-+#endif
-+
-+	spin_lock_irqsave (&dev->lock, flags);
-+
-+	_req->status = -EINPROGRESS;
-+	_req->actual = 0;
-+
-+	/* kickstart this i/o queue? */
-+	if (list_empty (&ep->queue) && !ep->stopped) {
-+		/* use DMA if the endpoint supports it, else pio */
-+		if (ep->dma)
-+			start_dma (ep, req);
-+		else {
-+			/* maybe there's no control data, just status ack */
-+			if (ep->num == 0 && _req->length == 0) {
-+				allow_status (ep);
-+				done (ep, req, 0);
-+				VDEBUG (dev, "%s status ack\n", ep->ep.name);
-+				goto done;
-+			}
-+
-+			/* PIO ... stuff the fifo, or unblock it.  */
-+			if (ep->is_in)
-+				write_fifo (ep, _req);
-+			else if (list_empty (&ep->queue)) {
-+				u32	s;
-+
-+				/* OUT FIFO might have packet(s) buffered */
-+				s = readl (&ep->regs->ep_stat);
-+				if ((s & (1 << FIFO_EMPTY)) == 0) {
-+					/* note:  _req->short_not_ok is
-+					 * ignored here since PIO _always_
-+					 * stops queue advance here, and
-+					 * _req->status doesn't change for
-+					 * short reads (only _req->actual)
-+					 */
-+					if (read_fifo (ep, req)) {
-+						done (ep, req, 0);
-+						if (ep->num == 0)
-+							allow_status (ep);
-+						/* don't queue it */
-+						req = NULL;
-+					} else
-+						s = readl (&ep->regs->ep_stat);
-+				}
-+
-+				/* don't NAK, let the fifo fill */
-+				if (req && (s & (1 << NAK_OUT_PACKETS)))
-+					writel ((1 << CLEAR_NAK_OUT_PACKETS),
-+							&ep->regs->ep_rsp);
-+			}
-+		}
-+
-+	} else if (ep->dma) {
-+		int	valid = 1;
-+
-+		if (ep->is_in) {
-+			int	expect;
-+
-+			/* preventing magic zlps is per-engine state, not
-+			 * per-transfer; irq logic must recover hiccups.
-+			 */
-+			expect = likely (req->req.zero
-+				|| (req->req.length % ep->ep.maxpacket) != 0);
-+			if (expect != ep->in_fifo_validate)
-+				valid = 0;
-+		}
-+		queue_dma (ep, req, valid);
-+
-+	} /* else the irq handler advances the queue. */
-+
-+	if (req)
-+		list_add_tail (&req->queue, &ep->queue);
-+done:
-+	spin_unlock_irqrestore (&dev->lock, flags);
-+
-+	/* pci writes may still be posted */
-+	return 0;
-+}
-+
-+static inline void
-+dma_done (
-+	struct net2280_ep *ep,
-+	struct net2280_request *req,
-+	u32 dmacount,
-+	int status
-+)
-+{
-+	req->req.actual = req->req.length - (DMA_BYTE_COUNT_MASK & dmacount);
-+	done (ep, req, status);
-+}
-+
-+static void restart_dma (struct net2280_ep *ep);
-+
-+static void scan_dma_completions (struct net2280_ep *ep)
-+{
-+	/* only look at descriptors that were "naturally" retired,
-+	 * so fifo and list head state won't matter
-+	 */
-+	while (!list_empty (&ep->queue)) {
-+		struct net2280_request	*req;
-+		u32			tmp;
-+
-+		req = list_entry (ep->queue.next,
-+				struct net2280_request, queue);
-+		if (!req->valid)
-+			break;
-+		rmb ();
-+		tmp = le32_to_cpup (&req->td->dmacount);
-+		if ((tmp & (1 << VALID_BIT)) != 0)
-+			break;
-+
-+		/* SHORT_PACKET_TRANSFERRED_INTERRUPT handles "usb-short"
-+		 * cases where DMA must be aborted; this code handles
-+		 * all non-abort DMA completions.
-+		 */
-+		if (unlikely (req->td->dmadesc == 0)) {
-+			/* paranoia */
-+			tmp = readl (&ep->dma->dmacount);
-+			if (tmp & DMA_BYTE_COUNT_MASK)
-+				break;
-+			/* single transfer mode */
-+			dma_done (ep, req, tmp, 0);
-+			break;
-+		} else if (!ep->is_in
-+				&& (req->req.length % ep->ep.maxpacket) != 0) {
-+			tmp = readl (&ep->regs->ep_stat);
-+
-+			/* AVOID TROUBLE HERE by not issuing short reads from
-+			 * your gadget driver.  That helps avoids errata 0121,
-+			 * 0122, and 0124; not all cases trigger the warning.
-+			 */
-+			if ((tmp & (1 << NAK_OUT_PACKETS)) == 0) {
-+				WARN (ep->dev, "%s lost packet sync!\n",
-+						ep->ep.name);
-+				req->req.status = -EOVERFLOW;
-+			} else if ((tmp = readl (&ep->regs->ep_avail)) != 0) {
-+				/* fifo gets flushed later */
-+				ep->out_overflow = 1;
-+				DEBUG (ep->dev, "%s dma, discard %d len %d\n",
-+						ep->ep.name, tmp,
-+						req->req.length);
-+				req->req.status = -EOVERFLOW;
-+			}
-+		}
-+		dma_done (ep, req, tmp, 0);
-+	}
-+}
-+
-+static void restart_dma (struct net2280_ep *ep)
-+{
-+	struct net2280_request	*req;
-+	u32			dmactl = dmactl_default;
-+
-+	if (ep->stopped)
-+		return;
-+	req = list_entry (ep->queue.next, struct net2280_request, queue);
-+
-+	if (!use_dma_chaining) {
-+		start_dma (ep, req);
-+		return;
-+	}
-+
-+	/* the 2280 will be processing the queue unless queue hiccups after
-+	 * the previous transfer:
-+	 *  IN:   wanted automagic zlp, head doesn't (or vice versa)
-+	 *        DMA_FIFO_VALIDATE doesn't init from dma descriptors.
-+	 *  OUT:  was "usb-short", we must restart.
-+	 */
-+	if (ep->is_in && !req->valid) {
-+		struct net2280_request	*entry, *prev = NULL;
-+		int			reqmode, done = 0;
-+
-+		DEBUG (ep->dev, "%s dma hiccup td %p\n", ep->ep.name, req->td);
-+		ep->in_fifo_validate = likely (req->req.zero
-+			|| (req->req.length % ep->ep.maxpacket) != 0);
-+		if (ep->in_fifo_validate)
-+			dmactl |= (1 << DMA_FIFO_VALIDATE);
-+		list_for_each_entry (entry, &ep->queue, queue) {
-+			u32		dmacount;
-+
-+			if (entry == req)
-+				continue;
-+			dmacount = entry->td->dmacount;
-+			if (!done) {
-+				reqmode = likely (entry->req.zero
-+					|| (entry->req.length
-+						% ep->ep.maxpacket) != 0);
-+				if (reqmode == ep->in_fifo_validate) {
-+					entry->valid = 1;
-+					dmacount |= valid_bit;
-+					entry->td->dmacount = dmacount;
-+					prev = entry;
-+					continue;
-+				} else {
-+					/* force a hiccup */
-+					prev->td->dmacount |= dma_done_ie;
-+					done = 1;
-+				}
-+			}
-+
-+			/* walk the rest of the queue so unlinks behave */
-+			entry->valid = 0;
-+			dmacount &= ~valid_bit;
-+			entry->td->dmacount = dmacount;
-+			prev = entry;
-+		}
-+	}
-+
-+	writel (0, &ep->dma->dmactl);
-+	start_queue (ep, dmactl, req->td_dma);
-+}
-+
-+static void abort_dma (struct net2280_ep *ep)
-+{
-+	/* abort the current transfer */
-+	if (likely (!list_empty (&ep->queue))) {
-+		/* FIXME work around errata 0121, 0122, 0124 */
-+		writel ((1 << DMA_ABORT), &ep->dma->dmastat);
-+		spin_stop_dma (ep->dma);
-+	} else
-+		stop_dma (ep->dma);
-+	scan_dma_completions (ep);
-+}
-+
-+/* dequeue ALL requests */
-+static void nuke (struct net2280_ep *ep)
-+{
-+	struct net2280_request	*req;
-+
-+	/* called with spinlock held */
-+	ep->stopped = 1;
-+	if (ep->dma)
-+		abort_dma (ep);
-+	while (!list_empty (&ep->queue)) {
-+		req = list_entry (ep->queue.next,
-+				struct net2280_request,
-+				queue);
-+		done (ep, req, -ESHUTDOWN);
-+	}
-+}
-+
-+/* dequeue JUST ONE request */
-+static int net2280_dequeue (struct usb_ep *_ep, struct usb_request *_req)
-+{
-+	struct net2280_ep	*ep;
-+	struct net2280_request	*req;
-+	unsigned long		flags;
-+	u32			dmactl;
-+	int			stopped;
-+
-+	ep = container_of (_ep, struct net2280_ep, ep);
-+	if (!_ep || (!ep->desc && ep->num != 0) || !_req)
-+		return -EINVAL;
-+
-+	spin_lock_irqsave (&ep->dev->lock, flags);
-+	stopped = ep->stopped;
-+
-+	/* quiesce dma while we patch the queue */
-+	dmactl = 0;
-+	ep->stopped = 1;
-+	if (ep->dma) {
-+		dmactl = readl (&ep->dma->dmactl);
-+		/* WARNING erratum 0127 may kick in ... */
-+		stop_dma (ep->dma);
-+		scan_dma_completions (ep);
-+	}
-+
-+	/* make sure it's still queued on this endpoint */
-+	list_for_each_entry (req, &ep->queue, queue) {
-+		if (&req->req == _req)
-+			break;
-+	}
-+	if (&req->req != _req) {
-+		spin_unlock_irqrestore (&ep->dev->lock, flags);
-+		return -EINVAL;
-+	}
-+
-+	/* queue head may be partially complete. */
-+	if (ep->queue.next == &req->queue) {
-+		if (ep->dma) {
-+			DEBUG (ep->dev, "unlink (%s) dma\n", _ep->name);
-+			_req->status = -ECONNRESET;
-+			abort_dma (ep);
-+			if (likely (ep->queue.next == &req->queue)) {
-+				// NOTE: misreports single-transfer mode
-+				req->td->dmacount = 0;	/* invalidate */
-+				dma_done (ep, req,
-+					readl (&ep->dma->dmacount),
-+					-ECONNRESET);
-+			}
-+		} else {
-+			DEBUG (ep->dev, "unlink (%s) pio\n", _ep->name);
-+			done (ep, req, -ECONNRESET);
-+		}
-+		req = NULL;
-+
-+	/* patch up hardware chaining data */
-+	} else if (ep->dma && use_dma_chaining) {
-+		if (req->queue.prev == ep->queue.next) {
-+			writel (le32_to_cpu (req->td->dmadesc),
-+				&ep->dma->dmadesc);
-+			if (req->td->dmacount & dma_done_ie)
-+				writel (readl (&ep->dma->dmacount)
-+						| dma_done_ie,
-+					&ep->dma->dmacount);
-+		} else {
-+			struct net2280_request	*prev;
-+
-+			prev = list_entry (req->queue.prev,
-+				struct net2280_request, queue);
-+			prev->td->dmadesc = req->td->dmadesc;
-+			if (req->td->dmacount & dma_done_ie)
-+				prev->td->dmacount |= dma_done_ie;
-+		}
-+	}
-+
-+	if (req)
-+		done (ep, req, -ECONNRESET);
-+	ep->stopped = stopped;
-+
-+	if (ep->dma) {
-+		/* turn off dma on inactive queues */
-+		if (list_empty (&ep->queue))
-+			stop_dma (ep->dma);
-+		else if (!ep->stopped) {
-+			/* resume current request, or start new one */
-+			if (req)
-+				writel (dmactl, &ep->dma->dmactl);
-+			else
-+				start_dma (ep, list_entry (ep->queue.next,
-+					struct net2280_request, queue));
-+		}
-+	}
-+
-+	spin_unlock_irqrestore (&ep->dev->lock, flags);
-+	return req ? 0 : -EOPNOTSUPP;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int net2280_fifo_status (struct usb_ep *_ep);
-+
-+static int
-+net2280_set_halt (struct usb_ep *_ep, int value)
-+{
-+	struct net2280_ep	*ep;
-+	unsigned long		flags;
-+	int			retval = 0;
-+
-+	ep = container_of (_ep, struct net2280_ep, ep);
-+	if (!_ep || (!ep->desc && ep->num != 0))
-+		return -EINVAL;
-+	if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
-+		return -ESHUTDOWN;
-+	if (ep->desc /* not ep0 */ && (ep->desc->bmAttributes & 0x03)
-+						== USB_ENDPOINT_XFER_ISOC)
-+		return -EINVAL;
-+
-+	spin_lock_irqsave (&ep->dev->lock, flags);
-+	if (!list_empty (&ep->queue))
-+		retval = -EAGAIN;
-+	else if (ep->is_in && value && net2280_fifo_status (_ep) != 0)
-+		retval = -EAGAIN;
-+	else {
-+		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->num == 0)
-+				ep->dev->protocol_stall = 1;
-+			else
-+				set_halt (ep);
-+		} else
-+			clear_halt (ep);
-+		(void) readl (&ep->regs->ep_rsp);
-+	}
-+	spin_unlock_irqrestore (&ep->dev->lock, flags);
-+
-+	return retval;
-+}
-+
-+static int
-+net2280_fifo_status (struct usb_ep *_ep)
-+{
-+	struct net2280_ep	*ep;
-+	u32			avail;
-+
-+	ep = container_of (_ep, struct net2280_ep, ep);
-+	if (!_ep || (!ep->desc && ep->num != 0))
-+		return -ENODEV;
-+	if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
-+		return -ESHUTDOWN;
-+
-+	avail = readl (&ep->regs->ep_avail) & ((1 << 12) - 1);
-+	if (avail > ep->fifo_size)
-+		return -EOVERFLOW;
-+	if (ep->is_in)
-+		avail = ep->fifo_size - avail;
-+	return avail;
-+}
-+
-+static void
-+net2280_fifo_flush (struct usb_ep *_ep)
-+{
-+	struct net2280_ep	*ep;
-+
-+	ep = container_of (_ep, struct net2280_ep, ep);
-+	if (!_ep || (!ep->desc && ep->num != 0))
-+		return;
-+	if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
-+		return;
-+
-+	writel ((1 << FIFO_FLUSH), &ep->regs->ep_stat);
-+	(void) readl (&ep->regs->ep_rsp);
-+}
-+
-+static struct usb_ep_ops net2280_ep_ops = {
-+	.enable		= net2280_enable,
-+	.disable	= net2280_disable,
-+
-+	.alloc_request	= net2280_alloc_request,
-+	.free_request	= net2280_free_request,
-+
-+	.alloc_buffer	= net2280_alloc_buffer,
-+	.free_buffer	= net2280_free_buffer,
-+
-+	.queue		= net2280_queue,
-+	.dequeue	= net2280_dequeue,
-+
-+	.set_halt	= net2280_set_halt,
-+	.fifo_status	= net2280_fifo_status,
-+	.fifo_flush	= net2280_fifo_flush,
-+};
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int net2280_get_frame (struct usb_gadget *_gadget)
-+{
-+	struct net2280		*dev;
-+	unsigned long		flags;
-+	u16			retval;
-+
-+	if (!_gadget)
-+		return -ENODEV;
-+	dev = container_of (_gadget, struct net2280, gadget);
-+	spin_lock_irqsave (&dev->lock, flags);
-+	retval = get_idx_reg (dev->regs, REG_FRAME) & 0x03ff;
-+	spin_unlock_irqrestore (&dev->lock, flags);
-+	return retval;
-+}
-+
-+static int net2280_wakeup (struct usb_gadget *_gadget)
-+{
-+	struct net2280		*dev;
-+	u32			tmp;
-+	unsigned long		flags;
-+
-+	if (!_gadget)
-+		return 0;
-+	dev = container_of (_gadget, struct net2280, gadget);
-+
-+	spin_lock_irqsave (&dev->lock, flags);
-+	tmp = readl (&dev->usb->usbctl);
-+	if (tmp & (1 << DEVICE_REMOTE_WAKEUP_ENABLE))
-+		writel (1 << GENERATE_RESUME, &dev->usb->usbstat);
-+	spin_unlock_irqrestore (&dev->lock, flags);
-+
-+	/* pci writes may still be posted */
-+	return 0;
-+}
-+
-+static int net2280_set_selfpowered (struct usb_gadget *_gadget, int value)
-+{
-+	struct net2280		*dev;
-+	u32			tmp;
-+	unsigned long		flags;
-+
-+	if (!_gadget)
-+		return 0;
-+	dev = container_of (_gadget, struct net2280, gadget);
-+
-+	spin_lock_irqsave (&dev->lock, flags);
-+	tmp = readl (&dev->usb->usbctl);
-+	if (value)
-+		tmp |= (1 << SELF_POWERED_STATUS);
-+	else
-+		tmp &= ~(1 << SELF_POWERED_STATUS);
-+	writel (tmp, &dev->usb->usbctl);
-+	spin_unlock_irqrestore (&dev->lock, flags);
-+
-+	return 0;
-+}
-+
-+static int net2280_pullup(struct usb_gadget *_gadget, int is_on)
-+{
-+	struct net2280  *dev;
-+	u32             tmp;
-+	unsigned long   flags;
-+
-+	if (!_gadget)
-+		return -ENODEV;
-+	dev = container_of (_gadget, struct net2280, gadget);
-+
-+	spin_lock_irqsave (&dev->lock, flags);
-+	tmp = readl (&dev->usb->usbctl);
-+	dev->softconnect = (is_on != 0);
-+	if (is_on)
-+		tmp |= (1 << USB_DETECT_ENABLE);
-+	else
-+		tmp &= ~(1 << USB_DETECT_ENABLE);
-+	writel (tmp, &dev->usb->usbctl);
-+	spin_unlock_irqrestore (&dev->lock, flags);
-+
-+	return 0;
-+}
-+
-+static const struct usb_gadget_ops net2280_ops = {
-+	.get_frame	= net2280_get_frame,
-+	.wakeup		= net2280_wakeup,
-+	.set_selfpowered = net2280_set_selfpowered,
-+	.pullup		= net2280_pullup,
-+};
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#ifdef	USE_SYSFS_DEBUG_FILES
-+
-+/* "function" sysfs attribute */
-+static ssize_t
-+show_function (struct device *_dev, char *buf)
-+{
-+	struct net2280	*dev = dev_get_drvdata (_dev);
-+
-+	if (!dev->driver
-+			|| !dev->driver->function
-+			|| strlen (dev->driver->function) > PAGE_SIZE)
-+		return 0;
-+	return snprintf (buf, PAGE_SIZE, "%s\n", dev->driver->function);
-+}
-+static DEVICE_ATTR (function, S_IRUGO, show_function, NULL);
-+
-+static ssize_t
-+show_registers (struct device *_dev, char *buf)
-+{
-+	struct net2280		*dev;
-+	char			*next;
-+	unsigned		size, t;
-+	unsigned long		flags;
-+	int			i;
-+	u32			t1, t2;
-+	char			*s;
-+
-+	dev = dev_get_drvdata (_dev);
-+	next = buf;
-+	size = PAGE_SIZE;
-+	spin_lock_irqsave (&dev->lock, flags);
-+
-+	if (dev->driver)
-+		s = dev->driver->driver.name;
-+	else
-+		s = "(none)";
-+
-+	/* Main Control Registers */
-+	t = snprintf (next, size, "%s version " DRIVER_VERSION
-+			", chiprev %04x, dma %s\n\n"
-+			"devinit %03x fifoctl %08x gadget '%s'\n"
-+			"pci irqenb0 %02x irqenb1 %08x "
-+			"irqstat0 %04x irqstat1 %08x\n",
-+			driver_name, dev->chiprev,
-+			use_dma
-+				? (use_dma_chaining ? "chaining" : "enabled")
-+				: "disabled",
-+			readl (&dev->regs->devinit),
-+			readl (&dev->regs->fifoctl),
-+			s,
-+			readl (&dev->regs->pciirqenb0),
-+			readl (&dev->regs->pciirqenb1),
-+			readl (&dev->regs->irqstat0),
-+			readl (&dev->regs->irqstat1));
-+	size -= t;
-+	next += t;
-+
-+	/* USB Control Registers */
-+	t1 = readl (&dev->usb->usbctl);
-+	t2 = readl (&dev->usb->usbstat);
-+	if (t1 & (1 << VBUS_PIN)) {
-+		if (t2 & (1 << HIGH_SPEED))
-+			s = "high speed";
-+		else if (dev->gadget.speed == USB_SPEED_UNKNOWN)
-+			s = "powered";
-+		else
-+			s = "full speed";
-+		/* full speed bit (6) not working?? */
-+	} else
-+			s = "not attached";
-+	t = snprintf (next, size,
-+			"stdrsp %08x usbctl %08x usbstat %08x "
-+				"addr 0x%02x (%s)\n",
-+			readl (&dev->usb->stdrsp), t1, t2,
-+			readl (&dev->usb->ouraddr), s);
-+	size -= t;
-+	next += t;
-+
-+	/* PCI Master Control Registers */
-+
-+	/* DMA Control Registers */
-+
-+	/* Configurable EP Control Registers */
-+	for (i = 0; i < 7; i++) {
-+		struct net2280_ep	*ep;
-+
-+		ep = &dev->ep [i];
-+		if (i && !ep->desc)
-+			continue;
-+
-+		t1 = readl (&ep->regs->ep_cfg);
-+		t2 = readl (&ep->regs->ep_rsp) & 0xff;
-+		t = snprintf (next, size,
-+				"\n%s\tcfg %05x rsp (%02x) %s%s%s%s%s%s%s%s"
-+					"irqenb %02x\n",
-+				ep->ep.name, t1, t2,
-+				(t2 & (1 << CLEAR_NAK_OUT_PACKETS))
-+					? "NAK " : "",
-+				(t2 & (1 << CLEAR_EP_HIDE_STATUS_PHASE))
-+					? "hide " : "",
-+				(t2 & (1 << CLEAR_EP_FORCE_CRC_ERROR))
-+					? "CRC " : "",
-+				(t2 & (1 << CLEAR_INTERRUPT_MODE))
-+					? "interrupt " : "",
-+				(t2 & (1<<CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE))
-+					? "status " : "",
-+				(t2 & (1 << CLEAR_NAK_OUT_PACKETS_MODE))
-+					? "NAKmode " : "",
-+				(t2 & (1 << CLEAR_ENDPOINT_TOGGLE))
-+					? "DATA1 " : "DATA0 ",
-+				(t2 & (1 << CLEAR_ENDPOINT_HALT))
-+					? "HALT " : "",
-+				readl (&ep->regs->ep_irqenb));
-+		size -= t;
-+		next += t;
-+
-+		t = snprintf (next, size,
-+				"\tstat %08x avail %04x "
-+				"(ep%d%s-%s)%s\n",
-+				readl (&ep->regs->ep_stat),
-+				readl (&ep->regs->ep_avail),
-+				t1 & 0x0f, DIR_STRING (t1),
-+				type_string (t1 >> 8),
-+				ep->stopped ? "*" : "");
-+		size -= t;
-+		next += t;
-+
-+		if (!ep->dma)
-+			continue;
-+
-+		t = snprintf (next, size,
-+				"  dma\tctl %08x stat %08x count %08x\n"
-+				"\taddr %08x desc %08x\n",
-+				readl (&ep->dma->dmactl),
-+				readl (&ep->dma->dmastat),
-+				readl (&ep->dma->dmacount),
-+				readl (&ep->dma->dmaaddr),
-+				readl (&ep->dma->dmadesc));
-+		size -= t;
-+		next += t;
-+
-+	}
-+
-+	/* Indexed Registers */
-+		// none yet 
-+
-+	/* Statistics */
-+	t = snprintf (next, size, "\nirqs:  ");
-+	size -= t;
-+	next += t;
-+	for (i = 0; i < 7; i++) {
-+		struct net2280_ep	*ep;
-+
-+		ep = &dev->ep [i];
-+		if (i && !ep->irqs)
-+			continue;
-+		t = snprintf (next, size, " %s/%lu", ep->ep.name, ep->irqs);
-+		size -= t;
-+		next += t;
-+
-+	}
-+	t = snprintf (next, size, "\n");
-+	size -= t;
-+	next += t;
-+
-+	spin_unlock_irqrestore (&dev->lock, flags);
-+
-+	return PAGE_SIZE - size;
-+}
-+static DEVICE_ATTR (registers, S_IRUGO, show_registers, NULL);
-+
-+static ssize_t
-+show_queues (struct device *_dev, char *buf)
-+{
-+	struct net2280		*dev;
-+	char			*next;
-+	unsigned		size;
-+	unsigned long		flags;
-+	int			i;
-+
-+	dev = dev_get_drvdata (_dev);
-+	next = buf;
-+	size = PAGE_SIZE;
-+	spin_lock_irqsave (&dev->lock, flags);
-+
-+	for (i = 0; i < 7; i++) {
-+		struct net2280_ep		*ep = &dev->ep [i];
-+		struct net2280_request		*req;
-+		int				t;
-+
-+		if (i != 0) {
-+			const struct usb_endpoint_descriptor	*d;
-+
-+			d = ep->desc;
-+			if (!d)
-+				continue;
-+			t = d->bEndpointAddress;
-+			t = snprintf (next, size,
-+				"\n%s (ep%d%s-%s) max %04x %s fifo %d\n",
-+				ep->ep.name, t & USB_ENDPOINT_NUMBER_MASK,
-+				(t & USB_DIR_IN) ? "in" : "out",
-+				({ char *val;
-+				 switch (d->bmAttributes & 0x03) {
-+				 case USB_ENDPOINT_XFER_BULK:
-+				 	val = "bulk"; break;
-+				 case USB_ENDPOINT_XFER_INT:
-+				 	val = "intr"; break;
-+				 default:
-+				 	val = "iso"; break;
-+				 }; val; }),
-+				le16_to_cpu (d->wMaxPacketSize) & 0x1fff,
-+				ep->dma ? "dma" : "pio", ep->fifo_size
-+				);
-+		} else /* ep0 should only have one transfer queued */
-+			t = snprintf (next, size, "ep0 max 64 pio %s\n",
-+					ep->is_in ? "in" : "out");
-+		if (t <= 0 || t > size)
-+			goto done;
-+		size -= t;
-+		next += t;
-+
-+		if (list_empty (&ep->queue)) {
-+			t = snprintf (next, size, "\t(nothing queued)\n");
-+			if (t <= 0 || t > size)
-+				goto done;
-+			size -= t;
-+			next += t;
-+			continue;
-+		}
-+		list_for_each_entry (req, &ep->queue, queue) {
-+			if (ep->dma && req->td_dma == readl (&ep->dma->dmadesc))
-+				t = snprintf (next, size,
-+					"\treq %p len %d/%d "
-+					"buf %p (dmacount %08x)\n",
-+					&req->req, req->req.actual,
-+					req->req.length, req->req.buf,
-+					readl (&ep->dma->dmacount));
-+			else
-+				t = snprintf (next, size,
-+					"\treq %p len %d/%d buf %p\n",
-+					&req->req, req->req.actual,
-+					req->req.length, req->req.buf);
-+			if (t <= 0 || t > size)
-+				goto done;
-+			size -= t;
-+			next += t;
-+
-+			if (ep->dma) {
-+				struct net2280_dma	*td;
-+
-+				td = req->td;
-+				t = snprintf (next, size, "\t    td %08x "
-+					" count %08x buf %08x desc %08x\n",
-+					req->td_dma, td->dmacount,
-+					td->dmaaddr, td->dmadesc);
-+				if (t <= 0 || t > size)
-+					goto done;
-+				size -= t;
-+				next += t;
-+			}
-+		}
-+	}
-+
-+done:
-+	spin_unlock_irqrestore (&dev->lock, flags);
-+	return PAGE_SIZE - size;
-+}
-+static DEVICE_ATTR (queues, S_IRUGO, show_queues, NULL);
-+
-+
-+#else
-+
-+#define device_create_file(a,b)	do {} while (0)
-+#define device_remove_file	device_create_file
-+
-+#endif
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* another driver-specific mode might be a request type doing dma
-+ * to/from another device fifo instead of to/from memory.
-+ */
-+
-+static void set_fifo_mode (struct net2280 *dev, int mode)
-+{
-+	/* keeping high bits preserves BAR2 */
-+	writel ((0xffff << PCI_BASE2_RANGE) | mode, &dev->regs->fifoctl);
-+
-+	/* always ep-{a,b,e,f} ... maybe not ep-c or ep-d */
-+	INIT_LIST_HEAD (&dev->gadget.ep_list);
-+	list_add_tail (&dev->ep [1].ep.ep_list, &dev->gadget.ep_list);
-+	list_add_tail (&dev->ep [2].ep.ep_list, &dev->gadget.ep_list);
-+	switch (mode) {
-+	case 0:
-+		list_add_tail (&dev->ep [3].ep.ep_list, &dev->gadget.ep_list);
-+		list_add_tail (&dev->ep [4].ep.ep_list, &dev->gadget.ep_list);
-+		dev->ep [1].fifo_size = dev->ep [2].fifo_size = 1024;
-+		break;
-+	case 1:
-+		dev->ep [1].fifo_size = dev->ep [2].fifo_size = 2048;
-+		break;
-+	case 2:
-+		list_add_tail (&dev->ep [3].ep.ep_list, &dev->gadget.ep_list);
-+		dev->ep [1].fifo_size = 2048;
-+		dev->ep [2].fifo_size = 1024;
-+		break;
-+	}
-+	/* fifo sizes for ep0, ep-c, ep-d, ep-e, and ep-f never change */
-+	list_add_tail (&dev->ep [5].ep.ep_list, &dev->gadget.ep_list);
-+	list_add_tail (&dev->ep [6].ep.ep_list, &dev->gadget.ep_list);
-+}
-+
-+/**
-+ * net2280_set_fifo_mode - change allocation of fifo buffers
-+ * @gadget: access to the net2280 device that will be updated
-+ * @mode: 0 for default, four 1kB buffers (ep-a through ep-d);
-+ * 	1 for two 2kB buffers (ep-a and ep-b only);
-+ * 	2 for one 2kB buffer (ep-a) and two 1kB ones (ep-b, ep-c).
-+ *
-+ * returns zero on success, else negative errno.  when this succeeds,
-+ * the contents of gadget->ep_list may have changed.
-+ *
-+ * you may only call this function when endpoints a-d are all disabled.
-+ * use it whenever extra hardware buffering can help performance, such
-+ * as before enabling "high bandwidth" interrupt endpoints that use
-+ * maxpacket bigger than 512 (when double buffering would otherwise
-+ * be unavailable).
-+ */
-+int net2280_set_fifo_mode (struct usb_gadget *gadget, int mode)
-+{
-+	int			i;
-+	struct net2280		*dev;
-+	int			status = 0;
-+	unsigned long		flags;
-+
-+	if (!gadget)
-+		return -ENODEV;
-+	dev = container_of (gadget, struct net2280, gadget);
-+
-+	spin_lock_irqsave (&dev->lock, flags);
-+
-+	for (i = 1; i <= 4; i++)
-+		if (dev->ep [i].desc) {
-+			status = -EINVAL;
-+			break;
-+		}
-+	if (mode < 0 || mode > 2)
-+		status = -EINVAL;
-+	if (status == 0)
-+		set_fifo_mode (dev, mode);
-+	spin_unlock_irqrestore (&dev->lock, flags);
-+
-+	if (status == 0) {
-+		if (mode == 1)
-+			DEBUG (dev, "fifo:  ep-a 2K, ep-b 2K\n");
-+		else if (mode == 2)
-+			DEBUG (dev, "fifo:  ep-a 2K, ep-b 1K, ep-c 1K\n");
-+		/* else all are 1K */
-+	}
-+	return status;
-+}
-+EXPORT_SYMBOL (net2280_set_fifo_mode);
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* keeping it simple:
-+ * - one bus driver, initted first;
-+ * - one function driver, initted second
-+ *
-+ * most of the work to support multiple net2280 controllers would
-+ * be to associate this gadget driver (yes?) with all of them, or
-+ * perhaps to bind specific drivers to specific devices.
-+ */
-+
-+static struct net2280	*the_controller;
-+
-+static void usb_reset (struct net2280 *dev)
-+{
-+	u32	tmp;
-+
-+	dev->gadget.speed = USB_SPEED_UNKNOWN;
-+	(void) readl (&dev->usb->usbctl);
-+
-+	net2280_led_init (dev);
-+
-+	/* disable automatic responses, and irqs */
-+	writel (0, &dev->usb->stdrsp);
-+	writel (0, &dev->regs->pciirqenb0);
-+	writel (0, &dev->regs->pciirqenb1);
-+
-+	/* clear old dma and irq state */
-+	for (tmp = 0; tmp < 4; tmp++) {
-+		struct net2280_ep	*ep = &dev->ep [tmp + 1];
-+
-+		if (ep->dma)
-+			abort_dma (ep);
-+	}
-+	writel (~0, &dev->regs->irqstat0),
-+	writel (~(1 << SUSPEND_REQUEST_INTERRUPT), &dev->regs->irqstat1),
-+
-+	/* reset, and enable pci */
-+	tmp = readl (&dev->regs->devinit)
-+		| (1 << PCI_ENABLE)
-+		| (1 << FIFO_SOFT_RESET)
-+		| (1 << USB_SOFT_RESET)
-+		| (1 << M8051_RESET);
-+	writel (tmp, &dev->regs->devinit);
-+
-+	/* standard fifo and endpoint allocations */
-+	set_fifo_mode (dev, (fifo_mode <= 2) ? fifo_mode : 0);
-+}
-+
-+static void usb_reinit (struct net2280 *dev)
-+{
-+	u32	tmp;
-+	int	init_dma;
-+
-+	/* use_dma changes are ignored till next device re-init */
-+	init_dma = use_dma;
-+
-+	/* basic endpoint init */
-+	for (tmp = 0; tmp < 7; tmp++) {
-+		struct net2280_ep	*ep = &dev->ep [tmp];
-+
-+		ep->ep.name = ep_name [tmp];
-+		ep->dev = dev;
-+		ep->num = tmp;
-+
-+		if (tmp > 0 && tmp <= 4) {
-+			ep->fifo_size = 1024;
-+			if (init_dma)
-+				ep->dma = &dev->dma [tmp - 1];
-+		} else
-+			ep->fifo_size = 64;
-+		ep->regs = &dev->epregs [tmp];
-+		ep_reset (dev->regs, ep);
-+	}
-+	dev->ep [0].ep.maxpacket = 64;
-+	dev->ep [5].ep.maxpacket = 64;
-+	dev->ep [6].ep.maxpacket = 64;
-+
-+	dev->gadget.ep0 = &dev->ep [0].ep;
-+	dev->ep [0].stopped = 0;
-+	INIT_LIST_HEAD (&dev->gadget.ep0->ep_list);
-+
-+	/* we want to prevent lowlevel/insecure access from the USB host,
-+	 * but erratum 0119 means this enable bit is ignored
-+	 */
-+	for (tmp = 0; tmp < 5; tmp++)
-+		writel (EP_DONTUSE, &dev->dep [tmp].dep_cfg);
-+}
-+
-+static void ep0_start (struct net2280 *dev)
-+{
-+	writel (  (1 << CLEAR_EP_HIDE_STATUS_PHASE)
-+		| (1 << CLEAR_NAK_OUT_PACKETS)
-+		| (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
-+		, &dev->epregs [0].ep_rsp);
-+
-+	/*
-+	 * hardware optionally handles a bunch of standard requests
-+	 * that the API hides from drivers anyway.  have it do so.
-+	 * endpoint status/features are handled in software, to
-+	 * help pass tests for some dubious behavior.
-+	 */
-+	writel (  (1 << SET_TEST_MODE)
-+		| (1 << SET_ADDRESS)
-+		| (1 << DEVICE_SET_CLEAR_DEVICE_REMOTE_WAKEUP)
-+		| (1 << GET_DEVICE_STATUS)
-+		| (1 << GET_INTERFACE_STATUS)
-+		, &dev->usb->stdrsp);
-+	writel (  (1 << USB_ROOT_PORT_WAKEUP_ENABLE)
-+		| (1 << SELF_POWERED_USB_DEVICE)
-+		/* erratum 0102 workaround */
-+		| ((dev->chiprev == 0100) ? 0 : 1) << SUSPEND_IMMEDIATELY
-+		| (1 << REMOTE_WAKEUP_SUPPORT)
-+		| (dev->softconnect << USB_DETECT_ENABLE)
-+		| (1 << SELF_POWERED_STATUS)
-+		, &dev->usb->usbctl);
-+
-+	/* enable irqs so we can see ep0 and general operation  */
-+	writel (  (1 << SETUP_PACKET_INTERRUPT_ENABLE)
-+		| (1 << ENDPOINT_0_INTERRUPT_ENABLE)
-+		, &dev->regs->pciirqenb0);
-+	writel (  (1 << PCI_INTERRUPT_ENABLE)
-+		| (1 << PCI_MASTER_ABORT_RECEIVED_INTERRUPT_ENABLE)
-+		| (1 << PCI_TARGET_ABORT_RECEIVED_INTERRUPT_ENABLE)
-+		| (1 << PCI_RETRY_ABORT_INTERRUPT_ENABLE)
-+		| (1 << VBUS_INTERRUPT_ENABLE)
-+		| (1 << ROOT_PORT_RESET_INTERRUPT_ENABLE)
-+		| (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE)
-+		, &dev->regs->pciirqenb1);
-+
-+	/* don't leave any writes posted */
-+	(void) readl (&dev->usb->usbctl);
-+}
-+
-+/* 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 net2280		*dev = the_controller;
-+	int			retval;
-+	unsigned		i;
-+
-+	/* insist on high speed support from the driver, since
-+	 * (dev->usb->xcvrdiag & FORCE_FULL_SPEED_MODE)
-+	 * "must not be used in normal operation"
-+	 */
-+	if (!driver
-+			|| driver->speed != USB_SPEED_HIGH
-+			|| !driver->bind
-+			|| !driver->unbind
-+			|| !driver->setup)
-+		return -EINVAL;
-+	if (!dev)
-+		return -ENODEV;
-+	if (dev->driver)
-+		return -EBUSY;
-+
-+	for (i = 0; i < 7; i++)
-+		dev->ep [i].irqs = 0;
-+
-+	/* hook up the driver ... */
-+	dev->softconnect = 1;
-+	dev->driver = driver;
-+	retval = driver->bind (&dev->gadget);
-+	if (retval) {
-+		DEBUG (dev, "bind to driver %s --> %d\n",
-+				driver->driver.name, retval);
-+		dev->driver = 0;
-+		return retval;
-+	}
-+
-+	/* ... then enable host detection and ep0; and we're ready
-+	 * for set_configuration as well as eventual disconnect.
-+	 */
-+	net2280_led_active (dev, 1);
-+	ep0_start (dev);
-+
-+	DEBUG (dev, "%s ready, usbctl %08x stdrsp %08x\n",
-+			driver->driver.name,
-+			readl (&dev->usb->usbctl),
-+			readl (&dev->usb->stdrsp));
-+
-+	/* pci writes may still be posted */
-+	return 0;
-+}
-+EXPORT_SYMBOL (usb_gadget_register_driver);
-+
-+static void
-+stop_activity (struct net2280 *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;
-+
-+	/* stop hardware; prevent new request submissions;
-+	 * and kill any outstanding requests.
-+	 */
-+	usb_reset (dev);
-+	for (i = 0; i < 7; i++)
-+		nuke (&dev->ep [i]);
-+
-+	/* report disconnect; the driver is already quiesced */
-+	if (driver) {
-+		spin_unlock (&dev->lock);
-+		driver->disconnect (&dev->gadget);
-+		spin_lock (&dev->lock);
-+	}
-+
-+	usb_reinit (dev);
-+}
-+
-+int usb_gadget_unregister_driver (struct usb_gadget_driver *driver)
-+{
-+	struct net2280	*dev = the_controller;
-+	unsigned long	flags;
-+
-+	if (!dev)
-+		return -ENODEV;
-+	if (!driver || driver != dev->driver)
-+		return -EINVAL;
-+
-+	spin_lock_irqsave (&dev->lock, flags);
-+	stop_activity (dev, driver);
-+	spin_unlock_irqrestore (&dev->lock, flags);
-+
-+	driver->unbind (&dev->gadget);
-+	dev->driver = 0;
-+
-+	net2280_led_active (dev, 0);
-+
-+	DEBUG (dev, "unregistered driver '%s'\n", driver->driver.name);
-+	return 0;
-+}
-+EXPORT_SYMBOL (usb_gadget_unregister_driver);
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* handle ep0, ep-e, ep-f with 64 byte packets: packet per irq.
-+ * also works for dma-capable endpoints, in pio mode or just
-+ * to manually advance the queue after short OUT transfers.
-+ */
-+static void handle_ep_small (struct net2280_ep *ep)
-+{
-+	struct net2280_request	*req;
-+	u32			t;
-+	/* 0 error, 1 mid-data, 2 done */
-+	int			mode = 1;
-+
-+	if (!list_empty (&ep->queue))
-+		req = list_entry (ep->queue.next,
-+			struct net2280_request, queue);
-+	else
-+		req = NULL;
-+
-+	/* ack all, and handle what we care about */
-+	t = readl (&ep->regs->ep_stat);
-+	ep->irqs++;
-+#if 0
-+	VDEBUG (ep->dev, "%s ack ep_stat %08x, req %p\n",
-+			ep->ep.name, t, req ? &req->req : 0);
-+#endif
-+	writel (t & ~(1 << NAK_OUT_PACKETS), &ep->regs->ep_stat);
-+
-+	/* for ep0, monitor token irqs to catch data stage length errors
-+	 * and to synchronize on status.
-+	 *
-+	 * also, to defer reporting of protocol stalls ... here's where
-+	 * data or status first appears, handling stalls here should never
-+	 * cause trouble on the host side..
-+	 *
-+	 * control requests could be slightly faster without token synch for
-+	 * status, but status can jam up that way.
-+	 */
-+	if (unlikely (ep->num == 0)) {
-+		if (ep->is_in) {
-+			/* status; stop NAKing */
-+			if (t & (1 << DATA_OUT_PING_TOKEN_INTERRUPT)) {
-+				if (ep->dev->protocol_stall) {
-+					ep->stopped = 1;
-+					set_halt (ep);
-+				}
-+				if (!req)
-+					allow_status (ep);
-+				mode = 2;
-+			/* reply to extra IN data tokens with a zlp */
-+			} else if (t & (1 << DATA_IN_TOKEN_INTERRUPT)) {
-+				if (ep->dev->protocol_stall) {
-+					ep->stopped = 1;
-+					set_halt (ep);
-+					mode = 2;
-+				} else if (!req && ep->stopped)
-+					write_fifo (ep, NULL);
-+			}
-+		} else {
-+			/* status; stop NAKing */
-+			if (t & (1 << DATA_IN_TOKEN_INTERRUPT)) {
-+				if (ep->dev->protocol_stall) {
-+					ep->stopped = 1;
-+					set_halt (ep);
-+				}
-+				mode = 2;
-+			/* an extra OUT token is an error */
-+			} else if (((t & (1 << DATA_OUT_PING_TOKEN_INTERRUPT))
-+					&& req
-+					&& req->req.actual == req->req.length)
-+					|| !req) {
-+				ep->dev->protocol_stall = 1;
-+				set_halt (ep);
-+				ep->stopped = 1;
-+				if (req)
-+					done (ep, req, -EOVERFLOW);
-+				req = NULL;
-+			}
-+		}
-+	}
-+
-+	if (unlikely (!req))
-+		return;
-+
-+	/* manual DMA queue advance after short OUT */
-+	if (likely (ep->dma != 0)) {
-+		if (t & (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)) {
-+			u32	count;
-+			int	stopped = ep->stopped;
-+
-+			/* TRANSFERRED works around OUT_DONE erratum 0112.
-+			 * we expect (N <= maxpacket) bytes; host wrote M.
-+			 * iff (M < N) we won't ever see a DMA interrupt.
-+			 */
-+			ep->stopped = 1;
-+			for (count = 0; ; t = readl (&ep->regs->ep_stat)) {
-+
-+				/* any preceding dma transfers must finish.
-+				 * dma handles (M >= N), may empty the queue
-+				 */
-+				scan_dma_completions (ep);
-+				if (unlikely (list_empty (&ep->queue)
-+						|| ep->out_overflow)) {
-+					req = NULL;
-+					break;
-+				}
-+				req = list_entry (ep->queue.next,
-+					struct net2280_request, queue);
-+
-+				/* here either (M < N), a "real" short rx;
-+				 * or (M == N) and the queue didn't empty
-+				 */
-+				if (likely (t & (1 << FIFO_EMPTY))) {
-+					count = readl (&ep->dma->dmacount);
-+					count &= DMA_BYTE_COUNT_MASK;
-+					if (readl (&ep->dma->dmadesc)
-+							!= req->td_dma)
-+						req = NULL;
-+					break;
-+				}
-+				udelay(1);
-+			}
-+
-+			/* stop DMA, leave ep NAKing */
-+			writel ((1 << DMA_ABORT), &ep->dma->dmastat);
-+			spin_stop_dma (ep->dma);
-+
-+			if (likely (req != 0)) {
-+				req->td->dmacount = 0;
-+				t = readl (&ep->regs->ep_avail);
-+				dma_done (ep, req, count, t);
-+			}
-+
-+			/* also flush to prevent erratum 0106 trouble */
-+			if (unlikely (ep->out_overflow
-+					|| (ep->dev->chiprev == 0x0100
-+						&& ep->dev->gadget.speed
-+							== USB_SPEED_FULL))) {
-+				out_flush (ep);
-+				ep->out_overflow = 0;
-+			}
-+
-+			/* (re)start dma if needed, stop NAKing */
-+			ep->stopped = stopped;
-+			if (!list_empty (&ep->queue))
-+				restart_dma (ep);
-+		} else
-+			DEBUG (ep->dev, "%s dma ep_stat %08x ??\n",
-+					ep->ep.name, t);
-+		return;
-+
-+	/* data packet(s) received (in the fifo, OUT) */
-+	} else if (t & (1 << DATA_PACKET_RECEIVED_INTERRUPT)) {
-+		if (read_fifo (ep, req) && ep->num != 0)
-+			mode = 2;
-+
-+	/* data packet(s) transmitted (IN) */
-+	} else if (t & (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)) {
-+		unsigned	len;
-+
-+		len = req->req.length - req->req.actual;
-+		if (len > ep->ep.maxpacket)
-+			len = ep->ep.maxpacket;
-+		req->req.actual += len;
-+
-+		/* if we wrote it all, we're usually done */
-+		if (req->req.actual == req->req.length) {
-+			if (ep->num == 0) {
-+				/* wait for control status */
-+				if (mode != 2)
-+					req = NULL;
-+			} else if (!req->req.zero || len != ep->ep.maxpacket)
-+				mode = 2;
-+		}
-+
-+	/* there was nothing to do ...  */
-+	} else if (mode == 1)
-+		return;
-+
-+	/* done */
-+	if (mode == 2) {
-+		/* stream endpoints often resubmit/unlink in completion */
-+		done (ep, req, 0);
-+
-+		/* maybe advance queue to next request */
-+		if (ep->num == 0) {
-+			/* NOTE:  net2280 could let gadget driver start the
-+			 * status stage later. since not all controllers let
-+			 * them control that, the api doesn't (yet) allow it.
-+			 */
-+			if (!ep->stopped)
-+				allow_status (ep);
-+			req = NULL;
-+		} else {
-+			if (!list_empty (&ep->queue) && !ep->stopped)
-+				req = list_entry (ep->queue.next,
-+					struct net2280_request, queue);
-+			else
-+				req = NULL;
-+			if (req && !ep->is_in)
-+				stop_out_naking (ep);
-+		}
-+	}
-+
-+	/* is there a buffer for the next packet?
-+	 * for best streaming performance, make sure there is one.
-+	 */
-+	if (req && !ep->stopped) {
-+
-+		/* load IN fifo with next packet (may be zlp) */
-+		if (t & (1 << DATA_PACKET_TRANSMITTED_INTERRUPT))
-+			write_fifo (ep, &req->req);
-+	}
-+}
-+
-+static struct net2280_ep *
-+get_ep_by_addr (struct net2280 *dev, u16 wIndex)
-+{
-+	struct net2280_ep	*ep;
-+
-+	if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0)
-+		return &dev->ep [0];
-+	list_for_each_entry (ep, &dev->gadget.ep_list, ep.ep_list) {
-+		u8	bEndpointAddress;
-+
-+		if (!ep->desc)
-+			continue;
-+		bEndpointAddress = ep->desc->bEndpointAddress;
-+		if ((wIndex ^ bEndpointAddress) & USB_DIR_IN)
-+			continue;
-+		if ((wIndex & 0x0f) == (bEndpointAddress & 0x0f))
-+			return ep;
-+	}
-+	return NULL;
-+}
-+
-+static void handle_stat0_irqs (struct net2280 *dev, u32 stat)
-+{
-+	struct net2280_ep	*ep;
-+	u32			num, scratch;
-+
-+	/* most of these don't need individual acks */
-+	stat &= ~(1 << INTA_ASSERTED);
-+	if (!stat)
-+		return;
-+	// DEBUG (dev, "irqstat0 %04x\n", stat);
-+
-+	/* starting a control request? */
-+	if (unlikely (stat & (1 << SETUP_PACKET_INTERRUPT))) {
-+		union {
-+			u32			raw [2];
-+			struct usb_ctrlrequest	r;
-+		} u;
-+		int				tmp = 0;
-+		struct net2280_request		*req;
-+
-+		if (dev->gadget.speed == USB_SPEED_UNKNOWN) {
-+			if (readl (&dev->usb->usbstat) & (1 << HIGH_SPEED))
-+				dev->gadget.speed = USB_SPEED_HIGH;
-+			else
-+				dev->gadget.speed = USB_SPEED_FULL;
-+			net2280_led_speed (dev, dev->gadget.speed);
-+			DEBUG (dev, "%s speed\n",
-+				(dev->gadget.speed == USB_SPEED_HIGH)
-+					? "high" : "full");
-+		}
-+
-+		ep = &dev->ep [0];
-+		ep->irqs++;
-+
-+		/* make sure any leftover request state is cleared */
-+		stat &= ~(1 << ENDPOINT_0_INTERRUPT);
-+		while (!list_empty (&ep->queue)) {
-+			req = list_entry (ep->queue.next,
-+					struct net2280_request, queue);
-+			done (ep, req, (req->req.actual == req->req.length)
-+						? 0 : -EPROTO);
-+		}
-+		ep->stopped = 0;
-+		dev->protocol_stall = 0;
-+		writel (  (1 << TIMEOUT)
-+			| (1 << USB_STALL_SENT)
-+			| (1 << USB_IN_NAK_SENT)
-+			| (1 << USB_IN_ACK_RCVD)
-+			| (1 << USB_OUT_PING_NAK_SENT)
-+			| (1 << USB_OUT_ACK_SENT)
-+			| (1 << FIFO_OVERFLOW)
-+			| (1 << FIFO_UNDERFLOW)
-+			| (1 << SHORT_PACKET_OUT_DONE_INTERRUPT)
-+			| (1 << SHORT_PACKET_TRANSFERRED_INTERRUPT)
-+			| (1 << DATA_PACKET_RECEIVED_INTERRUPT)
-+			| (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)
-+			| (1 << DATA_OUT_PING_TOKEN_INTERRUPT)
-+			| (1 << DATA_IN_TOKEN_INTERRUPT)
-+			, &ep->regs->ep_stat);
-+		u.raw [0] = readl (&dev->usb->setup0123);
-+		u.raw [1] = readl (&dev->usb->setup4567);
-+		
-+		cpu_to_le32s (&u.raw [0]);
-+		cpu_to_le32s (&u.raw [1]);
-+
-+		le16_to_cpus (&u.r.wValue);
-+		le16_to_cpus (&u.r.wIndex);
-+		le16_to_cpus (&u.r.wLength);
-+
-+		/* ack the irq */
-+		writel (1 << SETUP_PACKET_INTERRUPT, &dev->regs->irqstat0);
-+		stat ^= (1 << SETUP_PACKET_INTERRUPT);
-+
-+		/* watch control traffic at the token level, and force
-+		 * synchronization before letting the status stage happen.
-+		 * FIXME ignore tokens we'll NAK, until driver responds.
-+		 * that'll mean a lot less irqs for some drivers.
-+		 */
-+		ep->is_in = (u.r.bRequestType & USB_DIR_IN) != 0;
-+		if (ep->is_in) {
-+			scratch = (1 << DATA_PACKET_TRANSMITTED_INTERRUPT)
-+				| (1 << DATA_OUT_PING_TOKEN_INTERRUPT)
-+				| (1 << DATA_IN_TOKEN_INTERRUPT);
-+			stop_out_naking (ep);
-+		} else
-+			scratch = (1 << DATA_PACKET_RECEIVED_INTERRUPT)
-+				| (1 << DATA_OUT_PING_TOKEN_INTERRUPT)
-+				| (1 << DATA_IN_TOKEN_INTERRUPT);
-+		writel (scratch, &dev->epregs [0].ep_irqenb);
-+
-+		/* we made the hardware handle most lowlevel requests;
-+		 * everything else goes uplevel to the gadget code.
-+		 */
-+		switch (u.r.bRequest) {
-+		case USB_REQ_GET_STATUS: {
-+			struct net2280_ep	*e;
-+			u16			status;
-+
-+			/* hw handles device and interface status */
-+			if (u.r.bRequestType != (USB_DIR_IN|USB_RECIP_ENDPOINT))
-+				goto delegate;
-+			if ((e = get_ep_by_addr (dev, u.r.wIndex)) == 0
-+					|| u.r.wLength > 2)
-+				goto do_stall;
-+
-+			if (readl (&e->regs->ep_rsp)
-+					& (1 << SET_ENDPOINT_HALT))
-+				status = __constant_cpu_to_le16 (1);
-+			else
-+				status = __constant_cpu_to_le16 (0);
-+
-+			/* don't bother with a request object! */
-+			writel (0, &dev->epregs [0].ep_irqenb);
-+			set_fifo_bytecount (ep, u.r.wLength);
-+			writel (status, &dev->epregs [0].ep_data);
-+			allow_status (ep);
-+			VDEBUG (dev, "%s stat %02x\n", ep->ep.name, status);
-+			goto next_endpoints;
-+			}
-+			break;
-+		case USB_REQ_CLEAR_FEATURE: {
-+			struct net2280_ep	*e;
-+
-+			/* hw handles device features */
-+			if (u.r.bRequestType != USB_RECIP_ENDPOINT)
-+				goto delegate;
-+			if (u.r.wValue != USB_ENDPOINT_HALT
-+					|| u.r.wLength != 0)
-+				goto do_stall;
-+			if ((e = get_ep_by_addr (dev, u.r.wIndex)) == 0)
-+				goto do_stall;
-+			clear_halt (e);
-+			allow_status (ep);
-+			VDEBUG (dev, "%s clear halt\n", ep->ep.name);
-+			goto next_endpoints;
-+			}
-+			break;
-+		case USB_REQ_SET_FEATURE: {
-+			struct net2280_ep	*e;
-+
-+			/* hw handles device features */
-+			if (u.r.bRequestType != USB_RECIP_ENDPOINT)
-+				goto delegate;
-+			if (u.r.wValue != USB_ENDPOINT_HALT
-+					|| u.r.wLength != 0)
-+				goto do_stall;
-+			if ((e = get_ep_by_addr (dev, u.r.wIndex)) == 0)
-+				goto do_stall;
-+			set_halt (e);
-+			allow_status (ep);
-+			VDEBUG (dev, "%s set halt\n", ep->ep.name);
-+			goto next_endpoints;
-+			}
-+			break;
-+		default:
-+delegate:
-+			VDEBUG (dev, "setup %02x.%02x v%04x i%04x "
-+				"ep_cfg %08x\n",
-+				u.r.bRequestType, u.r.bRequest,
-+				u.r.wValue, u.r.wIndex,
-+				readl (&ep->regs->ep_cfg));
-+			spin_unlock (&dev->lock);
-+			tmp = dev->driver->setup (&dev->gadget, &u.r);
-+			spin_lock (&dev->lock);
-+		}
-+
-+		/* stall ep0 on error */
-+		if (tmp < 0) {
-+do_stall:
-+			VDEBUG (dev, "req %02x.%02x protocol STALL; stat %d\n",
-+					u.r.bRequestType, u.r.bRequest, tmp);
-+			dev->protocol_stall = 1;
-+		}
-+
-+		/* some in/out token irq should follow; maybe stall then.
-+		 * driver must queue a request (even zlp) or halt ep0
-+		 * before the host times out.
-+		 */
-+	}
-+
-+next_endpoints:
-+	/* endpoint data irq ? */
-+	scratch = stat & 0x7f;
-+	stat &= ~0x7f;
-+	for (num = 0; scratch; num++) {
-+		u32		t;
-+
-+		/* do this endpoint's FIFO and queue need tending? */
-+		t = 1 << num;
-+		if ((scratch & t) == 0)
-+			continue;
-+		scratch ^= t;
-+
-+		ep = &dev->ep [num];
-+		handle_ep_small (ep);
-+	}
-+
-+	if (stat)
-+		DEBUG (dev, "unhandled irqstat0 %08x\n", stat);
-+}
-+
-+#define DMA_INTERRUPTS ( \
-+		  (1 << DMA_D_INTERRUPT) \
-+		| (1 << DMA_C_INTERRUPT) \
-+		| (1 << DMA_B_INTERRUPT) \
-+		| (1 << DMA_A_INTERRUPT))
-+#define	PCI_ERROR_INTERRUPTS ( \
-+		  (1 << PCI_MASTER_ABORT_RECEIVED_INTERRUPT) \
-+		| (1 << PCI_TARGET_ABORT_RECEIVED_INTERRUPT) \
-+		| (1 << PCI_RETRY_ABORT_INTERRUPT))
-+
-+static void handle_stat1_irqs (struct net2280 *dev, u32 stat)
-+{
-+	struct net2280_ep	*ep;
-+	u32			tmp, num, scratch;
-+
-+	/* after disconnect there's nothing else to do! */
-+	tmp = (1 << VBUS_INTERRUPT) | (1 << ROOT_PORT_RESET_INTERRUPT);
-+	if (stat & tmp) {
-+		writel (tmp, &dev->regs->irqstat1);
-+		if (((stat & (1 << ROOT_PORT_RESET_INTERRUPT)) != 0
-+			|| (readl (&dev->usb->usbctl) & (1 << VBUS_PIN)) == 0
-+			) && dev->gadget.speed != USB_SPEED_UNKNOWN) {
-+			DEBUG (dev, "disconnect %s\n",
-+					dev->driver->driver.name);
-+			stop_activity (dev, dev->driver);
-+			ep0_start (dev);
-+			return;
-+		}
-+		stat &= ~tmp;
-+
-+		/* vBUS can bounce ... one of many reasons to ignore the
-+		 * notion of hotplug events on bus connect/disconnect!
-+		 */
-+		if (!stat)
-+			return;
-+	}
-+
-+	/* NOTE: chip stays in PCI D0 state for now, but it could
-+	 * enter D1 to save more power
-+	 */
-+	tmp = (1 << SUSPEND_REQUEST_CHANGE_INTERRUPT);
-+	if (stat & tmp) {
-+		writel (tmp, &dev->regs->irqstat1);
-+		if (stat & (1 << SUSPEND_REQUEST_INTERRUPT)) {
-+			if (dev->driver->suspend)
-+				dev->driver->suspend (&dev->gadget);
-+			/* we use SUSPEND_IMMEDIATELY */
-+			stat &= ~(1 << SUSPEND_REQUEST_INTERRUPT);
-+		} else {
-+			if (dev->driver->resume)
-+				dev->driver->resume (&dev->gadget);
-+			/* at high speed, note erratum 0133 */
-+		}
-+		stat &= ~tmp;
-+	}
-+
-+	/* clear any other status/irqs */
-+	if (stat)
-+		writel (stat, &dev->regs->irqstat1);
-+
-+	/* some status we can just ignore */
-+	stat &= ~((1 << CONTROL_STATUS_INTERRUPT)
-+			| (1 << SUSPEND_REQUEST_INTERRUPT)
-+			| (1 << RESUME_INTERRUPT)
-+			| (1 << SOF_INTERRUPT));
-+	if (!stat)
-+		return;
-+	// DEBUG (dev, "irqstat1 %08x\n", stat);
-+
-+	/* DMA status, for ep-{a,b,c,d} */
-+	scratch = stat & DMA_INTERRUPTS;
-+	stat &= ~DMA_INTERRUPTS;
-+	scratch >>= 9;
-+	for (num = 0; scratch; num++) {
-+		struct net2280_dma_regs	*dma;
-+
-+		tmp = 1 << num;
-+		if ((tmp & scratch) == 0)
-+			continue;
-+		scratch ^= tmp;
-+
-+		ep = &dev->ep [num + 1];
-+		dma = ep->dma;
-+
-+		if (!dma)
-+			continue;
-+
-+		/* clear ep's dma status */
-+		tmp = readl (&dma->dmastat);
-+		writel (tmp, &dma->dmastat);
-+
-+		/* chaining should stop on abort, short OUT from fifo,
-+		 * or (stat0 codepath) short OUT transfer.
-+		 */
-+		if (!use_dma_chaining) {
-+			if ((tmp & (1 << DMA_TRANSACTION_DONE_INTERRUPT))
-+					== 0) {
-+				DEBUG (ep->dev, "%s no xact done? %08x\n",
-+					ep->ep.name, tmp);
-+				continue;
-+			}
-+			stop_dma (ep->dma);
-+		}
-+
-+		/* OUT transfers terminate when the data from the
-+		 * host is in our memory.  Process whatever's done.
-+		 * On this path, we know transfer's last packet wasn't
-+		 * less than req->length. NAK_OUT_PACKETS may be set,
-+		 * or the FIFO may already be holding new packets.
-+		 *
-+		 * IN transfers can linger in the FIFO for a very
-+		 * long time ... we ignore that for now, accounting
-+		 * precisely (like PIO does) needs per-packet irqs
-+		 */
-+		scan_dma_completions (ep);
-+
-+		/* disable dma on inactive queues; else maybe restart */
-+		if (list_empty (&ep->queue)) {
-+			if (use_dma_chaining)
-+				stop_dma (ep->dma);
-+		} else {
-+			tmp = readl (&dma->dmactl);
-+			if (!use_dma_chaining
-+					|| (tmp & (1 << DMA_ENABLE)) == 0)
-+				restart_dma (ep);
-+			else if (ep->is_in && use_dma_chaining) {
-+				struct net2280_request	*req;
-+				u32			dmacount;
-+
-+				/* the descriptor at the head of the chain
-+				 * may still have VALID_BIT clear; that's
-+				 * used to trigger changing DMA_FIFO_VALIDATE
-+				 * (affects automagic zlp writes).
-+				 */
-+				req = list_entry (ep->queue.next,
-+						struct net2280_request, queue);
-+				dmacount = req->td->dmacount;
-+				dmacount &= __constant_cpu_to_le32 (
-+						(1 << VALID_BIT)
-+						| DMA_BYTE_COUNT_MASK);
-+				if (dmacount && (dmacount & valid_bit) == 0)
-+					restart_dma (ep);
-+			}
-+		}
-+		ep->irqs++;
-+	}
-+
-+	/* NOTE:  there are other PCI errors we might usefully notice.
-+	 * if they appear very often, here's where to try recovering.
-+	 */
-+	if (stat & PCI_ERROR_INTERRUPTS) {
-+		ERROR (dev, "pci dma error; stat %08x\n", stat);
-+		stat &= ~PCI_ERROR_INTERRUPTS;
-+		/* these are fatal errors, but "maybe" they won't
-+		 * happen again ...
-+		 */
-+		stop_activity (dev, dev->driver);
-+		ep0_start (dev);
-+		stat = 0;
-+	}
-+
-+	if (stat)
-+		DEBUG (dev, "unhandled irqstat1 %08x\n", stat);
-+}
-+
-+static irqreturn_t net2280_irq (int irq, void *_dev, struct pt_regs * r)
-+{
-+	struct net2280		*dev = _dev;
-+
-+	spin_lock (&dev->lock);
-+
-+	/* handle disconnect, dma, and more */
-+	handle_stat1_irqs (dev, readl (&dev->regs->irqstat1));
-+
-+	/* control requests and PIO */
-+	handle_stat0_irqs (dev, readl (&dev->regs->irqstat0));
-+
-+	spin_unlock (&dev->lock);
-+
-+	return IRQ_HANDLED;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* tear down the binding between this driver and the pci device */
-+
-+static void net2280_remove (struct pci_dev *pdev)
-+{
-+	struct net2280		*dev = pci_get_drvdata (pdev);
-+
-+	/* start with the driver above us */
-+	if (dev->driver) {
-+		/* should have been done already by driver model core */
-+		WARN (dev, "pci remove, driver '%s' is still registered\n",
-+				dev->driver->driver.name);
-+		usb_gadget_unregister_driver (dev->driver);
-+	}
-+
-+	/* then clean up the resources we allocated during probe() */
-+	net2280_led_shutdown (dev);
-+	if (dev->requests) {
-+		int		i;
-+		for (i = 1; i < 5; i++) {
-+			if (!dev->ep [i].dummy)
-+				continue;
-+			pci_pool_free (dev->requests, dev->ep [i].dummy,
-+					dev->ep [i].td_dma);
-+		}
-+		pci_pool_destroy (dev->requests);
-+	}
-+	if (dev->got_irq)
-+		free_irq (pdev->irq, dev);
-+	if (dev->regs)
-+		iounmap (dev->regs);
-+	if (dev->region)
-+		release_mem_region (pci_resource_start (pdev, 0),
-+				pci_resource_len (pdev, 0));
-+	if (dev->enabled)
-+		pci_disable_device (pdev);
-+	pci_set_drvdata (pdev, 0);
-+
-+	INFO (dev, "unbind from pci %s\n", pdev->slot_name);
-+
-+	kfree (dev);
-+	the_controller = 0;
-+}
-+
-+/* wrap this driver around the specified device, but
-+ * don't respond over USB until a gadget driver binds to us.
-+ */
-+
-+static int net2280_probe (struct pci_dev *pdev, const struct pci_device_id *id)
-+{
-+	struct net2280		*dev;
-+	unsigned long		resource, len;
-+	void			*base = NULL;
-+	int			retval, i;
-+	char			buf [8], *bufp;
-+
-+	/* if you want to support more than one controller in a system,
-+	 * usb_gadget_driver_{register,unregister}() must change.
-+	 */
-+	if (the_controller) {
-+		WARN (the_controller, "ignoring %s\n", pdev->slot_name);
-+		return -EBUSY;
-+	}
-+
-+	/* alloc, and start init */
-+	dev = kmalloc (sizeof *dev, SLAB_KERNEL);
-+	if (dev == NULL){
-+		retval = -ENOMEM;
-+		goto done;
-+	}
-+
-+	memset (dev, 0, sizeof *dev);
-+	spin_lock_init (&dev->lock);
-+	dev->pdev = pdev;
-+	dev->gadget.ops = &net2280_ops;
-+	dev->gadget.is_dualspeed = 1;
-+
-+	dev->gadget.dev.bus_id = pdev->slot_name;
-+	dev->gadget.name = driver_name;
-+
-+	/* now all the pci goodies ... */
-+	if (pci_enable_device (pdev) < 0) {
-+   	        retval = -ENODEV;
-+		goto done;
-+	}
-+	dev->enabled = 1;
-+
-+	/* BAR 0 holds all the registers
-+	 * BAR 1 is 8051 memory; unused here (note erratum 0103)
-+	 * BAR 2 is fifo memory; unused here
-+	 */
-+	resource = pci_resource_start (pdev, 0);
-+	len = pci_resource_len (pdev, 0);
-+	if (!request_mem_region (resource, len, driver_name)) {
-+		DEBUG (dev, "controller already in use\n");
-+		retval = -EBUSY;
-+		goto done;
-+	}
-+	dev->region = 1;
-+
-+	base = ioremap_nocache (resource, len);
-+	if (base == NULL) {
-+		DEBUG (dev, "can't map memory\n");
-+		retval = -EFAULT;
-+		goto done;
-+	}
-+	dev->regs = (struct net2280_regs *) base;
-+	dev->usb = (struct net2280_usb_regs *) (base + 0x0080);
-+	dev->pci = (struct net2280_pci_regs *) (base + 0x0100);
-+	dev->dma = (struct net2280_dma_regs *) (base + 0x0180);
-+	dev->dep = (struct net2280_dep_regs *) (base + 0x0200);
-+	dev->epregs = (struct net2280_ep_regs *) (base + 0x0300);
-+
-+	/* put into initial config, link up all endpoints */
-+	writel (0, &dev->usb->usbctl);
-+	usb_reset (dev);
-+	usb_reinit (dev);
-+
-+	/* irq setup after old hardware is cleaned up */
-+	if (!pdev->irq) {
-+		ERROR (dev, "No IRQ.  Check PCI setup!\n");
-+		retval = -ENODEV;
-+		goto done;
-+	}
-+#ifndef __sparc__
-+	snprintf (buf, sizeof buf, "%d", pdev->irq);
-+	bufp = buf;
-+#else
-+	bufp = __irq_itoa(pdev->irq);
-+#endif
-+	if (request_irq (pdev->irq, net2280_irq, SA_SHIRQ, driver_name, dev)
-+			!= 0) {
-+		ERROR (dev, "request interrupt %s failed\n", bufp);
-+		retval = -EBUSY;
-+		goto done;
-+	}
-+	dev->got_irq = 1;
-+
-+	/* DMA setup */
-+	dev->requests = pci_pool_create ("requests", pdev,
-+		sizeof (struct net2280_dma),
-+		0 /* no alignment requirements */,
-+		0 /* or page-crossing issues */,
-+		SLAB_KERNEL /* 2.4 only */ );
-+	if (!dev->requests) {
-+		DEBUG (dev, "can't get request pool\n");
-+		retval = -ENOMEM;
-+		goto done;
-+	}
-+	for (i = 1; i < 5; i++) {
-+		struct net2280_dma	*td;
-+
-+		td = pci_pool_alloc (dev->requests, GFP_KERNEL,
-+				&dev->ep [i].td_dma);
-+		if (!td) {
-+			DEBUG (dev, "can't get dummy %d\n", i);
-+			retval = -ENOMEM;
-+			goto done;
-+		}
-+		td->dmacount = 0;	/* not VALID */
-+		td->dmaaddr = __constant_cpu_to_le32 (DMA_ADDR_INVALID);
-+		td->dmadesc = td->dmaaddr;
-+		dev->ep [i].dummy = td;
-+	}
-+
-+	/* enable lower-overhead pci memory bursts during DMA */
-+	writel ( (1 << DMA_MEMORY_WRITE_AND_INVALIDATE_ENABLE)
-+			// 256 write retries may not be enough...
-+			// | (1 << PCI_RETRY_ABORT_ENABLE)
-+			| (1 << DMA_READ_MULTIPLE_ENABLE)
-+			| (1 << DMA_READ_LINE_ENABLE)
-+			, &dev->pci->pcimstctl);
-+	/* erratum 0115 shouldn't appear: Linux inits PCI_LATENCY_TIMER */
-+	pci_set_master (pdev);
-+	pci_set_mwi (pdev);
-+
-+	/* ... also flushes any posted pci writes */
-+	dev->chiprev = get_idx_reg (dev->regs, REG_CHIPREV) & 0xffff;
-+
-+	/* done */
-+	pci_set_drvdata (pdev, dev);
-+	INFO (dev, "%s\n", driver_desc);
-+	INFO (dev, "irq %s, pci mem %p, chip rev %04x\n",
-+			bufp, base, dev->chiprev);
-+	INFO (dev, "version: " DRIVER_VERSION "; dma %s\n",
-+			use_dma
-+				? (use_dma_chaining ? "chaining" : "enabled")
-+				: "disabled");
-+	the_controller = dev;
-+
-+	return 0;
-+
-+done:
-+	if (dev)
-+		net2280_remove (pdev);
-+	return retval;
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static struct pci_device_id pci_ids [] = { {
-+	.class = 	((PCI_CLASS_SERIAL_USB << 8) | 0xfe),
-+	.class_mask = 	~0,
-+	.vendor =	0x17cc,
-+	.device =	0x2280,
-+	.subvendor =	PCI_ANY_ID,
-+	.subdevice =	PCI_ANY_ID,
-+
-+}, { /* end: all zeroes */ }
-+};
-+MODULE_DEVICE_TABLE (pci, pci_ids);
-+
-+/* pci driver glue; this is a "new style" PCI driver module */
-+static struct pci_driver net2280_pci_driver = {
-+	.name =		(char *) driver_name,
-+	.id_table =	pci_ids,
-+
-+	.probe =	net2280_probe,
-+	.remove =	net2280_remove,
-+
-+	/* FIXME add power management support */
-+};
-+
-+MODULE_DESCRIPTION (DRIVER_DESC);
-+MODULE_AUTHOR ("David Brownell");
-+MODULE_LICENSE ("GPL");
-+
-+static int __init init (void)
-+{
-+	if (!use_dma)
-+		use_dma_chaining = 0;
-+	return pci_module_init (&net2280_pci_driver);
-+}
-+module_init (init);
-+
-+static void __exit cleanup (void)
-+{
-+	pci_unregister_driver (&net2280_pci_driver);
-+}
-+module_exit (cleanup);
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/net2280.h kernel/drivers/usb/gadget/net2280.h
---- /tmp/kernel/drivers/usb/gadget/net2280.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/net2280.h	2005-04-22 17:53:19.483531538 +0200
-@@ -0,0 +1,756 @@
-+/*
-+ * NetChip 2280 high/full speed USB device controller.
-+ * Unlike many such controllers, this one talks PCI.
-+ */
-+
-+/*
-+ * Copyright (C) 2002 NetChip Technology, Inc. (http://www.netchip.com)
-+ * 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
-+ */
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* NET2280 MEMORY MAPPED REGISTERS
-+ *
-+ * The register layout came from the chip documentation, and the bit
-+ * number definitions were extracted from chip specification.
-+ *
-+ * Use the shift operator ('<<') to build bit masks, with readl/writel
-+ * to access the registers through PCI.
-+ */
-+
-+/* main registers, BAR0 + 0x0000 */
-+struct net2280_regs {
-+	// offset 0x0000
-+	u32		devinit;
-+#define     LOCAL_CLOCK_FREQUENCY                               8
-+#define     FORCE_PCI_RESET                                     7
-+#define     PCI_ID                                              6
-+#define     PCI_ENABLE                                          5
-+#define     FIFO_SOFT_RESET                                     4
-+#define     CFG_SOFT_RESET                                      3
-+#define     PCI_SOFT_RESET                                      2
-+#define     USB_SOFT_RESET                                      1
-+#define     M8051_RESET                                         0
-+	u32		eectl;
-+#define     EEPROM_ADDRESS_WIDTH                                23
-+#define     EEPROM_CHIP_SELECT_ACTIVE                           22
-+#define     EEPROM_PRESENT                                      21
-+#define     EEPROM_VALID                                        20
-+#define     EEPROM_BUSY                                         19
-+#define     EEPROM_CHIP_SELECT_ENABLE                           18
-+#define     EEPROM_BYTE_READ_START                              17
-+#define     EEPROM_BYTE_WRITE_START                             16
-+#define     EEPROM_READ_DATA                                    8
-+#define     EEPROM_WRITE_DATA                                   0
-+	u32		eeclkfreq;
-+	u32		_unused0;
-+	// offset 0x0010
-+
-+	u32		pciirqenb0;		/* interrupt PCI master ... */
-+#define     SETUP_PACKET_INTERRUPT_ENABLE                       7
-+#define     ENDPOINT_F_INTERRUPT_ENABLE                         6
-+#define     ENDPOINT_E_INTERRUPT_ENABLE                         5
-+#define     ENDPOINT_D_INTERRUPT_ENABLE                         4
-+#define     ENDPOINT_C_INTERRUPT_ENABLE                         3
-+#define     ENDPOINT_B_INTERRUPT_ENABLE                         2
-+#define     ENDPOINT_A_INTERRUPT_ENABLE                         1
-+#define     ENDPOINT_0_INTERRUPT_ENABLE                         0
-+	u32		pciirqenb1;
-+#define     PCI_INTERRUPT_ENABLE                                31
-+#define     POWER_STATE_CHANGE_INTERRUPT_ENABLE                 27
-+#define     PCI_ARBITER_TIMEOUT_INTERRUPT_ENABLE                26
-+#define     PCI_PARITY_ERROR_INTERRUPT_ENABLE                   25
-+#define     PCI_MASTER_ABORT_RECEIVED_INTERRUPT_ENABLE          20
-+#define     PCI_TARGET_ABORT_RECEIVED_INTERRUPT_ENABLE          19
-+#define     PCI_TARGET_ABORT_ASSERTED_INTERRUPT_ENABLE          18
-+#define     PCI_RETRY_ABORT_INTERRUPT_ENABLE                    17
-+#define     PCI_MASTER_CYCLE_DONE_INTERRUPT_ENABLE              16
-+#define     GPIO_INTERRUPT_ENABLE                               13
-+#define     DMA_D_INTERRUPT_ENABLE                              12
-+#define     DMA_C_INTERRUPT_ENABLE                              11
-+#define     DMA_B_INTERRUPT_ENABLE                              10
-+#define     DMA_A_INTERRUPT_ENABLE                              9
-+#define     EEPROM_DONE_INTERRUPT_ENABLE                        8
-+#define     VBUS_INTERRUPT_ENABLE                               7
-+#define     CONTROL_STATUS_INTERRUPT_ENABLE                     6
-+#define     ROOT_PORT_RESET_INTERRUPT_ENABLE                    4
-+#define     SUSPEND_REQUEST_INTERRUPT_ENABLE                    3
-+#define     SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE             2
-+#define     RESUME_INTERRUPT_ENABLE                             1
-+#define     SOF_INTERRUPT_ENABLE                                0
-+	u32		cpu_irqenb0;		/* ... or onboard 8051 */
-+#define     SETUP_PACKET_INTERRUPT_ENABLE                       7
-+#define     ENDPOINT_F_INTERRUPT_ENABLE                         6
-+#define     ENDPOINT_E_INTERRUPT_ENABLE                         5
-+#define     ENDPOINT_D_INTERRUPT_ENABLE                         4
-+#define     ENDPOINT_C_INTERRUPT_ENABLE                         3
-+#define     ENDPOINT_B_INTERRUPT_ENABLE                         2
-+#define     ENDPOINT_A_INTERRUPT_ENABLE                         1
-+#define     ENDPOINT_0_INTERRUPT_ENABLE                         0
-+	u32		cpu_irqenb1;
-+#define     CPU_INTERRUPT_ENABLE                                31
-+#define     POWER_STATE_CHANGE_INTERRUPT_ENABLE                 27
-+#define     PCI_ARBITER_TIMEOUT_INTERRUPT_ENABLE                26
-+#define     PCI_PARITY_ERROR_INTERRUPT_ENABLE                   25
-+#define     PCI_INTA_INTERRUPT_ENABLE                           24
-+#define     PCI_PME_INTERRUPT_ENABLE                            23
-+#define     PCI_SERR_INTERRUPT_ENABLE                           22
-+#define     PCI_PERR_INTERRUPT_ENABLE                           21
-+#define     PCI_MASTER_ABORT_RECEIVED_INTERRUPT_ENABLE          20
-+#define     PCI_TARGET_ABORT_RECEIVED_INTERRUPT_ENABLE          19
-+#define     PCI_RETRY_ABORT_INTERRUPT_ENABLE                    17
-+#define     PCI_MASTER_CYCLE_DONE_INTERRUPT_ENABLE              16
-+#define     GPIO_INTERRUPT_ENABLE                               13
-+#define     DMA_D_INTERRUPT_ENABLE                              12
-+#define     DMA_C_INTERRUPT_ENABLE                              11
-+#define     DMA_B_INTERRUPT_ENABLE                              10
-+#define     DMA_A_INTERRUPT_ENABLE                              9
-+#define     EEPROM_DONE_INTERRUPT_ENABLE                        8
-+#define     VBUS_INTERRUPT_ENABLE                               7
-+#define     CONTROL_STATUS_INTERRUPT_ENABLE                     6
-+#define     ROOT_PORT_RESET_INTERRUPT_ENABLE                    4
-+#define     SUSPEND_REQUEST_INTERRUPT_ENABLE                    3
-+#define     SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE             2
-+#define     RESUME_INTERRUPT_ENABLE                             1
-+#define     SOF_INTERRUPT_ENABLE                                0
-+
-+	// offset 0x0020
-+	u32		_unused1;
-+	u32		usbirqenb1;
-+#define     USB_INTERRUPT_ENABLE                                31
-+#define     POWER_STATE_CHANGE_INTERRUPT_ENABLE                 27
-+#define     PCI_ARBITER_TIMEOUT_INTERRUPT_ENABLE                26
-+#define     PCI_PARITY_ERROR_INTERRUPT_ENABLE                   25
-+#define     PCI_INTA_INTERRUPT_ENABLE                           24
-+#define     PCI_PME_INTERRUPT_ENABLE                            23
-+#define     PCI_SERR_INTERRUPT_ENABLE                           22
-+#define     PCI_PERR_INTERRUPT_ENABLE                           21
-+#define     PCI_MASTER_ABORT_RECEIVED_INTERRUPT_ENABLE          20
-+#define     PCI_TARGET_ABORT_RECEIVED_INTERRUPT_ENABLE          19
-+#define     PCI_RETRY_ABORT_INTERRUPT_ENABLE                    17
-+#define     PCI_MASTER_CYCLE_DONE_INTERRUPT_ENABLE              16
-+#define     GPIO_INTERRUPT_ENABLE                               13
-+#define     DMA_D_INTERRUPT_ENABLE                              12
-+#define     DMA_C_INTERRUPT_ENABLE                              11
-+#define     DMA_B_INTERRUPT_ENABLE                              10
-+#define     DMA_A_INTERRUPT_ENABLE                              9
-+#define     EEPROM_DONE_INTERRUPT_ENABLE                        8
-+#define     VBUS_INTERRUPT_ENABLE                               7
-+#define     CONTROL_STATUS_INTERRUPT_ENABLE                     6
-+#define     ROOT_PORT_RESET_INTERRUPT_ENABLE                    4
-+#define     SUSPEND_REQUEST_INTERRUPT_ENABLE                    3
-+#define     SUSPEND_REQUEST_CHANGE_INTERRUPT_ENABLE             2
-+#define     RESUME_INTERRUPT_ENABLE                             1
-+#define     SOF_INTERRUPT_ENABLE                                0
-+	u32		irqstat0;
-+#define     INTA_ASSERTED                                       12
-+#define     SETUP_PACKET_INTERRUPT                              7
-+#define     ENDPOINT_F_INTERRUPT                                6
-+#define     ENDPOINT_E_INTERRUPT                                5
-+#define     ENDPOINT_D_INTERRUPT                                4
-+#define     ENDPOINT_C_INTERRUPT                                3
-+#define     ENDPOINT_B_INTERRUPT                                2
-+#define     ENDPOINT_A_INTERRUPT                                1
-+#define     ENDPOINT_0_INTERRUPT                                0
-+	u32		irqstat1;
-+#define     POWER_STATE_CHANGE_INTERRUPT                        27
-+#define     PCI_ARBITER_TIMEOUT_INTERRUPT                       26
-+#define     PCI_PARITY_ERROR_INTERRUPT                          25
-+#define     PCI_INTA_INTERRUPT                                  24
-+#define     PCI_PME_INTERRUPT                                   23
-+#define     PCI_SERR_INTERRUPT                                  22
-+#define     PCI_PERR_INTERRUPT                                  21
-+#define     PCI_MASTER_ABORT_RECEIVED_INTERRUPT                 20
-+#define     PCI_TARGET_ABORT_RECEIVED_INTERRUPT                 19
-+#define     PCI_RETRY_ABORT_INTERRUPT                           17
-+#define     PCI_MASTER_CYCLE_DONE_INTERRUPT                     16
-+#define     GPIO_INTERRUPT                                      13
-+#define     DMA_D_INTERRUPT                                     12
-+#define     DMA_C_INTERRUPT                                     11
-+#define     DMA_B_INTERRUPT                                     10
-+#define     DMA_A_INTERRUPT                                     9
-+#define     EEPROM_DONE_INTERRUPT                               8
-+#define     VBUS_INTERRUPT                                      7
-+#define     CONTROL_STATUS_INTERRUPT                            6
-+#define     ROOT_PORT_RESET_INTERRUPT                           4
-+#define     SUSPEND_REQUEST_INTERRUPT                           3
-+#define     SUSPEND_REQUEST_CHANGE_INTERRUPT                    2
-+#define     RESUME_INTERRUPT                                    1
-+#define     SOF_INTERRUPT                                       0
-+	// offset 0x0030
-+	u32		idxaddr;
-+	u32		idxdata;
-+	u32		fifoctl;
-+#define     PCI_BASE2_RANGE                                     16
-+#define     IGNORE_FIFO_AVAILABILITY                            3
-+#define     PCI_BASE2_SELECT                                    2
-+#define     FIFO_CONFIGURATION_SELECT                           0
-+	u32		_unused2;
-+	// offset 0x0040
-+	u32		memaddr;
-+#define     START                                               28
-+#define     DIRECTION                                           27
-+#define     FIFO_DIAGNOSTIC_SELECT                              24
-+#define     MEMORY_ADDRESS                                      0
-+	u32		memdata0;
-+	u32		memdata1;
-+	u32		_unused3;
-+	// offset 0x0050
-+	u32		gpioctl;
-+#define     GPIO3_LED_SELECT                                    12
-+#define     GPIO3_INTERRUPT_ENABLE                              11
-+#define     GPIO2_INTERRUPT_ENABLE                              10
-+#define     GPIO1_INTERRUPT_ENABLE                              9
-+#define     GPIO0_INTERRUPT_ENABLE                              8
-+#define     GPIO3_OUTPUT_ENABLE                                 7
-+#define     GPIO2_OUTPUT_ENABLE                                 6
-+#define     GPIO1_OUTPUT_ENABLE                                 5
-+#define     GPIO0_OUTPUT_ENABLE                                 4
-+#define     GPIO3_DATA                                          3
-+#define     GPIO2_DATA                                          2
-+#define     GPIO1_DATA                                          1
-+#define     GPIO0_DATA                                          0
-+	u32		gpiostat;
-+#define     GPIO3_INTERRUPT                                     3
-+#define     GPIO2_INTERRUPT                                     2
-+#define     GPIO1_INTERRUPT                                     1
-+#define     GPIO0_INTERRUPT                                     0
-+} __attribute__ ((packed));
-+
-+/* usb control, BAR0 + 0x0080 */
-+struct net2280_usb_regs {
-+	// offset 0x0080
-+	u32		stdrsp;
-+#define     STALL_UNSUPPORTED_REQUESTS                          31
-+#define     SET_TEST_MODE                                       16
-+#define     GET_OTHER_SPEED_CONFIGURATION                       15
-+#define     GET_DEVICE_QUALIFIER                                14
-+#define     SET_ADDRESS                                         13
-+#define     ENDPOINT_SET_CLEAR_HALT                             12
-+#define     DEVICE_SET_CLEAR_DEVICE_REMOTE_WAKEUP               11
-+#define     GET_STRING_DESCRIPTOR_2                             10
-+#define     GET_STRING_DESCRIPTOR_1                             9
-+#define     GET_STRING_DESCRIPTOR_0                             8
-+#define     GET_SET_INTERFACE                                   6
-+#define     GET_SET_CONFIGURATION                               5
-+#define     GET_CONFIGURATION_DESCRIPTOR                        4
-+#define     GET_DEVICE_DESCRIPTOR                               3
-+#define     GET_ENDPOINT_STATUS                                 2
-+#define     GET_INTERFACE_STATUS                                1
-+#define     GET_DEVICE_STATUS                                   0
-+	u32		prodvendid;
-+#define     PRODUCT_ID                                          16
-+#define     VENDOR_ID                                           0
-+	u32		relnum;
-+	u32		usbctl;
-+#define     SERIAL_NUMBER_INDEX                                 16
-+#define     PRODUCT_ID_STRING_ENABLE                            13
-+#define     VENDOR_ID_STRING_ENABLE                             12
-+#define     USB_ROOT_PORT_WAKEUP_ENABLE                         11
-+#define     VBUS_PIN                                            10
-+#define     TIMED_DISCONNECT                                    9
-+#define     SUSPEND_IMMEDIATELY                                 7
-+#define     SELF_POWERED_USB_DEVICE                             6
-+#define     REMOTE_WAKEUP_SUPPORT                               5
-+#define     PME_POLARITY                                        4
-+#define     USB_DETECT_ENABLE                                   3
-+#define     PME_WAKEUP_ENABLE                                   2
-+#define     DEVICE_REMOTE_WAKEUP_ENABLE                         1
-+#define     SELF_POWERED_STATUS                                 0
-+	// offset 0x0090
-+	u32		usbstat;
-+#define     HIGH_SPEED                                          7
-+#define     FULL_SPEED                                          6
-+#define     GENERATE_RESUME                                     5
-+#define     GENERATE_DEVICE_REMOTE_WAKEUP                       4
-+	u32		xcvrdiag;
-+#define     FORCE_HIGH_SPEED_MODE                               31
-+#define     FORCE_FULL_SPEED_MODE                               30
-+#define     USB_TEST_MODE                                       24
-+#define     LINE_STATE                                          16
-+#define     TRANSCEIVER_OPERATION_MODE                          2
-+#define     TRANSCEIVER_SELECT                                  1
-+#define     TERMINATION_SELECT                                  0
-+	u32		setup0123;
-+	u32		setup4567;
-+	// offset 0x0090
-+	u32		_unused0;
-+	u32		ouraddr;
-+#define     FORCE_IMMEDIATE                                     7
-+#define     OUR_USB_ADDRESS                                     0
-+	u32		ourconfig;
-+} __attribute__ ((packed));
-+
-+/* pci control, BAR0 + 0x0100 */
-+struct net2280_pci_regs {
-+	// offset 0x0100
-+	u32		 pcimstctl;
-+#define     PCI_ARBITER_PARK_SELECT                             13
-+#define     PCI_MULTI LEVEL_ARBITER                             12
-+#define     PCI_RETRY_ABORT_ENABLE                              11
-+#define     DMA_MEMORY_WRITE_AND_INVALIDATE_ENABLE              10
-+#define     DMA_READ_MULTIPLE_ENABLE                            9
-+#define     DMA_READ_LINE_ENABLE                                8
-+#define     PCI_MASTER_COMMAND_SELECT                           6
-+#define         MEM_READ_OR_WRITE                                   0
-+#define         IO_READ_OR_WRITE                                    1
-+#define         CFG_READ_OR_WRITE                                   2
-+#define     PCI_MASTER_START                                    5
-+#define     PCI_MASTER_READ_WRITE                               4
-+#define         PCI_MASTER_WRITE                                    0
-+#define         PCI_MASTER_READ                                     1
-+#define     PCI_MASTER_BYTE_WRITE_ENABLES                       0
-+	u32		 pcimstaddr;
-+	u32		 pcimstdata;
-+	u32		 pcimststat;
-+#define     PCI_ARBITER_CLEAR                                   2
-+#define     PCI_EXTERNAL_ARBITER                                1
-+#define     PCI_HOST_MODE                                       0
-+} __attribute__ ((packed));
-+
-+/* dma control, BAR0 + 0x0180 ... array of four structs like this,
-+ * for channels 0..3.  see also struct net2280_dma:  descriptor
-+ * that can be loaded into some of these registers.
-+ */
-+struct net2280_dma_regs {	/* [11.7] */
-+	// offset 0x0180, 0x01a0, 0x01c0, 0x01e0, 
-+	u32		dmactl;
-+#define     DMA_SCATTER_GATHER_DONE_INTERRUPT_ENABLE            25
-+#define     DMA_CLEAR_COUNT_ENABLE                              21
-+#define     DESCRIPTOR_POLLING_RATE                             19
-+#define         POLL_CONTINUOUS                                     0
-+#define         POLL_1_USEC                                         1
-+#define         POLL_100_USEC                                       2
-+#define         POLL_1_MSEC                                         3
-+#define     DMA_VALID_BIT_POLLING_ENABLE                        18
-+#define     DMA_VALID_BIT_ENABLE                                17
-+#define     DMA_SCATTER_GATHER_ENABLE                           16
-+#define     DMA_OUT_AUTO_START_ENABLE                           4
-+#define     DMA_PREEMPT_ENABLE                                  3
-+#define     DMA_FIFO_VALIDATE                                   2
-+#define     DMA_ENABLE                                          1
-+#define     DMA_ADDRESS_HOLD                                    0
-+	u32		dmastat;
-+#define     DMA_SCATTER_GATHER_DONE_INTERRUPT                   25
-+#define     DMA_TRANSACTION_DONE_INTERRUPT                      24
-+#define     DMA_ABORT                                           1
-+#define     DMA_START                                           0
-+	u32		_unused0 [2];
-+	// offset 0x0190, 0x01b0, 0x01d0, 0x01f0, 
-+	u32		dmacount;
-+#define     VALID_BIT                                           31
-+#define     DMA_DIRECTION                                       30
-+#define     DMA_DONE_INTERRUPT_ENABLE                           29
-+#define     END_OF_CHAIN                                        28
-+#define         DMA_BYTE_COUNT_MASK                                 ((1<<24)-1)
-+#define     DMA_BYTE_COUNT                                      0
-+	u32		dmaaddr;
-+	u32		dmadesc;
-+	u32		_unused1;
-+} __attribute__ ((packed));
-+
-+/* dedicated endpoint registers, BAR0 + 0x0200 */
-+
-+struct net2280_dep_regs {	/* [11.8] */
-+	// offset 0x0200, 0x0210, 0x220, 0x230, 0x240
-+	u32		dep_cfg;
-+	// offset 0x0204, 0x0214, 0x224, 0x234, 0x244
-+	u32		dep_rsp;
-+	u32		_unused [2];
-+} __attribute__ ((packed));
-+
-+/* configurable endpoint registers, BAR0 + 0x0300 ... array of seven structs
-+ * like this, for ep0 then the configurable endpoints A..F
-+ * ep0 reserved for control; E and F have only 64 bytes of fifo
-+ */
-+struct net2280_ep_regs {	/* [11.9] */
-+	// offset 0x0300, 0x0320, 0x0340, 0x0360, 0x0380, 0x03a0, 0x03c0
-+	u32		ep_cfg;
-+#define     ENDPOINT_BYTE_COUNT                                 16
-+#define     ENDPOINT_ENABLE                                     10
-+#define     ENDPOINT_TYPE                                       8
-+#define     ENDPOINT_DIRECTION                                  7
-+#define     ENDPOINT_NUMBER                                     0
-+	u32		ep_rsp;
-+#define     SET_NAK_OUT_PACKETS                                 15
-+#define     SET_EP_HIDE_STATUS_PHASE                            14
-+#define     SET_EP_FORCE_CRC_ERROR                              13
-+#define     SET_INTERRUPT_MODE                                  12
-+#define     SET_CONTROL_STATUS_PHASE_HANDSHAKE                  11
-+#define     SET_NAK_OUT_PACKETS_MODE                            10
-+#define     SET_ENDPOINT_TOGGLE                                 9
-+#define     SET_ENDPOINT_HALT                                   8
-+#define     CLEAR_NAK_OUT_PACKETS                               7
-+#define     CLEAR_EP_HIDE_STATUS_PHASE                          6
-+#define     CLEAR_EP_FORCE_CRC_ERROR                            5
-+#define     CLEAR_INTERRUPT_MODE                                4
-+#define     CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE                3
-+#define     CLEAR_NAK_OUT_PACKETS_MODE                          2
-+#define     CLEAR_ENDPOINT_TOGGLE                               1
-+#define     CLEAR_ENDPOINT_HALT                                 0
-+	u32		ep_irqenb;
-+#define     SHORT_PACKET_OUT_DONE_INTERRUPT_ENABLE              6
-+#define     SHORT_PACKET_TRANSFERRED_INTERRUPT_ENABLE           5
-+#define     DATA_PACKET_RECEIVED_INTERRUPT_ENABLE               3
-+#define     DATA_PACKET_TRANSMITTED_INTERRUPT_ENABLE            2
-+#define     DATA_OUT_PING_TOKEN_INTERRUPT_ENABLE                1
-+#define     DATA_IN_TOKEN_INTERRUPT_ENABLE                      0
-+	u32		ep_stat;
-+#define     FIFO_VALID_COUNT                                    24
-+#define     HIGH_BANDWIDTH_OUT_TRANSACTION_PID                  22
-+#define     TIMEOUT                                             21
-+#define     USB_STALL_SENT                                      20
-+#define     USB_IN_NAK_SENT                                     19
-+#define     USB_IN_ACK_RCVD                                     18
-+#define     USB_OUT_PING_NAK_SENT                               17
-+#define     USB_OUT_ACK_SENT                                    16
-+#define     FIFO_OVERFLOW                                       13
-+#define     FIFO_UNDERFLOW                                      12
-+#define     FIFO_FULL                                           11
-+#define     FIFO_EMPTY                                          10
-+#define     FIFO_FLUSH                                          9
-+#define     SHORT_PACKET_OUT_DONE_INTERRUPT                     6
-+#define     SHORT_PACKET_TRANSFERRED_INTERRUPT                  5
-+#define     NAK_OUT_PACKETS                                     4
-+#define     DATA_PACKET_RECEIVED_INTERRUPT                      3
-+#define     DATA_PACKET_TRANSMITTED_INTERRUPT                   2
-+#define     DATA_OUT_PING_TOKEN_INTERRUPT                       1
-+#define     DATA_IN_TOKEN_INTERRUPT                             0
-+	// offset 0x0310, 0x0330, 0x0350, 0x0370, 0x0390, 0x03b0, 0x03d0
-+	u32		ep_avail;
-+	u32		ep_data;
-+	u32		_unused0 [2];
-+} __attribute__ ((packed));
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#ifdef	__KERNEL__
-+
-+/* indexed registers [11.10] are accessed indirectly
-+ * caller must own the device lock.
-+ */
-+
-+static inline u32
-+get_idx_reg (struct net2280_regs *regs, u32 index)
-+{
-+	writel (index, &regs->idxaddr);
-+	/* NOTE:  synchs device/cpu memory views */
-+	return readl (&regs->idxdata);
-+}
-+
-+static inline void
-+set_idx_reg (struct net2280_regs *regs, u32 index, u32 value)
-+{
-+	writel (index, &regs->idxaddr);
-+	writel (value, &regs->idxdata);
-+	/* posted, may not be visible yet */
-+}
-+
-+#endif	/* __KERNEL__ */
-+
-+
-+#define REG_DIAG		0x0
-+#define     RETRY_COUNTER                                       16
-+#define     FORCE_PCI_SERR                                      11
-+#define     FORCE_PCI_INTERRUPT                                 10
-+#define     FORCE_USB_INTERRUPT                                 9
-+#define     FORCE_CPU_INTERRUPT                                 8
-+#define     ILLEGAL_BYTE_ENABLES                                5
-+#define     FAST_TIMES                                          4
-+#define     FORCE_RECEIVE_ERROR                                 2
-+#define     FORCE_TRANSMIT_CRC_ERROR                            0
-+#define REG_FRAME		0x02	/* from last sof */
-+#define REG_CHIPREV		0x03	/* in bcd */
-+#define	REG_HS_NAK_RATE		0x0a	/* NAK per N uframes */
-+
-+#define	CHIPREV_1	0x0100
-+#define	CHIPREV_1A	0x0110
-+
-+#ifdef	__KERNEL__
-+
-+/* ep a-f highspeed and fullspeed maxpacket, addresses
-+ * computed from ep->num
-+ */
-+#define REG_EP_MAXPKT(dev,num) (((num) + 1) * 0x10 + \
-+		(((dev)->gadget.speed == USB_SPEED_HIGH) ? 0 : 1))
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* [8.3] for scatter/gather i/o
-+ * use struct net2280_dma_regs bitfields
-+ */
-+struct net2280_dma {
-+	u32		dmacount;
-+	u32		dmaaddr;		/* the buffer */
-+	u32		dmadesc;		/* next dma descriptor */
-+	u32		_reserved;
-+} __attribute__ ((aligned (16)));
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* DRIVER DATA STRUCTURES and UTILITIES */
-+
-+struct net2280_ep {
-+	struct usb_ep				ep;
-+	struct net2280_ep_regs			*regs;
-+	struct net2280_dma_regs			*dma;
-+	struct net2280_dma			*dummy;
-+	dma_addr_t				td_dma;	/* of dummy */
-+	struct net2280				*dev;
-+	unsigned long				irqs;
-+
-+	/* analogous to a host-side qh */
-+	struct list_head			queue;
-+	const struct usb_endpoint_descriptor	*desc;
-+	unsigned				num : 8,
-+						fifo_size : 12,
-+						in_fifo_validate : 1,
-+						out_overflow : 1,
-+						stopped : 1,
-+						is_in : 1,
-+						is_iso : 1;
-+};
-+
-+static inline void allow_status (struct net2280_ep *ep)
-+{
-+	/* ep0 only */
-+	writel (  (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
-+		| (1 << CLEAR_NAK_OUT_PACKETS)
-+		| (1 << CLEAR_NAK_OUT_PACKETS_MODE)
-+		, &ep->regs->ep_rsp);
-+	ep->stopped = 1;
-+}
-+
-+/* count (<= 4) bytes in the next fifo write will be valid */
-+static inline void set_fifo_bytecount (struct net2280_ep *ep, unsigned count)
-+{
-+	writeb (count, 2 + (u8 *) &ep->regs->ep_cfg);
-+}
-+
-+struct net2280_request {
-+	struct usb_request		req;
-+	struct net2280_dma		*td;
-+	dma_addr_t			td_dma;
-+	struct list_head		queue;
-+	unsigned			mapped : 1,
-+					valid : 1;
-+};
-+
-+struct net2280 {
-+	/* each pci device provides one gadget, several endpoints */
-+	struct usb_gadget		gadget;
-+	spinlock_t			lock;
-+	struct net2280_ep		ep [7];
-+	struct usb_gadget_driver 	*driver;
-+	unsigned			enabled : 1,
-+					protocol_stall : 1,
-+					softconnect : 1,
-+					got_irq : 1,
-+					region : 1;
-+	u16				chiprev;
-+
-+	/* pci state used to access those endpoints */
-+	struct pci_dev			*pdev;
-+	struct net2280_regs		*regs;
-+	struct net2280_usb_regs		*usb;
-+	struct net2280_pci_regs		*pci;
-+	struct net2280_dma_regs		*dma;
-+	struct net2280_dep_regs		*dep;
-+	struct net2280_ep_regs		*epregs;
-+
-+	struct pci_pool			*requests;
-+	// statistics...
-+};
-+
-+static inline void set_halt (struct net2280_ep *ep)
-+{
-+	/* ep0 and bulk/intr endpoints */
-+	writel (  (1 << CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE)
-+		    /* set NAK_OUT for erratum 0114 */
-+		| ((ep->dev->chiprev == CHIPREV_1) << SET_NAK_OUT_PACKETS)
-+		| (1 << SET_ENDPOINT_HALT)
-+		, &ep->regs->ep_rsp);
-+}
-+
-+static inline void clear_halt (struct net2280_ep *ep)
-+{
-+	/* ep0 and bulk/intr endpoints */
-+	writel (  (1 << CLEAR_ENDPOINT_HALT)
-+		| (1 << CLEAR_ENDPOINT_TOGGLE)
-+		    /* unless the gadget driver left a short packet in the
-+		     * fifo, this reverses the erratum 0114 workaround.
-+		     */
-+		| ((ep->dev->chiprev == CHIPREV_1) << CLEAR_NAK_OUT_PACKETS)
-+		, &ep->regs->ep_rsp);
-+}
-+
-+#ifdef USE_RDK_LEDS
-+
-+static inline void net2280_led_init (struct net2280 *dev)
-+{
-+	/* LED3 (green) is on during USB activity. note erratum 0113. */
-+	writel ((1 << GPIO3_LED_SELECT)
-+		| (1 << GPIO3_OUTPUT_ENABLE)
-+		| (1 << GPIO2_OUTPUT_ENABLE)
-+		| (1 << GPIO1_OUTPUT_ENABLE)
-+		| (1 << GPIO0_OUTPUT_ENABLE)
-+		, &dev->regs->gpioctl);
-+}
-+
-+/* indicate speed with bi-color LED 0/1 */
-+static inline
-+void net2280_led_speed (struct net2280 *dev, enum usb_device_speed speed)
-+{
-+	u32	val = readl (&dev->regs->gpioctl);
-+	switch (speed) {
-+	case USB_SPEED_HIGH:		/* green */
-+		val &= ~(1 << GPIO0_DATA);
-+		val |= (1 << GPIO1_DATA);
-+		break;
-+	case USB_SPEED_FULL:		/* red */
-+		val &= ~(1 << GPIO1_DATA);
-+		val |= (1 << GPIO0_DATA);
-+		break;
-+	default:			/* (off/black) */
-+		val &= ~((1 << GPIO1_DATA) | (1 << GPIO0_DATA));
-+		break;
-+	}
-+	writel (val, &dev->regs->gpioctl);
-+}
-+
-+/* indicate power with LED 2 */
-+static inline void net2280_led_active (struct net2280 *dev, int is_active)
-+{
-+	u32	val = readl (&dev->regs->gpioctl);
-+
-+	// FIXME this LED never seems to turn on.
-+	if (is_active)
-+		val |= GPIO2_DATA;
-+	else
-+		val &= ~GPIO2_DATA;
-+	writel (val, &dev->regs->gpioctl);
-+}
-+static inline void net2280_led_shutdown (struct net2280 *dev)
-+{
-+	/* turn off all four GPIO*_DATA bits */
-+	writel (readl (&dev->regs->gpioctl) & ~0x0f,
-+			&dev->regs->gpioctl);
-+}
-+
-+#else
-+
-+#define net2280_led_init(dev)		do { } while (0)
-+#define net2280_led_speed(dev, speed)	do { } while (0)
-+#define net2280_led_shutdown(dev)	do { } while (0)
-+
-+#endif
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#define xprintk(dev,level,fmt,args...) \
-+	printk(level "%s %s: " fmt , driver_name , \
-+			dev->pdev->slot_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)
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static inline void start_out_naking (struct net2280_ep *ep)
-+{
-+	/* NOTE:  hardware races lurk here, and PING protocol issues */
-+	writel ((1 << SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
-+	/* synch with device */
-+	readl (&ep->regs->ep_rsp);
-+}
-+
-+#ifdef DEBUG
-+static inline void assert_out_naking (struct net2280_ep *ep, const char *where)
-+{
-+	u32	tmp = readl (&ep->regs->ep_stat);
-+
-+	if ((tmp & (1 << NAK_OUT_PACKETS)) == 0) {
-+		DEBUG (ep->dev, "%s %s %08x !NAK\n",
-+				ep->ep.name, where, tmp);
-+		writel ((1 << SET_NAK_OUT_PACKETS),
-+			&ep->regs->ep_rsp);
-+	}
-+}
-+#define ASSERT_OUT_NAKING(ep) assert_out_naking(ep,__FUNCTION__)
-+#else
-+#define ASSERT_OUT_NAKING(ep) do {} while (0)
-+#endif
-+
-+static inline void stop_out_naking (struct net2280_ep *ep)
-+{
-+	u32	tmp;
-+
-+	tmp = readl (&ep->regs->ep_stat);
-+	if ((tmp & (1 << NAK_OUT_PACKETS)) != 0)
-+		writel ((1 << CLEAR_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* 2.5 and 2.4.older portability changes ... */
-+
-+#ifndef container_of
-+#define	container_of	list_entry
-+#endif
-+
-+#ifndef likely
-+#define likely(x) (x)
-+#define unlikely(x) (x)
-+#endif
-+
-+#ifndef BUG_ON
-+#define BUG_ON(condition) do { if (unlikely((condition)!=0)) BUG(); } while(0)
-+#endif
-+
-+#ifndef WARN_ON
-+#define	WARN_ON(x)	do { } while (0)
-+#endif
-+
-+#ifndef	IRQ_NONE
-+typedef void irqreturn_t;
-+#define IRQ_NONE
-+#define IRQ_HANDLED
-+#define IRQ_RETVAL(x)
-+#endif
-+
-+#endif	/* __KERNEL__ */
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/pxa2xx_udc.c kernel/drivers/usb/gadget/pxa2xx_udc.c
---- /tmp/kernel/drivers/usb/gadget/pxa2xx_udc.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/pxa2xx_udc.c	2005-04-22 17:53:19.492530073 +0200
-@@ -0,0 +1,2486 @@
-+/*
-+ * linux/drivers/usb/gadget/pxa2xx_udc.c
-+ * Intel PXA2xx 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
-+ *
-+ * 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	DEBUG	1
-+// #define	VERBOSE	DBG_VERBOSE
-+
-+#include <linux/config.h>
-+#include <linux/module.h>
-+#include <linux/kernel.h>
-+#include <linux/ioport.h>
-+#include <linux/types.h>
-+#include <linux/version.h>
-+#include <linux/errno.h>
-+#include <linux/delay.h>
-+#include <linux/sched.h>
-+#include <linux/slab.h>
-+#include <linux/init.h>
-+#include <linux/timer.h>
-+#include <linux/list.h>
-+#include <linux/interrupt.h>
-+#include <linux/proc_fs.h>
-+#include <linux/mm.h>
-+// #include <linux/device.h>
-+
-+#include <asm/byteorder.h>
-+#include <asm/dma.h>
-+#include <asm/io.h>
-+#include <asm/irq.h>
-+#include <asm/system.h>
-+#include <asm/unaligned.h>
-+#include <asm/proc/cache.h>
-+
-+#include <linux/usb_ch9.h>
-+#include <linux/usb_gadget.h>
-+
-+
-+/*
-+ * This driver handles the USB Device Controller (UDC) in Intel's PXA 2xx
-+ * 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:  the 2.6 driver is probably the most current version */
-+#define	DRIVER_VERSION	"5-Jan-2004"
-+#define	DRIVER_DESC	"PXA 2xx USB Device Controller driver"
-+
-+static const char driver_name [] = "pxa2xx_udc";
-+
-+static const char ep0name [] = "ep0";
-+
-+
-+// #define	USE_DMA
-+// #define	USE_OUT_DMA
-+// #define	DISABLE_TEST_MODE
-+
-+#ifdef CONFIG_PROC_FS
-+#define	UDC_PROC_FILE
-+#endif
-+
-+#ifdef CONFIG_ARCH_IXP425
-+#undef USE_DMA
-+
-+/* cpu-specific register addresses are compiled in to this code */
-+#ifdef CONFIG_ARCH_PXA
-+#error "Can't configure both IXP and PXA"
-+#endif
-+
-+#endif
-+
-+#ifdef CONFIG_EMBEDDED
-+/* few strings, and little code to use them */
-+#undef	DEBUG
-+#undef	UDC_PROC_FILE
-+#endif
-+
-+
-+#include "pxa2xx_udc.h"
-+
-+#ifdef	USE_DMA
-+static int use_dma = 1;
-+MODULE_PARM (use_dma, "i");
-+MODULE_PARM_DESC (use_dma, "true to use dma");
-+
-+static void dma_nodesc_handler (int dmach, void *_ep, struct pt_regs *r);
-+static void kick_dma(struct pxa2xx_ep *ep, struct pxa2xx_request *req);
-+
-+#ifdef USE_OUT_DMA
-+#define	DMASTR " (dma support)"
-+#else
-+#define	DMASTR " (dma in)"
-+#endif
-+
-+#else	/* !USE_DMA */
-+#define	DMASTR " (pio only)"
-+#undef	USE_OUT_DMA
-+#endif
-+
-+#ifdef	CONFIG_USB_PXA2XX_SMALL
-+#define SIZE_STR	" (small)"
-+#else
-+#define SIZE_STR	""
-+#endif
-+
-+#ifdef DISABLE_TEST_MODE
-+/* (mode == 0) == no undocumented chip tweaks
-+ * (mode & 1)  == double buffer bulk IN
-+ * (mode & 2)  == double buffer bulk OUT
-+ * ... so mode = 3 (or 7, 15, etc) does it for both
-+ */
-+static ushort fifo_mode = 0;
-+MODULE_PARM (fifo_mode, "h");
-+MODULE_PARM_DESC (fifo_mode, "pxa2xx udc fifo mode");
-+#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);
-+
-+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", __FUNCTION__);
-+		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", __FUNCTION__, _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", __FUNCTION__, _ep->name);
-+		return -ERANGE;
-+	}
-+
-+	dev = ep->dev;
-+	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
-+		DMSG("%s, bogus device state\n", __FUNCTION__);
-+		return -ESHUTDOWN;
-+	}
-+
-+	ep->desc = desc;
-+	ep->dma = -1;
-+	ep->stopped = 0;
-+	ep->pio_irqs = ep->dma_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 ... */
-+
-+#ifdef	USE_DMA
-+	/* for (some) bulk and ISO endpoints, try to get a DMA channel and
-+	 * bind it to the endpoint.  otherwise use PIO. 
-+	 */
-+	switch (ep->bmAttributes) {
-+	case USB_ENDPOINT_XFER_ISOC:
-+		if (le16_to_cpu(desc->wMaxPacketSize) % 32)
-+			break;
-+		// fall through
-+	case USB_ENDPOINT_XFER_BULK:
-+		if (!use_dma || !ep->reg_drcmr)
-+			break;
-+		/* no bulk-out dma yet (pointless w/o descriptors) */
-+		if ((ep->bmAttributes == USB_ENDPOINT_XFER_BULK)
-+				&& (ep->bEndpointAddress & USB_DIR_IN) == 0) {
-+			DMSG("%s dma-out NYI\n", _ep->name);
-+			break;
-+		}
-+		ep->dma = pxa_request_dma ((char *)_ep->name,
-+				(le16_to_cpu(desc->wMaxPacketSize) > 64)
-+					? DMA_PRIO_MEDIUM /* some iso */
-+					: DMA_PRIO_LOW,
-+				// FIXME or ep_out_dma .. ..
-+				dma_nodesc_handler, ep);
-+		if (ep->dma >= 0) {
-+			*ep->reg_drcmr = DRCMR_MAPVLD | ep->dma;
-+			DMSG("%s using dma%d\n", _ep->name, ep->dma);
-+		}
-+	}
-+#endif
-+
-+	DBG(DBG_VERBOSE, "enabled %s\n", _ep->name);
-+	return 0;
-+}
-+
-+static int pxa2xx_ep_disable (struct usb_ep *_ep)
-+{
-+	struct pxa2xx_ep	*ep;
-+
-+	ep = container_of (_ep, struct pxa2xx_ep, ep);
-+	if (!_ep || !ep->desc) {
-+		DMSG("%s, %s not enabled\n", __FUNCTION__,
-+			_ep ? ep->ep.name : NULL);
-+		return -EINVAL;
-+	}
-+	nuke (ep, -ESHUTDOWN);
-+
-+#ifdef	USE_DMA
-+	if (ep->dma >= 0) {
-+		*ep->reg_drcmr = 0;
-+		pxa_free_dma (ep->dma);
-+		ep->dma = -1;
-+	}
-+#endif
-+
-+	/* flush fifo (mostly for IN buffers) */
-+	pxa2xx_ep_fifo_flush (_ep);
-+
-+	ep->desc = 0;
-+	ep->stopped = 1;
-+
-+	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, int gfp_flags)
-+{
-+	struct pxa2xx_request *req;
-+
-+	/* FIXME for bulk out-dma endpoints, preallocate a frame's worth of
-+	 * (aligned) dma descriptors at the end of the request
-+	 */
-+
-+	req = kmalloc (sizeof *req, gfp_flags);
-+	if (!req)
-+		return 0;
-+
-+	memset (req, 0, sizeof *req);
-+	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);
-+}
-+
-+
-+/* PXA cache needs flushing with DMA I/O (it's dma-incoherent), but there's
-+ * no device-affinity and the heap works perfectly well for i/o buffers.
-+ */
-+static void *
-+pxa2xx_ep_alloc_buffer(struct usb_ep *_ep, unsigned bytes,
-+	dma_addr_t *dma, int gfp_flags)
-+{
-+	char			*retval;
-+
-+	retval = kmalloc (bytes, gfp_flags & ~(__GFP_DMA|__GFP_HIGHMEM));
-+	if (retval)
-+		*dma = virt_to_bus (retval);
-+	return retval;
-+}
-+
-+static void
-+pxa2xx_ep_free_buffer(struct usb_ep *_ep, void *buf, dma_addr_t dma,
-+		unsigned bytes)
-+{
-+	kfree (buf);
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ *	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;
-+	LED_EP0_OFF;
-+}
-+
-+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) || unlikely(ep->dma >= 0))
-+				pio_irq_disable (ep->bEndpointAddress);
-+#ifdef USE_DMA
-+			if (unlikely(ep->dma >= 0) && !list_empty(&ep->queue)) {
-+DMSG("%s pio2dma\n", ep->ep.name);
-+				req = list_entry(ep->queue.next,
-+						struct pxa2xx_request, queue);
-+				kick_dma(ep,req);
-+				return 0;
-+			}
-+#endif
-+			return 1;
-+		}
-+
-+		// TODO experiment: how robust can fifo mode tweaking be?
-+		// the double buffering could speed up I/O a bunch.
-+
-+	} 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",
-+		__FUNCTION__, 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);
-+#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
-+	} 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;
-+}
-+
-+#ifdef	USE_DMA
-+
-+static inline void
-+start_dma_nodesc(struct pxa2xx_ep *ep, struct pxa2xx_request *req, int is_in)
-+{
-+	u32	dcmd = req->req.length;
-+	u32	buf = virt_to_bus (req->req.buf);
-+	u32	fifo = io_v2p ((u32)ep->reg_uddr);
-+
-+	/* no-descriptor mode can be simple for bulk-in, iso-in, iso-out */
-+	DCSR(ep->dma) = DCSR_NODESC;
-+	dcmd |= DCMD_BURST32 | DCMD_ENDIRQEN | DCMD_WIDTH1;
-+	if (is_in) {
-+		DSADR(ep->dma) = buf;
-+		DTADR(ep->dma) = fifo;
-+		dcmd |= DCMD_FLOWTRG | DCMD_INCSRCADDR;
-+	} else {
-+		DSADR(ep->dma) = fifo;
-+		DTADR(ep->dma) = buf;
-+		dcmd |= DCMD_FLOWSRC | DCMD_INCTRGADDR;
-+	}
-+	DCMD(ep->dma) = dcmd;
-+	DCSR(ep->dma) = DCSR_RUN | DCSR_STOPIRQEN | DCSR_NODESC;
-+	/* and later the dma handler gets called */
-+}
-+
-+static void kick_dma(struct pxa2xx_ep *ep, struct pxa2xx_request *req)
-+{
-+	if (ep->bEndpointAddress & USB_DIR_IN) {
-+		/* docs imply we can't preload with pio */
-+		if ((((u32)req->req.buf) & 0x0f) != 0) {
-+// VERBOSE
-+			DMSG("%s bad DMA align %p\n",
-+				ep->ep.name, req->req.buf);
-+pio_in:
-+// FIXME PIO fallback doesn't work right yet (recovery?)
-+DMSG("%s dma2pio\n", ep->ep.name);
-+			pio_irq_enable(ep->bEndpointAddress);
-+			if ((*ep->reg_udccs & UDCCS_BI_TFS) != 0)
-+				(void) write_fifo(ep, req);
-+			return;
-+		}
-+		/* dmacount 0 means end-of-transfer */
-+		if (unlikely((req->req.length - req->req.actual) == 0)) {
-+// VERBOSE
-+			DMSG("%s zlp dma write...\n", ep->ep.name);
-+			goto pio_in;
-+		}
-+		start_dma_nodesc(ep, req, USB_DIR_IN);
-+	} else {
-+		// if ISO, use no-descriptor DMA
-+		BUG();
-+	}
-+}
-+
-+static void cancel_dma(struct pxa2xx_ep *ep)
-+{
-+	struct pxa2xx_request	*req;
-+	u32			tmp;
-+
-+	if (DCSR(ep->dma) == 0 || list_empty(&ep->queue))
-+		return;
-+
-+	DCSR(ep->dma) = 0;
-+	while ((DCSR(ep->dma) & DCSR_STOPSTATE) == 0)
-+		cpu_relax();
-+
-+	req = list_entry(ep->queue.next, struct pxa2xx_request, queue);
-+	tmp = DCMD(ep->dma) & DCMD_LENGTH;
-+	req->req.actual = req->req.length - (tmp & DCMD_LENGTH);
-+
-+	/* the last tx packet may be incomplete, so flush the fifo.
-+	 * FIXME correct req.actual if we can
-+	 */
-+	if (ep->bEndpointAddress & USB_DIR_IN)
-+		*ep->reg_udccs = UDCCS_BI_FTF;
-+}
-+
-+static void dma_nodesc_handler(int dmach, void *_ep, struct pt_regs *r)
-+{
-+	struct pxa2xx_ep	*ep = _ep;
-+	struct pxa2xx_request	*req;
-+	u32			tmp;
-+
-+	req = list_entry(ep->queue.next, struct pxa2xx_request, queue);
-+
-+	ep->dev->stats.irqs++;
-+	HEX_DISPLAY(ep->dev->stats.irqs);
-+
-+	/* ack/clear */
-+	tmp = DCSR(ep->dma);
-+	DCSR(ep->dma) = tmp;
-+	if ((tmp & DCSR_STOPSTATE) == 0
-+			|| (DDADR(ep->dma) & DDADR_STOP) != 0) {
-+		DBG(DBG_VERBOSE, "%s, dcsr %08x ddadr %08x\n",
-+			ep->ep.name, DCSR(ep->dma), DDADR(ep->dma));
-+		return;
-+	}
-+	DCSR(ep->dma) = 0;	/* clear DCSR_STOPSTATE */
-+
-+	/* wrap up the transfer, and collect status */
-+	if (unlikely(tmp & DCSR_BUSERR))
-+		req->req.status = -EIO;
-+	tmp = DCMD(ep->dma);
-+	req->req.actual = req->req.length - (tmp & DCMD_LENGTH);
-+	tmp = 1;	/* normally this is the last packet */
-+
-+	if (ep->bEndpointAddress & USB_DIR_IN) {
-+		/* maybe validate final short packet */
-+		if ((ep->bmAttributes == USB_ENDPOINT_XFER_BULK
-+					&& req->req.actual % BULK_FIFO_SIZE)
-+				|| (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC
-+					&& req->req.actual % ISO_FIFO_SIZE))
-+			*ep->reg_udccs = UDCCS_BI_TSP /*|UDCCS_BI_TPC*/;
-+
-+		/* or force a zlp, with pio ... */
-+		else if (ep->bmAttributes == USB_ENDPOINT_XFER_BULK
-+				&& req->req.zero) {
-+			tmp = 0;
-+		}
-+		// if iso, maybe report underrun (TUR)
-+	} else {
-+		BUG();
-+	}
-+
-+	if (likely(tmp != 0))
-+		done(ep, req, 0);
-+
-+	/* maybe re-activate after completion */
-+	if (ep->stopped || list_empty(&ep->queue))
-+		return;
-+	req = list_entry(ep->queue.next, struct pxa2xx_request, queue);
-+	kick_dma(ep, req);
-+}
-+
-+#endif
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static int
-+pxa2xx_ep_queue(struct usb_ep *_ep, struct usb_request *_req, int 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", __FUNCTION__);
-+		return -EINVAL;
-+	}
-+
-+	ep = container_of(_ep, struct pxa2xx_ep, ep);
-+	if (unlikely (!_ep || (!ep->desc && ep->ep.name != ep0name))) {
-+		DMSG("%s, bad ep\n", __FUNCTION__);
-+		return -EINVAL;
-+	}
-+
-+	dev = ep->dev;
-+	if (unlikely (!dev->driver
-+			|| dev->gadget.speed == USB_SPEED_UNKNOWN)) {
-+		DMSG("%s, bogus device state\n", __FUNCTION__);
-+		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;
-+
-+#ifdef	USE_DMA
-+	if (ep->dma >= 0) {
-+		unsigned long	start = (unsigned long) _req->buf;
-+
-+		clean_dcache_range(start, start + _req->length);
-+		/* or for USB_DIR_OUT, invalidate_dcache_range (...) */
-+	}
-+#endif
-+
-+	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 == 0 /* ep0 */) {
-+			unsigned	length = _req->length;
-+
-+			switch (dev->ep0state) {
-+			case EP0_IN_DATA_PHASE:
-+				dev->stats.write.ops++;
-+				if (write_ep0_fifo(ep, req))
-+					req = 0;
-+				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;
-+					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 = 0;
-+				}
-+				break;
-+
-+			default:
-+				DMSG("ep0 i/o, odd state %d\n", dev->ep0state);
-+				local_irq_restore (flags);
-+				return -EL2HLT;
-+			}
-+#ifdef	USE_DMA
-+		/* either start dma or prime pio pump */
-+		} else if (ep->dma >= 0) {
-+			kick_dma(ep, req);
-+#endif
-+		/* can the FIFO can satisfy the request immediately? */
-+		} else if ((ep->bEndpointAddress & USB_DIR_IN) != 0
-+				&& (*ep->reg_udccs & UDCCS_BI_TFS) != 0
-+				&& write_fifo(ep, req)) {
-+			req = 0;
-+		} else if ((*ep->reg_udccs & UDCCS_BO_RFS) != 0
-+				&& read_fifo(ep, req)) {
-+			req = 0;
-+		}
-+
-+		if (likely (req && ep->desc) && ep->dma < 0)
-+			pio_irq_enable(ep->bEndpointAddress);
-+	}
-+
-+	/* pio or dma irq handler advances the queue. */
-+	if (likely (req != 0))
-+		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 */
-+#ifdef	USE_DMA
-+	if (ep->dma >= 0 && !ep->stopped)
-+		cancel_dma(ep);
-+#endif
-+	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;
-+	}
-+
-+#ifdef	USE_DMA
-+	if (ep->dma >= 0 && ep->queue.next == &req->queue && !ep->stopped) {
-+		cancel_dma(ep);
-+		done(ep, req, -ECONNRESET);
-+		/* restart i/o */
-+		if (!list_empty(&ep->queue)) {
-+			req = list_entry(ep->queue.next,
-+					struct pxa2xx_request, queue);
-+			kick_dma(ep, req);
-+		}
-+	} else
-+#endif
-+		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", __FUNCTION__);
-+		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;
-+		LED_EP0_OFF;
-+
-+ 	/* 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", __FUNCTION__);
-+		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", __FUNCTION__);
-+		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,
-+
-+	.alloc_buffer	= pxa2xx_ep_alloc_buffer,
-+	.free_buffer	= pxa2xx_ep_free_buffer,
-+
-+	.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 const struct usb_gadget_ops pxa2xx_udc_ops = {
-+	.get_frame	 = pxa2xx_udc_get_frame,
-+	.wakeup		 = pxa2xx_udc_wakeup,
-+	// current versions must always be self-powered
-+};
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#ifdef UDC_PROC_FILE
-+
-+static const char proc_node_name [] = "driver/udc";
-+
-+static int
-+udc_proc_read(char *page, char **start, off_t off, int count,
-+		int *eof, void *_dev)
-+{
-+	char			*buf = page;
-+	struct pxa2xx_udc	*dev = _dev;
-+	char			*next = buf;
-+	unsigned		size = count;
-+	unsigned long		flags;
-+	int			i, t;
-+	u32			tmp;
-+
-+	if (off != 0)
-+		return 0;
-+
-+	local_irq_save(flags);
-+
-+	/* basic device status */
-+	t = snprintf(next, size, DRIVER_DESC "\n"
-+		"%s version: %s\nGadget driver: %s\nHost %s\n\n",
-+		driver_name, DRIVER_VERSION SIZE_STR DMASTR,
-+		dev->driver ? dev->driver->driver.name : "(none)",
-+		is_usb_connected() ? "full speed" : "disconnected");
-+	size -= t;
-+	next += t;
-+
-+	/* registers for device and ep0 */
-+	t = snprintf(next, size,
-+		"uicr %02X.%02X, usir %02X.%02x, ufnr %02X.%02X\n",
-+		UICR1, UICR0, USIR1, USIR0, UFNRH, UFNRL);
-+	size -= t;
-+	next += t;
-+
-+	tmp = UDCCR;
-+	t = snprintf(next, size,
-+		"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" : "");
-+	size -= t;
-+	next += t;
-+
-+	tmp = UDCCS0;
-+	t = snprintf(next, size,
-+		"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" : "");
-+	size -= t;
-+	next += t;
-+
-+	if (dev->has_cfr) {
-+		tmp = UDCCFR;
-+		t = snprintf(next, size,
-+			"udccfr %02X =%s%s\n", tmp,
-+			(tmp & UDCCFR_AREN) ? " aren" : "",
-+			(tmp & UDCCFR_ACM) ? " acm" : "");
-+		size -= t;
-+		next += t;
-+	}
-+
-+	if (!is_usb_connected() || !dev->driver)
-+		goto done;
-+
-+	t = snprintf(next, size, "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);
-+	size -= t;
-+	next += t;
-+
-+	/* dump endpoint queues */
-+	for (i = 0; i < PXA_UDC_NUM_ENDPOINTS; i++) {
-+		struct pxa2xx_ep	*ep = &dev->ep [i];
-+		struct pxa2xx_request	*req;
-+		int			t;
-+
-+		if (i != 0) {
-+			const struct usb_endpoint_descriptor	*d;
-+
-+			d = ep->desc;
-+			if (!d)
-+				continue;
-+			tmp = *dev->ep [i].reg_udccs;
-+			t = snprintf(next, size,
-+				"%s max %d %s udccs %02x irqs %lu/%lu\n",
-+				ep->ep.name, le16_to_cpu (d->wMaxPacketSize),
-+				(ep->dma >= 0) ? "dma" : "pio", tmp,
-+				ep->pio_irqs, ep->dma_irqs);
-+			/* TODO translate all five groups of udccs bits! */
-+
-+		} else /* ep0 should only have one transfer queued */
-+			t = snprintf(next, size, "ep0 max 16 pio irqs %lu\n",
-+				ep->pio_irqs);
-+		if (t <= 0 || t > size)
-+			goto done;
-+		size -= t;
-+		next += t;
-+
-+		if (list_empty(&ep->queue)) {
-+			t = snprintf(next, size, "\t(nothing queued)\n");
-+			if (t <= 0 || t > size)
-+				goto done;
-+			size -= t;
-+			next += t;
-+			continue;
-+		}
-+		list_for_each_entry(req, &ep->queue, queue) {
-+#ifdef	USE_DMA
-+			if (ep->dma >= 0 && req->queue.prev == &ep->queue)
-+				t = snprintf(next, size,
-+					"\treq %p len %d/%d "
-+					"buf %p (dma%d dcmd %08x)\n",
-+					&req->req, req->req.actual,
-+					req->req.length, req->req.buf,
-+					ep->dma, DCMD(ep->dma)
-+					// low 13 bits == bytes-to-go
-+					);
-+			else
-+#endif
-+				t = snprintf(next, size,
-+					"\treq %p len %d/%d buf %p\n",
-+					&req->req, req->req.actual,
-+					req->req.length, req->req.buf);
-+			if (t <= 0 || t > size)
-+				goto done;
-+			size -= t;
-+			next += t;
-+		}
-+	}
-+
-+done:
-+	local_irq_restore(flags);
-+	*eof = 1;
-+	return count - size;
-+}
-+
-+#define create_proc_files() \
-+	create_proc_read_entry(proc_node_name, 0, NULL, udc_proc_read, dev)
-+#define remove_proc_files() \
-+	remove_proc_entry(proc_node_name, NULL)
-+
-+#else	/* !UDC_PROC_FILE */
-+#define create_proc_files() do {} while (0)
-+#define remove_proc_files() do {} while (0)
-+
-+#endif	/* UDC_PROC_FILE */
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ * 	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 */
-+	make_usb_disappear();
-+
-+	udc_clear_mask_UDCCR(UDCCR_UDE);
-+
-+#ifdef	CONFIG_ARCH_PXA
-+        /* Disable clock for USB device */
-+        CKEN &= ~CKEN11_USB;
-+#endif
-+
-+	ep0_idle (dev);
-+	dev->gadget.speed = USB_SPEED_UNKNOWN;
-+	LED_CONNECTED_OFF;
-+}
-+
-+
-+/*
-+ * 	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 = 0;
-+		ep->stopped = 0;
-+		INIT_LIST_HEAD (&ep->queue);
-+		ep->pio_irqs = ep->dma_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);
-+
-+#ifdef	CONFIG_ARCH_PXA
-+        /* Enable clock for USB device */
-+        CKEN |= CKEN11_USB;
-+#endif
-+
-+	/* 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;
-+	} 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;
-+	}
-+
-+#ifdef	DISABLE_TEST_MODE
-+	/* "test mode" seems to have become the default in later chip
-+	 * revs, preventing double buffering (and invalidating docs).
-+	 * this EXPERIMENT enables it for bulk endpoints by tweaking
-+	 * undefined/reserved register bits (that other drivers clear).
-+	 * Belcarra code comments noted this usage.
-+	 */
-+	if (fifo_mode & 1) {	/* IN endpoints */
-+		UDC_RES1 |= USIR0_IR1|USIR0_IR6;
-+		UDC_RES2 |= USIR1_IR11;
-+	}
-+	if (fifo_mode & 2) {	/* OUT endpoints */
-+		UDC_RES1 |= USIR0_IR2|USIR0_IR7;
-+		UDC_RES2 |= USIR1_IR12;
-+	}
-+#endif
-+
-+	/* caller must be able to sleep in order to cope
-+	 * with startup transients.
-+	 */
-+	schedule_timeout(HZ/10);
-+
-+	/* enable suspend/resume and reset irqs */
-+	udc_clear_mask_UDCCR(UDCCR_SRM | UDCCR_REM);
-+
-+	/* enable ep0 irqs */
-+	UICR0 &= ~UICR0_IM0;
-+
-+	/* if hardware supports it, connect to usb and wait for host */
-+	let_usb_appear();
-+}
-+
-+
-+/* 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->unbind
-+			|| !driver->disconnect
-+			|| !driver->setup)
-+		return -EINVAL;
-+	if (!dev)
-+		return -ENODEV;
-+	if (dev->driver)
-+		return -EBUSY;
-+
-+	/* first hook up the driver ... */
-+	dev->driver = driver;
-+
-+	retval = driver->bind(&dev->gadget);
-+	if (retval) {
-+		DMSG("bind to driver %s --> error %d\n",
-+				driver->driver.name, retval);
-+		dev->driver = 0;
-+		return retval;
-+	}
-+
-+	/* ... then enable host detection and ep0; and we're ready
-+	 * for set_configuration as well as eventual disconnect.
-+	 * NOTE:  this shouldn't power up until later.
-+	 */
-+	DMSG("registered gadget driver '%s'\n", driver->driver.name);
-+	udc_enable(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 = 0;
-+	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 */
-+	LED_CONNECTED_OFF;
-+	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)
-+		return -EINVAL;
-+
-+	local_irq_disable();
-+	udc_disable(dev);
-+	stop_activity(dev, driver);
-+	local_irq_enable();
-+
-+	driver->unbind(&dev->gadget);
-+	dev->driver = 0;
-+
-+	DMSG("unregistered gadget driver '%s'\n", driver->driver.name);
-+	dump_state(dev);
-+	return 0;
-+}
-+EXPORT_SYMBOL(usb_gadget_unregister_driver);
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#ifdef CONFIG_ARCH_LUBBOCK
-+#ifdef LUBBOCK_USB_DISC_IRQ
-+
-+/* Lubbock can report connect or disconnect irqs.  Likely more hardware
-+ * could support it as a timer callback.
-+ *
-+ * FIXME for better power management, keep the hardware powered down
-+ * until a host is powering the link.  means scheduling work later
-+ * in some task that can udc_enable().
-+ */
-+
-+#define	enable_disconnect_irq() \
-+	if (machine_is_lubbock()) { enable_irq(LUBBOCK_USB_DISC_IRQ); }
-+#define	disable_disconnect_irq() \
-+	if (machine_is_lubbock()) { disable_irq(LUBBOCK_USB_DISC_IRQ); }
-+
-+static irqreturn_t
-+usb_connection_irq(int irq, void *_dev, struct pt_regs *r)
-+{
-+	struct pxa2xx_udc	*dev = _dev;
-+
-+	dev->stats.irqs++;
-+	HEX_DISPLAY(dev->stats.irqs);
-+
-+	if (!is_usb_connected()) {
-+		LED_CONNECTED_OFF;
-+		disable_disconnect_irq();
-+		/* report disconnect just once */
-+		if (dev->gadget.speed != USB_SPEED_UNKNOWN) {
-+			DMSG("disconnect %s\n",
-+				dev->driver ? dev->driver->driver.name : 0);
-+			stop_activity(dev, dev->driver);
-+
-+			// udc_disable (dev);
-+			// no more udc irqs
-+			// maybe "ACTION=disconnect /sbin/hotplug gadget".
-+		}
-+	} else if (dev->gadget.speed == USB_SPEED_UNKNOWN) {
-+		LED_CONNECTED_ON;
-+
-+		DMSG("?? connect irq ??\n");
-+
-+		// if there's no driver bound, ignore; else
-+		// udc_enable (dev);
-+		// UDC irqs drive the rest.
-+		// maybe "ACTION=connect /sbin/hotplug gadget".
-+	}
-+	return IRQ_HANDLED;
-+}
-+
-+#endif
-+#endif
-+
-+#ifndef	enable_disconnect_irq
-+#warning USB disconnect() is not yet reported.
-+#define	enable_disconnect_irq()		do {} while (0)
-+#define	disable_disconnect_irq()	do {} while (0)
-+#endif
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+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 = 0;
-+	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:
-+			le16_to_cpus (&u.r.wValue);
-+			le16_to_cpus (&u.r.wIndex);
-+			le16_to_cpus (&u.r.wLength);
-+
-+			LED_EP0_ON;
-+			DBG(DBG_VERBOSE, "SETUP %02x.%02x v%04x i%04x l%04x\n",
-+				u.r.bRequestType, u.r.bRequest,
-+				u.r.wValue, u.r.wIndex, 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",
-+						u.r.wIndex, 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;
-+				LED_EP0_OFF;
-+
-+			/* 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 = 0;
-+
-+		// 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 != 0)) {
-+#ifdef USE_OUT_DMA
-+// TODO didn't yet debug out-dma.  this approach assumes
-+// the worst about short packets and RPC; it might be better.
-+
-+				if (likely(ep->dma >= 0)) {
-+					if (!(udccs & UDCCS_BO_RSP)) {
-+						*ep->reg_udccs = UDCCS_BO_RPC;
-+						ep->dma_irqs++;
-+						return;
-+					}
-+				}
-+#endif
-+				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 pt_regs *r)
-+{
-+	struct pxa2xx_udc	*dev = _dev;
-+	int			handled;
-+
-+	dev->stats.irqs++;
-+	HEX_DISPLAY(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_usb_connected()
-+				? "" : "+disconnect");
-+
-+			if (!is_usb_connected())
-+				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_usb_connected())
-+				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");
-+				if (dev->gadget.speed != USB_SPEED_UNKNOWN)
-+					disable_disconnect_irq();
-+
-+				/* reset driver and endpoints,
-+				 * in case that's not yet done
-+				 */
-+				stop_activity (dev, dev->driver);
-+
-+			} else {
-+				INFO("USB reset\n");
-+				dev->gadget.speed = USB_SPEED_FULL;
-+				LED_CONNECTED_ON;
-+				memset(&dev->stats, 0, sizeof dev->stats);
-+				/* driver and endpoints are still reset */
-+				enable_disconnect_irq();
-+			}
-+
-+		} 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;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ *	cleanup - free resources allocated during init
-+ */
-+static void /*__exit and */ __init cleanup(void)
-+{
-+	struct pxa2xx_udc *dev = the_controller;
-+
-+	if (!dev)
-+		return;
-+
-+	udc_disable(dev);
-+	remove_proc_files();
-+	usb_gadget_unregister_driver(dev->driver);
-+	if (dev->got_irq) {
-+		free_irq(IRQ_USB, dev);
-+		dev->got_irq = 0;
-+	}
-+#ifdef	LUBBOCK_USB_DISC_IRQ
-+	if (dev->got_disc) {
-+		free_irq(LUBBOCK_USB_DISC_IRQ, dev);
-+		dev->got_disc = 0;
-+	}
-+#endif
-+	the_controller = 0;
-+	release_mem_region(REGISTER_FIRST, REGISTER_LENGTH);
-+}
-+module_exit (cleanup);
-+
-+/* 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",
-+		},
-+	},
-+
-+	/* 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,
-+		drcmr (25)
-+	},
-+	.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,
-+		drcmr (26)
-+	},
-+#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,
-+		drcmr (27)
-+	},
-+	.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,
-+		drcmr (28)
-+	},
-+	.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,
-+		drcmr (30)
-+	},
-+	.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,
-+		drcmr (31)
-+	},
-+	.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,
-+		drcmr (32)
-+	},
-+	.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,
-+		drcmr (33)
-+	},
-+	.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,
-+		drcmr (35)
-+	},
-+	.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,
-+		drcmr (36)
-+	},
-+	.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,
-+		drcmr (37)
-+	},
-+	.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,
-+		drcmr (38)
-+	},
-+	.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_IXP425)
-+#define CP15R0_XSCALE_VALUE	0x69054000	/* intel/arm/ixp425 */
-+
-+#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
-+
-+/*
-+ * 	init - allocate resources
-+ */
-+static int __init init(void)
-+{
-+	struct pxa2xx_udc *dev;
-+	int retval, out_dma = 1;
-+	u32 chiprev;
-+
-+	printk(KERN_INFO "%s: version %s\n", driver_name, DRIVER_VERSION);
-+
-+	/* insist on Intel/ARM/XScale */
-+	asm("mrc%? p15, 0, %0, c0, c0" : "=r" (chiprev));
-+	if ((chiprev & CP15R0_VENDOR_MASK) != CP15R0_XSCALE_VALUE) {
-+		printk(KERN_ERR "%s: not XScale!\n", driver_name);
-+		return -ENODEV;
-+	}
-+
-+	/* allocate resources */
-+	if (!request_mem_region(REGISTER_FIRST, REGISTER_LENGTH, driver_name))
-+		return -EBUSY;
-+
-+	/* initialize data */
-+	dev = &memory;
-+
-+	init_timer(&dev->timer);
-+	dev->timer.function = udc_watchdog;
-+	dev->timer.data = (unsigned long) dev;
-+
-+	/* 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 = 0;
-+		/* fall through */
-+	case PXA250_C0: case PXA210_C0:
-+		break;
-+#elif	defined(CONFIG_ARCH_IXP425)
-+	case IXP425_A0:
-+		out_dma = 0;
-+		break;
-+#endif
-+	default:
-+		out_dma = 0;
-+		printk(KERN_ERR "%s: unrecognized processor: %08x\n",
-+			driver_name, chiprev);
-+		return -ENODEV;
-+	}
-+
-+	pr_debug("%s: IRQ %d%s%s%s\n", driver_name, IRQ_USB,
-+		dev->has_cfr ? "" : " (!cfr)",
-+		out_dma ? "" : " (broken dma-out)",
-+		SIZE_STR DMASTR
-+		);
-+
-+#ifdef	USE_DMA
-+#ifndef	USE_OUT_DMA
-+	out_dma = 0;
-+#endif
-+	/* pxa 250 erratum 130 prevents using OUT dma (fixed C0) */
-+	if (!out_dma) {
-+		DMSG("disabled OUT dma\n");
-+		dev->ep[ 2].reg_drcmr = dev->ep[ 4].reg_drcmr = 0;
-+		dev->ep[ 7].reg_drcmr = dev->ep[ 9].reg_drcmr = 0;
-+		dev->ep[12].reg_drcmr = dev->ep[14].reg_drcmr = 0;
-+	}
-+#endif
-+
-+	the_controller = dev;
-+	udc_disable(dev);
-+	udc_reinit(dev);
-+
-+	/* irq setup after old hardware state is cleaned up */
-+	retval = request_irq(IRQ_USB, pxa2xx_udc_irq,
-+			SA_INTERRUPT, driver_name, dev);
-+	if (retval != 0) {
-+		printk(KERN_ERR "%s: can't get irq %i, err %d\n",
-+			driver_name, IRQ_USB, retval);
-+		return -EBUSY;
-+	}
-+	dev->got_irq = 1;
-+
-+#ifdef LUBBOCK_USB_DISC_IRQ
-+	if (machine_is_lubbock()) {
-+		disable_irq(LUBBOCK_USB_DISC_IRQ);
-+		retval = request_irq(LUBBOCK_USB_DISC_IRQ,
-+				usb_connection_irq,
-+				SA_INTERRUPT | SA_SAMPLE_RANDOM,
-+				driver_name, dev);
-+		if (retval != 0) {
-+			enable_irq(LUBBOCK_USB_DISC_IRQ);
-+			printk(KERN_ERR "%s: can't get irq %i, err %d\n",
-+				driver_name, LUBBOCK_USB_DISC_IRQ, retval);
-+			cleanup();
-+			return retval;
-+		}
-+		dev->got_disc = 1;
-+	}
-+#endif
-+
-+	create_proc_files();
-+	return 0;
-+}
-+module_init (init);
-+
-+MODULE_DESCRIPTION(DRIVER_DESC);
-+MODULE_AUTHOR("Frank Becker, Robert Schwebel, David Brownell");
-+MODULE_LICENSE("GPL");
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/pxa2xx_udc.h kernel/drivers/usb/gadget/pxa2xx_udc.h
---- /tmp/kernel/drivers/usb/gadget/pxa2xx_udc.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/pxa2xx_udc.h	2005-04-22 17:53:19.496529422 +0200
-@@ -0,0 +1,528 @@
-+/*
-+ * 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
-+ * 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
-+ */
-+
-+#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) */
-+
-+/* for address space reservation */
-+#define	REGISTER_FIRST	((unsigned long)(&UDCCR))
-+#define	REGISTER_LAST	((unsigned long)(&UDDR14))	/* not UDDR15! */
-+#define REGISTER_LENGTH	((REGISTER_LAST - REGISTER_FIRST) + 4)
-+
-+/*-------------------------------------------------------------------------*/
-+
-+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 long				dma_irqs;
-+	short					dma; 
-+
-+	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;
-+#ifdef USE_DMA
-+	volatile u32				*reg_drcmr;
-+#define	drcmr(n)  .reg_drcmr = & DRCMR ## n ,
-+#else
-+#define	drcmr(n)  
-+#endif
-+};
-+
-+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.  */
-+#undef	USE_DMA
-+#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,
-+						got_disc : 1,
-+						has_cfr : 1,
-+						req_pending : 1,
-+						req_std : 1,
-+						req_config : 1;
-+
-+#define start_watchdog(dev) mod_timer(&dev->timer, jiffies + (HZ/200))
-+	struct timer_list			timer;
-+
-+	struct pxa2xx_ep			ep [PXA_UDC_NUM_ENDPOINTS];
-+};
-+
-+/* 2.5 changes ... */
-+
-+#ifndef container_of
-+#define container_of    list_entry
-+#endif
-+
-+#ifndef WARN_ON
-+#define WARN_ON BUG_ON
-+#endif
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* please keep machine-specific defines in alphabetical order. */
-+
-+// CONFIG_ARCH_ADI_COYOTE behaves
-+
-+#ifdef CONFIG_ARCH_E7XX
-+#  include <asm/arch/e7xx-gpio.h>
-+#endif
-+
-+#ifdef CONFIG_ARCH_H1900
-+#  include <asm/arch/h1900-gpio.h>
-+#endif
-+
-+#ifdef CONFIG_ARCH_H3900
-+#  include <asm/arch/h3900-gpio.h>
-+#endif
-+
-+#ifdef CONFIG_ARCH_H5400
-+#  include <asm/arch/h5400-gpio.h>
-+#endif
-+
-+#ifdef CONFIG_ARCH_INNOKOM
-+#include <asm/arch/innokom.h>
-+#endif
-+
-+#ifdef CONFIG_ARCH_LUBBOCK
-+#include <asm/arch/lubbock.h>
-+/* lubbock can also report usb connect/disconnect irqs */
-+
-+#ifdef DEBUG
-+#define HEX_DISPLAY(n)	if (machine_is_lubbock()) { LUB_HEXLED = (n); }
-+
-+#define LED_CONNECTED_ON	if (machine_is_lubbock()) { \
-+	DISCRETE_LED_ON(D26); }
-+#define LED_CONNECTED_OFF	if(machine_is_lubbock()) { \
-+	DISCRETE_LED_OFF(D26); LUB_HEXLED = 0; }
-+#define LED_EP0_ON	if (machine_is_lubbock()) { DISCRETE_LED_ON(D25); }
-+#define LED_EP0_OFF	if (machine_is_lubbock()) { DISCRETE_LED_OFF(D25); }
-+#endif /* DEBUG */
-+
-+#endif
-+
-+#ifdef CONFIG_ARCH_PXA_CORGI
-+/* Sharp Zaurus C-700, C-750, C-760, C-860 */
-+#define	CORGI_CONNECT_GPIO	45
-+/* use the ARM-Linux registered symbol, not a Lineo-private one */
-+#define CONFIG_MACH_CORGI
-+#endif
-+
-+#ifdef CONFIG_ARCH_PXA_POODLE
-+/* Sharp B-500, SL-5600 */
-+#define	POODLE_CONNECT_GPIO	20
-+/* use the ARM-Linux registered symbol, not a Lineo-private one */
-+#define CONFIG_MACH_POODLE
-+#endif
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* LEDs are only for debug */
-+#ifndef HEX_DISPLAY
-+#define HEX_DISPLAY(n)		do {} while(0)
-+#endif
-+
-+#ifndef LED_CONNECTED_ON
-+#define LED_CONNECTED_ON	do {} while(0)
-+#define LED_CONNECTED_OFF	do {} while(0)
-+#endif
-+#ifndef LED_EP0_ON
-+#define LED_EP0_ON		do {} while (0)
-+#define LED_EP0_OFF		do {} while (0)
-+#endif
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static struct pxa2xx_udc *the_controller;
-+
-+/* one GPIO should be used to detect host disconnect */
-+static int is_usb_connected(void)
-+{
-+	static int first = 0;
-+	
-+	// CONFIG_ARCH_ADI_COYOTE cannot detect or force disconnect
-+#ifdef CONFIG_ARCH_E7XX
-+	if (machine_is_e7xx())
-+		return (GPLR(GPIO_E7XX_USB_DISC)
-+				& GPIO_bit(GPIO_E7XX_USB_DISC));
-+#endif
-+#if 0
-+#ifdef CONFIG_ARCH_H1900
-+	if (machine_is_h1900())
-+		return (!(GPLR(GPIO_NR_H1900_USB_DETECT_N)
-+				& GPIO_bit(GPIO_NR_H1900_USB_DETECT_N)));
-+#endif
-+#ifdef CONFIG_ARCH_H3900
-+	if (machine_is_h3900())
-+		return 1;
-+#endif
-+#ifdef CONFIG_ARCH_H5400
-+	// h5400 ... ?
-+#endif
-+#endif
-+#ifdef CONFIG_ARCH_INNOKOM
-+	if (machine_is_innokom())
-+		return (GPLR(GPIO_INNOKOM_USB_DISC)
-+				& GPIO_bit(GPIO_INNOKOM_USB_DISC));
-+#endif
-+#ifdef CONFIG_ARCH_LUBBOCK
-+	if (machine_is_lubbock())
-+		return ((LUB_MISC_RD & (1 << 9)) == 0);
-+#endif
-+	// Sharp's sources didn't show a corgi or poodle hook
-+
-+	if (!first) {
-+		pr_info("%s: can't check host connect\n", driver_name);
-+		first++;
-+	}
-+	return 1;
-+}
-+
-+static int disc_first = 0;
-+
-+/* one GPIO should force the host to see this device (or not) */
-+static void make_usb_disappear(void)
-+{
-+	// CONFIG_ARCH_ADI_COYOTE cannot detect or force disconnect
-+#ifdef CONFIG_ARCH_E7XX
-+	if (machine_is_e7xx()) {
-+		GPSR(GPIO_E7XX_USB_PULLUP) = GPIO_bit(GPIO_E7XX_USB_PULLUP);
-+		return;
-+	}
-+#endif
-+	// h1900 ... ?
-+#ifdef CONFIG_ARCH_H3900
-+	if (machine_is_h3900()) {
-+		GPDR0 &= ~GPIO_H3900_USBP_PULLUP;
-+		return;
-+	}
-+#endif
-+#ifdef CONFIG_ARCH_H5400
-+	if (machine_is_h5400()) {
-+		GPDR(GPIO_NR_H5400_USB_PULLUP) &=
-+					~GPIO_bit(GPIO_NR_H5400_USB_PULLUP);
-+		return;
-+	}
-+#endif
-+#ifdef CONFIG_ARCH_INNOKOM
-+	if (machine_is_innokom()) {
-+		GPSR(GPIO_INNOKOM_USB_ONOFF) = GPIO_bit(GPIO_INNOKOM_USB_ONOFF);
-+		printk("innokom: disappear\n");
-+		udelay(5);
-+		return;
-+	}
-+#endif
-+#ifdef CONFIG_ARCH_CSB226
-+	if (machine_is_csb226()) {
-+		GPCR0 |= 0x00000080;
-+		printk("csb226: disappear\n");
-+		udelay(5);
-+		return;
-+	}
-+#endif
-+	// lubbock has no D+ pullup
-+#ifdef CONFIG_MACH_CORGI
-+	if (machine_is_corgi()) {
-+		GPDR(CORGI_CONNECT_GPIO) |= GPIO_bit(CORGI_CONNECT_GPIO);
-+		GPCR(CORGI_CONNECT_GPIO) = GPIO_bit(CORGI_CONNECT_GPIO);
-+	}
-+#endif
-+#ifdef CONFIG_MACH_POODLE
-+	if (machine_is_poodle()) {
-+		GPDR(POODLE_CONNECT_GPIO) |= GPIO_bit(POODLE_CONNECT_GPIO);
-+		GPCR(POODLE_CONNECT_GPIO) = GPIO_bit(POODLE_CONNECT_GPIO);
-+	}
-+#endif
-+
-+	if (!disc_first) {
-+		pr_info("%s: can't force usb disconnect\n", driver_name);
-+		disc_first++;
-+	}
-+}
-+
-+static void let_usb_appear(void)
-+{
-+	// CONFIG_ARCH_ADI_COYOTE cannot detect or force disconnect
-+#ifdef CONFIG_ARCH_E7XX
-+	if (machine_is_e7xx()) {
-+		GPCR(GPIO_E7XX_USB_PULLUP) = GPIO_bit(GPIO_E7XX_USB_PULLUP);
-+		return;
-+	}
-+#endif
-+	// h1900 ... ?
-+#ifdef CONFIG_ARCH_H3900
-+	if (machine_is_h3900()) {
-+		GPDR0 |= GPIO_H3900_USBP_PULLUP;
-+		GPSR0 |= GPIO_H3900_USBP_PULLUP;
-+		return;
-+	}
-+#endif
-+#ifdef CONFIG_ARCH_H5400
-+	if (machine_is_h5400()) {
-+		GPDR(GPIO_NR_H5400_USB_PULLUP) |=
-+					GPIO_bit(GPIO_NR_H5400_USB_PULLUP);
-+		return;
-+	}
-+#endif
-+#ifdef CONFIG_ARCH_INNOKOM
-+	if (machine_is_innokom()) {
-+		GPCR(GPIO_INNOKOM_USB_ONOFF) = GPIO_bit(GPIO_INNOKOM_USB_ONOFF);
-+		printk("innokom: appear\n");
-+		udelay(5);
-+		return;
-+	}
-+#endif
-+#ifdef CONFIG_ARCH_CSB226
-+	if (machine_is_csb226()) {
-+		GPDR0 |= 0x00000080;
-+		GPSR0 |= 0x00000080;
-+		printk("csb226: appear\n");
-+		udelay(5);
-+		return;
-+	}
-+#endif
-+	// lubbock has no D+ pullup
-+#ifdef CONFIG_MACH_CORGI
-+	if (machine_is_corgi()) {
-+		GPDR(CORGI_CONNECT_GPIO) |= GPIO_bit(CORGI_CONNECT_GPIO);
-+		GPSR(CORGI_CONNECT_GPIO) = GPIO_bit(CORGI_CONNECT_GPIO);
-+	}
-+#endif
-+#ifdef CONFIG_MACH_POODLE
-+	if (machine_is_poodle()) {
-+		GPDR(POODLE_CONNECT_GPIO) |= GPIO_bit(POODLE_CONNECT_GPIO);
-+		GPSR(POODLE_CONNECT_GPIO) = GPIO_bit(POODLE_CONNECT_GPIO);
-+	}
-+#endif
-+
-+	if (!disc_first) {
-+		pr_info("%s: can't force usb disconnect\n", driver_name);
-+		disc_first++;
-+	}
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* LEDs are only for debug */
-+#ifndef LED_CONNECTED_ON
-+#define LED_CONNECTED_ON	do {} while(0)
-+#define LED_CONNECTED_OFF	do {} while(0)
-+#endif
-+#ifndef LED_EP0_ON
-+#define LED_EP0_ON		do {} while (0)
-+#define LED_EP0_OFF		do {} while (0)
-+#endif
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ * 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 */
-+
-+#ifdef DEBUG
-+
-+static const char *state_name[] = {
-+	"EP0_IDLE",
-+	"EP0_IN_DATA_PHASE", "EP0_OUT_DATA_PHASE",
-+	"EP0_END_XFER", "EP0_STALL"
-+};
-+
-+#define DMSG(stuff...) printk(KERN_DEBUG "udc: " stuff)
-+
-+#ifdef VERBOSE
-+#    define UDC_DEBUG DBG_VERBOSE
-+#else
-+#    define UDC_DEBUG DBG_NORMAL
-+#endif
-+
-+static void __attribute__ ((__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 __attribute__ ((__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 __attribute__ ((__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_usb_connected() ? "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_usb_connected())
-+		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 == 0)
-+			continue;
-+		DMSG ("udccs%d = %02x\n", i, *dev->ep->reg_udccs);
-+	}
-+}
-+
-+#else
-+
-+#define DMSG(stuff...)		do{}while(0)
-+
-+#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 WARN(stuff...) printk(KERN_WARNING "udc: " stuff)
-+#define INFO(stuff...) printk(KERN_INFO "udc: " stuff)
-+
-+
-+/* 2.4 backport support */
-+#define irqreturn_t	void
-+#define	IRQ_HANDLED
-+
-+
-+#endif /* __LINUX_USB_GADGET_PXA2XX_H */
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/rndis.c kernel/drivers/usb/gadget/rndis.c
---- /tmp/kernel/drivers/usb/gadget/rndis.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/rndis.c	2005-04-22 17:53:19.501528608 +0200
-@@ -0,0 +1,1425 @@
-+/* 
-+ * 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
-+ * 
-+ *              This program is free software; you can redistribute it and/or
-+ *              modify it under the terms of the GNU General Public License
-+ *              version 2, as published by the Free Software Foundation. 
-+ * 
-+ *		This software was originally developed in conformance with
-+ *		Microsoft's Remote NDIS Specification License Agreement.
-+ *              
-+ * 03/12/2004 Kai-Uwe Bloem <linux-development@auerswald.de>
-+ *		Fixed message length bug in init_response
-+ * 
-+ * 03/25/2004 Kai-Uwe Bloem <linux-development@auerswald.de>
-+ * 		Fixed rndis_rm_hdr length bug.
-+ *
-+ * Copyright (C) 2004 by David Brownell
-+ *		updates to merge with Linux 2.6, better match RNDIS spec
-+ */
-+
-+#include <linux/config.h>
-+#include <linux/module.h>
-+#include <linux/moduleparam.h>
-+#include <linux/kernel.h>
-+#include <linux/errno.h>
-+#include <linux/version.h>
-+#include <linux/init.h>
-+#include <linux/list.h>
-+#include <linux/proc_fs.h>
-+#include <linux/netdevice.h>
-+
-+#include <asm/io.h>
-+#include <asm/byteorder.h>
-+#include <asm/system.h>
-+
-+
-+#undef	RNDIS_PM
-+#undef	VERBOSE
-+
-+#include "rndis.h"
-+
-+
-+/* The driver for your USB chip needs to support ep0 OUT to work with
-+ * RNDIS, plus all three CDC Ethernet endpoints (interrupt not optional).
-+ *
-+ * Windows hosts need an INF file like Documentation/usb/linux.inf
-+ * and will be happier if you provide the host_addr module parameter.
-+ */
-+
-+#if 0
-+#define DEBUG(str,args...) do { \
-+	if (rndis_debug) \
-+		printk(KERN_DEBUG str , ## args ); \
-+	} while (0)
-+static int rndis_debug = 0;
-+
-+module_param (rndis_debug, bool, 0);
-+MODULE_PARM_DESC (rndis_debug, "enable debugging");
-+
-+#else
-+
-+#define rndis_debug		0
-+#define DEBUG(str,args...)	do{}while(0)
-+#endif
-+
-+#define RNDIS_MAX_CONFIGS	1
-+
-+
-+static rndis_params rndis_per_dev_params [RNDIS_MAX_CONFIGS];
-+
-+/* Driver Version */
-+static const u32 rndis_driver_version = __constant_cpu_to_le32 (1);
-+
-+/* Function Prototypes */
-+static int rndis_init_response (int configNr, rndis_init_msg_type *buf);
-+static int rndis_query_response (int configNr, rndis_query_msg_type *buf);
-+static int rndis_set_response (int configNr, rndis_set_msg_type *buf);
-+static int rndis_reset_response (int configNr, rndis_reset_msg_type *buf);
-+static int rndis_keepalive_response (int configNr, 
-+				     rndis_keepalive_msg_type *buf);
-+
-+static rndis_resp_t *rndis_add_response (int configNr, u32 length);
-+
-+
-+/* NDIS Functions */
-+static int gen_ndis_query_resp (int configNr, u32 OID, rndis_resp_t *r)
-+{
-+	int 			retval = -ENOTSUPP;
-+	u32 			length = 0;
-+	u32			*tmp;
-+	int			i, count;
-+	rndis_query_cmplt_type	*resp;
-+
-+	if (!r) return -ENOMEM;
-+	resp = (rndis_query_cmplt_type *) r->buf;
-+
-+	if (!resp) return -ENOMEM;
-+	
-+	switch (OID) {
-+
-+	/* general oids (table 4-1) */
-+
-+	/* mandatory */
-+	case OID_GEN_SUPPORTED_LIST:
-+		DEBUG ("%s: OID_GEN_SUPPORTED_LIST\n", __FUNCTION__);
-+		length = sizeof (oid_supported_list);
-+		count  = length / sizeof (u32);
-+		tmp = (u32 *) ((u8 *)resp + 24);
-+		for (i = 0; i < count; i++)
-+			tmp[i] = cpu_to_le32 (oid_supported_list[i]);
-+		retval = 0;
-+		break;
-+		
-+	/* mandatory */
-+	case OID_GEN_HARDWARE_STATUS:
-+		DEBUG("%s: OID_GEN_HARDWARE_STATUS\n", __FUNCTION__);
-+		length = 4;
-+		/* Bogus question! 
-+		 * Hardware must be ready to receive high level protocols.
-+		 * BTW: 
-+		 * reddite ergo quae sunt Caesaris Caesari
-+		 * et quae sunt Dei Deo!
-+		 */
-+		*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+		retval = 0;
-+		break;
-+		
-+	/* mandatory */
-+	case OID_GEN_MEDIA_SUPPORTED:
-+		DEBUG("%s: OID_GEN_MEDIA_SUPPORTED\n", __FUNCTION__);
-+		length = 4;
-+		*((u32 *) resp + 6) = cpu_to_le32 (
-+					rndis_per_dev_params [configNr].medium);
-+		retval = 0;
-+		break;
-+		
-+	/* mandatory */
-+	case OID_GEN_MEDIA_IN_USE:
-+		DEBUG("%s: OID_GEN_MEDIA_IN_USE\n", __FUNCTION__);
-+		length = 4;
-+		/* one medium, one transport... (maybe you do it better) */
-+		*((u32 *) resp + 6) = cpu_to_le32 (
-+					rndis_per_dev_params [configNr].medium);
-+		retval = 0;
-+		break;
-+		
-+	/* mandatory */
-+	case OID_GEN_MAXIMUM_FRAME_SIZE:
-+		DEBUG("%s: OID_GEN_MAXIMUM_FRAME_SIZE\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].dev) {
-+			length = 4;
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr].dev->mtu);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	/* mandatory */
-+	case OID_GEN_LINK_SPEED:
-+		DEBUG("%s: OID_GEN_LINK_SPEED\n", __FUNCTION__);
-+		length = 4;
-+		if (rndis_per_dev_params [configNr].media_state
-+			== NDIS_MEDIA_STATE_DISCONNECTED)
-+		    *((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+		else
-+		    *((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr].speed);
-+		retval = 0;
-+		break;
-+
-+	/* mandatory */
-+	case OID_GEN_TRANSMIT_BLOCK_SIZE:
-+		DEBUG("%s: OID_GEN_TRANSMIT_BLOCK_SIZE\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].dev) {
-+			length = 4;
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr].dev->mtu);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	/* mandatory */
-+	case OID_GEN_RECEIVE_BLOCK_SIZE:
-+		DEBUG("%s: OID_GEN_RECEIVE_BLOCK_SIZE\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].dev) {
-+			length = 4;
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr].dev->mtu);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	/* mandatory */
-+	case OID_GEN_VENDOR_ID:
-+		DEBUG("%s: OID_GEN_VENDOR_ID\n", __FUNCTION__);
-+		length = 4;
-+		*((u32 *) resp + 6) = cpu_to_le32 (
-+			rndis_per_dev_params [configNr].vendorID);
-+		retval = 0;
-+		break;
-+		
-+	/* mandatory */
-+	case OID_GEN_VENDOR_DESCRIPTION:
-+		DEBUG("%s: OID_GEN_VENDOR_DESCRIPTION\n", __FUNCTION__);
-+		length = strlen (rndis_per_dev_params [configNr].vendorDescr);
-+		memcpy ((u8 *) resp + 24, 
-+			rndis_per_dev_params [configNr].vendorDescr, length);
-+		retval = 0;
-+		break;
-+
-+	case OID_GEN_VENDOR_DRIVER_VERSION:
-+		DEBUG("%s: OID_GEN_VENDOR_DRIVER_VERSION\n", __FUNCTION__);
-+		length = 4;
-+		/* Created as LE */
-+		*((u32 *) resp + 6) = rndis_driver_version;
-+		retval = 0;
-+		break;
-+
-+	/* mandatory */
-+	case OID_GEN_CURRENT_PACKET_FILTER:
-+		DEBUG("%s: OID_GEN_CURRENT_PACKET_FILTER\n", __FUNCTION__);
-+		length = 4;
-+		*((u32 *) resp + 6) = cpu_to_le32 (
-+					rndis_per_dev_params[configNr].filter);
-+		retval = 0;
-+		break;
-+
-+	/* mandatory */
-+	case OID_GEN_MAXIMUM_TOTAL_SIZE:
-+		DEBUG("%s: OID_GEN_MAXIMUM_TOTAL_SIZE\n", __FUNCTION__);
-+		length = 4;
-+		*((u32 *) resp + 6) = __constant_cpu_to_le32(
-+					RNDIS_MAX_TOTAL_SIZE);
-+		retval = 0;
-+		break;
-+
-+	/* mandatory */
-+	case OID_GEN_MEDIA_CONNECT_STATUS:
-+		DEBUG("%s: OID_GEN_MEDIA_CONNECT_STATUS\n", __FUNCTION__);
-+		length = 4;
-+		*((u32 *) resp + 6) = cpu_to_le32 (
-+					rndis_per_dev_params [configNr]
-+						.media_state);
-+		retval = 0;
-+		break;
-+
-+	case OID_GEN_PHYSICAL_MEDIUM:
-+		DEBUG("%s: OID_GEN_PHYSICAL_MEDIUM\n", __FUNCTION__);
-+		length = 4;
-+		*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+		retval = 0;
-+		break;
-+
-+	/* The RNDIS specification is incomplete/wrong.   Some versions
-+	 * of MS-Windows expect OIDs that aren't specified there.  Other
-+	 * versions emit undefined RNDIS messages. DOCUMENT ALL THESE!
-+	 */
-+	case OID_GEN_MAC_OPTIONS:		/* from WinME */
-+		DEBUG("%s: OID_GEN_MAC_OPTIONS\n", __FUNCTION__);
-+		length = 4;
-+		*((u32 *) resp + 6) = __constant_cpu_to_le32(
-+			  NDIS_MAC_OPTION_RECEIVE_SERIALIZED
-+			| NDIS_MAC_OPTION_FULL_DUPLEX);
-+		retval = 0;
-+		break;
-+
-+	/* statistics OIDs (table 4-2) */
-+
-+	/* mandatory */
-+	case OID_GEN_XMIT_OK:
-+		DEBUG("%s: OID_GEN_XMIT_OK\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			length = 4;
-+			*((u32 *) resp + 6) = 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);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+
-+	/* mandatory */
-+	case OID_GEN_RCV_OK:
-+		DEBUG("%s: OID_GEN_RCV_OK\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			length = 4;
-+			*((u32 *) resp + 6) = 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);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	/* mandatory */
-+	case OID_GEN_XMIT_ERROR:
-+		DEBUG("%s: OID_GEN_XMIT_ERROR\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			length = 4;
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->tx_errors);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	/* mandatory */
-+	case OID_GEN_RCV_ERROR:
-+		DEBUG("%s: OID_GEN_RCV_ERROR\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->rx_errors);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	/* mandatory */
-+	case OID_GEN_RCV_NO_BUFFER:
-+		DEBUG("%s: OID_GEN_RCV_NO_BUFFER\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->rx_dropped);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+
-+#ifdef	RNDIS_OPTIONAL_STATS
-+	case OID_GEN_DIRECTED_BYTES_XMIT:
-+		DEBUG("%s: OID_GEN_DIRECTED_BYTES_XMIT\n", __FUNCTION__);
-+		/* 
-+		 * Aunt Tilly's size of shoes
-+		 * minus antarctica count of penguins
-+		 * divided by weight of Alpha Centauri
-+		 */
-+		if (rndis_per_dev_params [configNr].stats) {
-+			length = 4;
-+			*((u32 *) resp + 6) = 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;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	case OID_GEN_DIRECTED_FRAMES_XMIT:
-+		DEBUG("%s: OID_GEN_DIRECTED_FRAMES_XMIT\n", __FUNCTION__);
-+		/* dito */
-+		if (rndis_per_dev_params [configNr].stats) {
-+			length = 4;
-+			*((u32 *) resp + 6) = 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;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	case OID_GEN_MULTICAST_BYTES_XMIT:
-+		DEBUG("%s: OID_GEN_MULTICAST_BYTES_XMIT\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->multicast*1234);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	case OID_GEN_MULTICAST_FRAMES_XMIT:
-+		DEBUG("%s: OID_GEN_MULTICAST_FRAMES_XMIT\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->multicast);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	case OID_GEN_BROADCAST_BYTES_XMIT:
-+		DEBUG("%s: OID_GEN_BROADCAST_BYTES_XMIT\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->tx_packets/42*255);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	case OID_GEN_BROADCAST_FRAMES_XMIT:
-+		DEBUG("%s: OID_GEN_BROADCAST_FRAMES_XMIT\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->tx_packets/42);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	case OID_GEN_DIRECTED_BYTES_RCV:
-+		DEBUG("%s: OID_GEN_DIRECTED_BYTES_RCV\n", __FUNCTION__);
-+		*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+		retval = 0;
-+		break;
-+		
-+	case OID_GEN_DIRECTED_FRAMES_RCV:
-+		DEBUG("%s: OID_GEN_DIRECTED_FRAMES_RCV\n", __FUNCTION__);
-+		*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+		retval = 0;
-+		break;
-+		
-+	case OID_GEN_MULTICAST_BYTES_RCV:
-+		DEBUG("%s: OID_GEN_MULTICAST_BYTES_RCV\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->multicast * 1111);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	case OID_GEN_MULTICAST_FRAMES_RCV:
-+		DEBUG("%s: OID_GEN_MULTICAST_FRAMES_RCV\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->multicast);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	case OID_GEN_BROADCAST_BYTES_RCV:
-+		DEBUG("%s: OID_GEN_BROADCAST_BYTES_RCV\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->rx_packets/42*255);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	case OID_GEN_BROADCAST_FRAMES_RCV:
-+		DEBUG("%s: OID_GEN_BROADCAST_FRAMES_RCV\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->rx_packets/42);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	case OID_GEN_RCV_CRC_ERROR:
-+		DEBUG("%s: OID_GEN_RCV_CRC_ERROR\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats) {
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->rx_crc_errors);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	case OID_GEN_TRANSMIT_QUEUE_LENGTH:
-+		DEBUG("%s: OID_GEN_TRANSMIT_QUEUE_LENGTH\n", __FUNCTION__);
-+		*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+		retval = 0;
-+		break;
-+#endif	/* RNDIS_OPTIONAL_STATS */
-+
-+	/* ieee802.3 OIDs (table 4-3) */
-+
-+	/* mandatory */
-+	case OID_802_3_PERMANENT_ADDRESS:
-+		DEBUG("%s: OID_802_3_PERMANENT_ADDRESS\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].dev) {
-+			length = ETH_ALEN;
-+			memcpy ((u8 *) resp + 24,
-+				rndis_per_dev_params [configNr].host_mac,
-+				length);
-+			retval = 0;
-+		} else {
-+			*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	/* mandatory */
-+	case OID_802_3_CURRENT_ADDRESS:
-+		DEBUG("%s: OID_802_3_CURRENT_ADDRESS\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].dev) {
-+			length = ETH_ALEN;
-+			memcpy ((u8 *) resp + 24,
-+				rndis_per_dev_params [configNr].host_mac,
-+				length);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	/* mandatory */
-+	case OID_802_3_MULTICAST_LIST:
-+		DEBUG("%s: OID_802_3_MULTICAST_LIST\n", __FUNCTION__);
-+		length = 4;
-+		/* Multicast base address only */
-+		*((u32 *) resp + 6) = __constant_cpu_to_le32 (0xE0000000);
-+		retval = 0;
-+		break;
-+		
-+	/* mandatory */
-+	case OID_802_3_MAXIMUM_LIST_SIZE:
-+		DEBUG("%s: OID_802_3_MAXIMUM_LIST_SIZE\n", __FUNCTION__);
-+		 length = 4;
-+		/* Multicast base address only */
-+		*((u32 *) resp + 6) = __constant_cpu_to_le32 (1);
-+		retval = 0;
-+		break;
-+		
-+	case OID_802_3_MAC_OPTIONS:
-+		DEBUG("%s: OID_802_3_MAC_OPTIONS\n", __FUNCTION__);
-+		break;
-+
-+	/* ieee802.3 statistics OIDs (table 4-4) */
-+
-+	/* mandatory */
-+	case OID_802_3_RCV_ERROR_ALIGNMENT:
-+		DEBUG("%s: OID_802_3_RCV_ERROR_ALIGNMENT\n", __FUNCTION__);
-+		if (rndis_per_dev_params [configNr].stats)
-+		{
-+			length = 4;
-+			*((u32 *) resp + 6) = cpu_to_le32 (
-+				rndis_per_dev_params [configNr]
-+					.stats->rx_frame_errors);
-+			retval = 0;
-+		}
-+		break;
-+		
-+	/* mandatory */
-+	case OID_802_3_XMIT_ONE_COLLISION:
-+		DEBUG("%s: OID_802_3_XMIT_ONE_COLLISION\n", __FUNCTION__);
-+		length = 4;
-+		*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+		retval = 0;
-+		break;
-+		
-+	/* mandatory */
-+	case OID_802_3_XMIT_MORE_COLLISIONS:
-+		DEBUG("%s: OID_802_3_XMIT_MORE_COLLISIONS\n", __FUNCTION__);
-+		length = 4;
-+		*((u32 *) resp + 6) = __constant_cpu_to_le32 (0);
-+		retval = 0;
-+		break;
-+		
-+#ifdef	RNDIS_OPTIONAL_STATS
-+	case OID_802_3_XMIT_DEFERRED:
-+		DEBUG("%s: OID_802_3_XMIT_DEFERRED\n", __FUNCTION__);
-+		/* TODO */
-+		break;
-+		
-+	case OID_802_3_XMIT_MAX_COLLISIONS:
-+		DEBUG("%s: OID_802_3_XMIT_MAX_COLLISIONS\n", __FUNCTION__);
-+		/* TODO */
-+		break;
-+		
-+	case OID_802_3_RCV_OVERRUN:
-+		DEBUG("%s: OID_802_3_RCV_OVERRUN\n", __FUNCTION__);
-+		/* TODO */
-+		break;
-+		
-+	case OID_802_3_XMIT_UNDERRUN:
-+		DEBUG("%s: OID_802_3_XMIT_UNDERRUN\n", __FUNCTION__);
-+		/* TODO */
-+		break;
-+		
-+	case OID_802_3_XMIT_HEARTBEAT_FAILURE:
-+		DEBUG("%s: OID_802_3_XMIT_HEARTBEAT_FAILURE\n", __FUNCTION__);
-+		/* TODO */
-+		break;
-+		
-+	case OID_802_3_XMIT_TIMES_CRS_LOST:
-+		DEBUG("%s: OID_802_3_XMIT_TIMES_CRS_LOST\n", __FUNCTION__);
-+		/* TODO */
-+		break;
-+		
-+	case OID_802_3_XMIT_LATE_COLLISIONS:
-+		DEBUG("%s: OID_802_3_XMIT_LATE_COLLISIONS\n", __FUNCTION__);
-+		/* TODO */
-+		break;		
-+#endif	/* RNDIS_OPTIONAL_STATS */
-+
-+#ifdef	RNDIS_PM
-+	/* power management OIDs (table 4-5) */
-+	case OID_PNP_CAPABILITIES:
-+		DEBUG("%s: OID_PNP_CAPABILITIES\n", __FUNCTION__);
-+
-+		/* just PM, and remote wakeup on link status change
-+		 * (not magic packet or pattern match)
-+		 */
-+		length = sizeof (struct NDIS_PNP_CAPABILITIES);
-+		memset (resp, 0, length);
-+		{
-+			struct NDIS_PNP_CAPABILITIES *caps = (void *) resp;
-+
-+			caps->Flags = NDIS_DEVICE_WAKE_UP_ENABLE;
-+			caps->WakeUpCapabilities.MinLinkChangeWakeUp 
-+				 = NdisDeviceStateD3;
-+
-+			/* FIXME then use usb_gadget_wakeup(), and
-+			 * set USB_CONFIG_ATT_WAKEUP in config desc
-+			 */
-+		}
-+		retval = 0;
-+		break;
-+	case OID_PNP_QUERY_POWER:
-+		DEBUG("%s: OID_PNP_QUERY_POWER\n", __FUNCTION__);
-+		/* sure, handle any power state that maps to USB suspend */
-+		retval = 0;
-+		break;
-+#endif
-+
-+	default:
-+		printk (KERN_WARNING "%s: query unknown OID 0x%08X\n", 
-+			 __FUNCTION__, OID);
-+	}
-+	
-+	resp->InformationBufferOffset = __constant_cpu_to_le32 (16);
-+	resp->InformationBufferLength = cpu_to_le32 (length);
-+	resp->MessageLength = cpu_to_le32 (24 + length);
-+	r->length = 24 + length;
-+	return retval;
-+}
-+
-+static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len, 
-+			      rndis_resp_t *r)
-+{
-+	rndis_set_cmplt_type		*resp;
-+	int 				i, retval = -ENOTSUPP;
-+	struct rndis_params		*params;
-+
-+	if (!r)
-+		return -ENOMEM;
-+	resp = (rndis_set_cmplt_type *) r->buf;
-+	if (!resp)
-+		return -ENOMEM;
-+
-+	DEBUG("set OID %08x value, len %d:\n", OID, buf_len);
-+	for (i = 0; i < buf_len; i += 16) {
-+		DEBUG ("%03d: "
-+			" %02x %02x %02x %02x"
-+			" %02x %02x %02x %02x"
-+			" %02x %02x %02x %02x"
-+			" %02x %02x %02x %02x"
-+			"\n",
-+			i,
-+			buf[i], buf [i+1],
-+				buf[i+2], buf[i+3],
-+			buf[i+4], buf [i+5],
-+				buf[i+6], buf[i+7],
-+			buf[i+8], buf [i+9],
-+				buf[i+10], buf[i+11],
-+			buf[i+12], buf [i+13],
-+				buf[i+14], buf[i+15]);
-+	}
-+
-+	switch (OID) {
-+	case OID_GEN_CURRENT_PACKET_FILTER:
-+		params = &rndis_per_dev_params [configNr];
-+		retval = 0;
-+
-+		/* FIXME use these NDIS_PACKET_TYPE_* bitflags to
-+		 * filter packets in hard_start_xmit()
-+		 * NDIS_PACKET_TYPE_x == USB_CDC_PACKET_TYPE_x for x in:
-+		 *	PROMISCUOUS, DIRECTED,
-+		 *	MULTICAST, ALL_MULTICAST, BROADCAST
-+		 */
-+		params->filter = cpu_to_le32p((u32 *)buf);
-+		DEBUG("%s: OID_GEN_CURRENT_PACKET_FILTER %08x\n",
-+			__FUNCTION__, params->filter);
-+
-+		/* this call has a significant side effect:  it's
-+		 * what makes the packet flow start and stop, like
-+		 * activating the CDC Ethernet altsetting.
-+		 */
-+		if (params->filter) {
-+			params->state = RNDIS_DATA_INITIALIZED;
-+			netif_carrier_on(params->dev);
-+			if (netif_running(params->dev))
-+				netif_wake_queue (params->dev);
-+		} else {
-+			params->state = RNDIS_INITIALIZED;
-+			netif_carrier_off (params->dev);
-+			netif_stop_queue (params->dev);
-+		}
-+		break;
-+		
-+	case OID_802_3_MULTICAST_LIST:
-+		/* I think we can ignore this */		
-+		DEBUG("%s: OID_802_3_MULTICAST_LIST\n", __FUNCTION__);
-+		retval = 0;
-+		break;
-+#if 0
-+	case OID_GEN_RNDIS_CONFIG_PARAMETER:
-+		{
-+		struct rndis_config_parameter	*param;
-+		param = (struct rndis_config_parameter *) buf;
-+		DEBUG("%s: OID_GEN_RNDIS_CONFIG_PARAMETER '%*s'\n",
-+			__FUNCTION__,
-+			min(cpu_to_le32(param->ParameterNameLength),80),
-+			buf + param->ParameterNameOffset);
-+		retval = 0;
-+		}
-+		break;
-+#endif
-+
-+#ifdef	RNDIS_PM
-+	case OID_PNP_SET_POWER:
-+		DEBUG ("OID_PNP_SET_POWER\n");
-+		/* sure, handle any power state that maps to USB suspend */
-+		retval = 0;
-+		break;
-+
-+	case OID_PNP_ENABLE_WAKE_UP:
-+		/* always-connected ... */
-+		DEBUG ("OID_PNP_ENABLE_WAKE_UP\n");
-+		retval = 0;
-+		break;
-+
-+	// no PM resume patterns supported (specified where?)
-+	// so OID_PNP_{ADD,REMOVE}_WAKE_UP_PATTERN always fails
-+#endif
-+
-+	default:
-+		printk (KERN_WARNING "%s: set unknown OID 0x%08X, size %d\n", 
-+			 __FUNCTION__, OID, buf_len);
-+	}
-+	
-+	return retval;
-+}
-+
-+/* 
-+ * Response Functions 
-+ */
-+
-+static int rndis_init_response (int configNr, rndis_init_msg_type *buf)
-+{
-+	rndis_init_cmplt_type	*resp; 
-+	rndis_resp_t            *r;
-+	
-+	if (!rndis_per_dev_params [configNr].dev) return -ENOTSUPP;
-+	
-+	r = rndis_add_response (configNr, sizeof (rndis_init_cmplt_type));
-+	
-+	if (!r) return -ENOMEM;
-+	
-+	resp = (rndis_init_cmplt_type *) r->buf;
-+	
-+	if (!resp) return -ENOMEM;
-+	
-+	resp->MessageType = __constant_cpu_to_le32 (
-+			REMOTE_NDIS_INITIALIZE_CMPLT);
-+	resp->MessageLength = __constant_cpu_to_le32 (52);
-+	resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
-+	resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
-+	resp->MajorVersion = __constant_cpu_to_le32 (RNDIS_MAJOR_VERSION);
-+	resp->MinorVersion = __constant_cpu_to_le32 (RNDIS_MINOR_VERSION);
-+	resp->DeviceFlags = __constant_cpu_to_le32 (RNDIS_DF_CONNECTIONLESS);
-+	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
-+		+ sizeof (struct ethhdr)
-+		+ sizeof (struct rndis_packet_msg_type)
-+		+ 22);
-+	resp->PacketAlignmentFactor = __constant_cpu_to_le32 (0);
-+	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);
-+	
-+	return 0;
-+}
-+
-+static int rndis_query_response (int configNr, rndis_query_msg_type *buf)
-+{
-+	rndis_query_cmplt_type *resp;
-+	rndis_resp_t            *r;
-+	
-+	// DEBUG("%s: OID = %08X\n", __FUNCTION__, cpu_to_le32(buf->OID));
-+	if (!rndis_per_dev_params [configNr].dev) return -ENOTSUPP;
-+	
-+	/* 
-+	 * we need more memory: 
-+	 * oid_supported_list is the largest answer 
-+	 */
-+	r = rndis_add_response (configNr, sizeof (oid_supported_list));
-+	
-+	if (!r) return -ENOMEM;
-+	resp = (rndis_query_cmplt_type *) r->buf;
-+	
-+	if (!resp) return -ENOMEM;
-+	
-+	resp->MessageType = __constant_cpu_to_le32 (REMOTE_NDIS_QUERY_CMPLT);
-+	resp->MessageLength = __constant_cpu_to_le32 (24);
-+	resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
-+	
-+	if (gen_ndis_query_resp (configNr, cpu_to_le32 (buf->OID), r)) {
-+		/* OID not supported */
-+		resp->Status = __constant_cpu_to_le32 (
-+				RNDIS_STATUS_NOT_SUPPORTED);
-+		resp->InformationBufferLength = __constant_cpu_to_le32 (0);
-+		resp->InformationBufferOffset = __constant_cpu_to_le32 (0);
-+	} 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);
-+	return 0;
-+}
-+
-+static int rndis_set_response (int configNr, rndis_set_msg_type *buf)
-+{
-+	u32			BufLength, BufOffset;
-+	rndis_set_cmplt_type	*resp;
-+	rndis_resp_t		*r;
-+	
-+	r = rndis_add_response (configNr, sizeof (rndis_set_cmplt_type));
-+	
-+	if (!r) return -ENOMEM;
-+	resp = (rndis_set_cmplt_type *) r->buf;
-+	if (!resp) return -ENOMEM;
-+
-+	BufLength = cpu_to_le32 (buf->InformationBufferLength);
-+	BufOffset = cpu_to_le32 (buf->InformationBufferOffset);
-+
-+#ifdef	VERBOSE
-+	DEBUG("%s: Length: %d\n", __FUNCTION__, BufLength);
-+	DEBUG("%s: Offset: %d\n", __FUNCTION__, BufOffset);
-+	DEBUG("%s: InfoBuffer: ", __FUNCTION__);
-+	
-+	for (i = 0; i < BufLength; i++) {
-+		DEBUG ("%02x ", *(((u8 *) buf) + i + 8 + BufOffset));
-+	}
-+	
-+	DEBUG ("\n");
-+#endif
-+	
-+	resp->MessageType = __constant_cpu_to_le32 (REMOTE_NDIS_SET_CMPLT);
-+	resp->MessageLength = __constant_cpu_to_le32 (16);
-+	resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
-+	if (gen_ndis_set_resp (configNr, cpu_to_le32 (buf->OID), 
-+			       ((u8 *) buf) + 8 + BufOffset, BufLength, r))
-+	    resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_NOT_SUPPORTED);
-+	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);
-+	
-+	return 0;
-+}
-+
-+static int rndis_reset_response (int configNr, rndis_reset_msg_type *buf)
-+{
-+	rndis_reset_cmplt_type	*resp;
-+	rndis_resp_t		*r;
-+	
-+	r = rndis_add_response (configNr, sizeof (rndis_reset_cmplt_type));
-+	
-+	if (!r) return -ENOMEM;
-+	resp = (rndis_reset_cmplt_type *) r->buf;
-+	if (!resp) return -ENOMEM;
-+	
-+	resp->MessageType = __constant_cpu_to_le32 (REMOTE_NDIS_RESET_CMPLT);
-+	resp->MessageLength = __constant_cpu_to_le32 (16);
-+	resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
-+	/* 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);
-+
-+	return 0;
-+}
-+
-+static int rndis_keepalive_response (int configNr,
-+				     rndis_keepalive_msg_type *buf)
-+{
-+	rndis_keepalive_cmplt_type	*resp;
-+	rndis_resp_t			*r;
-+
-+	/* host "should" check only in RNDIS_DATA_INITIALIZED state */
-+
-+	r = rndis_add_response (configNr, sizeof (rndis_keepalive_cmplt_type));
-+	resp = (rndis_keepalive_cmplt_type *) r->buf;
-+	if (!resp) return -ENOMEM;
-+		
-+	resp->MessageType = __constant_cpu_to_le32 (
-+			REMOTE_NDIS_KEEPALIVE_CMPLT);
-+	resp->MessageLength = __constant_cpu_to_le32 (16);
-+	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);
-+	
-+	return 0;
-+}
-+
-+
-+/* 
-+ * Device to Host Comunication 
-+ */
-+static int rndis_indicate_status_msg (int configNr, u32 status)
-+{
-+	rndis_indicate_status_msg_type	*resp;	
-+	rndis_resp_t			*r;
-+	
-+	if (rndis_per_dev_params [configNr].state == RNDIS_UNINITIALIZED)
-+	    return -ENOTSUPP;
-+	
-+	r = rndis_add_response (configNr, 
-+				sizeof (rndis_indicate_status_msg_type));
-+	if (!r) return -ENOMEM;
-+	
-+	resp = (rndis_indicate_status_msg_type *) r->buf;
-+	if (!resp) return -ENOMEM;
-+	
-+	resp->MessageType = __constant_cpu_to_le32 (
-+			REMOTE_NDIS_INDICATE_STATUS_MSG);
-+	resp->MessageLength = __constant_cpu_to_le32 (20);
-+	resp->Status = cpu_to_le32 (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);
-+	return 0;
-+}
-+
-+int rndis_signal_connect (int configNr)
-+{
-+	rndis_per_dev_params [configNr].media_state
-+			= NDIS_MEDIA_STATE_CONNECTED;
-+	return rndis_indicate_status_msg (configNr, 
-+					  RNDIS_STATUS_MEDIA_CONNECT);
-+}
-+
-+int rndis_signal_disconnect (int configNr)
-+{
-+	rndis_per_dev_params [configNr].media_state
-+			= NDIS_MEDIA_STATE_DISCONNECTED;
-+	return rndis_indicate_status_msg (configNr,
-+					  RNDIS_STATUS_MEDIA_DISCONNECT);
-+}
-+
-+void rndis_set_host_mac (int configNr, const u8 *addr)
-+{
-+	rndis_per_dev_params [configNr].host_mac = addr;
-+}
-+
-+/* 
-+ * Message Parser 
-+ */
-+int rndis_msg_parser (u8 configNr, u8 *buf)
-+{
-+	u32 MsgType, MsgLength, *tmp;
-+	struct rndis_params		*params;
-+	
-+	if (!buf)
-+		return -ENOMEM;
-+	
-+	tmp = (u32 *) buf; 
-+	MsgType   = cpu_to_le32p(tmp++);
-+	MsgLength = cpu_to_le32p(tmp++);
-+	
-+	if (configNr >= RNDIS_MAX_CONFIGS)
-+		return -ENOTSUPP;
-+	params = &rndis_per_dev_params [configNr];
-+	
-+	/* For USB: responses may take up to 10 seconds */
-+	switch (MsgType)
-+	{
-+	case REMOTE_NDIS_INITIALIZE_MSG:
-+		DEBUG("%s: REMOTE_NDIS_INITIALIZE_MSG\n", 
-+			__FUNCTION__ );
-+		params->state = RNDIS_INITIALIZED;
-+		return  rndis_init_response (configNr,
-+					     (rndis_init_msg_type *) buf);
-+		
-+	case REMOTE_NDIS_HALT_MSG:
-+		DEBUG("%s: REMOTE_NDIS_HALT_MSG\n",
-+			__FUNCTION__ );
-+		params->state = RNDIS_UNINITIALIZED;
-+		if (params->dev) {
-+			netif_carrier_off (params->dev);
-+			netif_stop_queue (params->dev);
-+		}
-+		return 0;
-+		
-+	case REMOTE_NDIS_QUERY_MSG:
-+		return rndis_query_response (configNr, 
-+					     (rndis_query_msg_type *) buf);
-+		
-+	case REMOTE_NDIS_SET_MSG:
-+		return rndis_set_response (configNr, 
-+					   (rndis_set_msg_type *) buf);
-+		
-+	case REMOTE_NDIS_RESET_MSG:
-+		DEBUG("%s: REMOTE_NDIS_RESET_MSG\n", 
-+			__FUNCTION__ );
-+		return rndis_reset_response (configNr,
-+					     (rndis_reset_msg_type *) buf);
-+
-+	case REMOTE_NDIS_KEEPALIVE_MSG:
-+		/* For USB: host does this every 5 seconds */
-+#ifdef	VERBOSE
-+		DEBUG("%s: REMOTE_NDIS_KEEPALIVE_MSG\n", 
-+			__FUNCTION__ );
-+#endif
-+		return rndis_keepalive_response (configNr,
-+						 (rndis_keepalive_msg_type *) 
-+						 buf);
-+		
-+	default: 
-+		/* At least Windows XP emits some undefined RNDIS messages.
-+		 * In one case those messages seemed to relate to the host
-+		 * suspending itself.
-+		 */
-+		printk (KERN_WARNING
-+			"%s: unknown RNDIS message 0x%08X len %d\n", 
-+			__FUNCTION__ , MsgType, MsgLength);
-+		{
-+			unsigned i;
-+			for (i = 0; i < MsgLength; i += 16) {
-+				DEBUG ("%03d: "
-+					" %02x %02x %02x %02x"
-+					" %02x %02x %02x %02x"
-+					" %02x %02x %02x %02x"
-+					" %02x %02x %02x %02x"
-+					"\n",
-+					i,
-+					buf[i], buf [i+1],
-+						buf[i+2], buf[i+3],
-+					buf[i+4], buf [i+5],
-+						buf[i+6], buf[i+7],
-+					buf[i+8], buf [i+9],
-+						buf[i+10], buf[i+11],
-+					buf[i+12], buf [i+13],
-+						buf[i+14], buf[i+15]);
-+			}
-+		}
-+		break;
-+	}
-+	
-+	return -ENOTSUPP;
-+}
-+
-+int rndis_register (int (* rndis_control_ack) (struct net_device *))
-+{
-+	u8 i;
-+	
-+	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;
-+			DEBUG("%s: configNr = %d\n", __FUNCTION__, i);
-+			return i;
-+		}
-+	}
-+	DEBUG("failed\n");
-+	
-+	return -1;
-+}
-+
-+void rndis_deregister (int configNr)
-+{
-+	DEBUG("%s: \n", __FUNCTION__ );
-+	
-+	if (configNr >= RNDIS_MAX_CONFIGS) return;
-+	rndis_per_dev_params [configNr].used = 0;
-+	
-+	return;
-+}
-+
-+int rndis_set_param_dev (u8 configNr, struct net_device *dev, 
-+			 struct net_device_stats *stats)
-+{
-+	DEBUG("%s:\n", __FUNCTION__ );
-+	if (!dev || !stats) return -1;
-+	if (configNr >= RNDIS_MAX_CONFIGS) return -1;
-+	
-+	rndis_per_dev_params [configNr].dev = dev;
-+	rndis_per_dev_params [configNr].stats = stats;
-+	
-+	return 0;
-+}
-+
-+int rndis_set_param_vendor (u8 configNr, u32 vendorID, const char *vendorDescr)
-+{
-+	DEBUG("%s:\n", __FUNCTION__ );
-+	if (!vendorDescr) return -1;
-+	if (configNr >= RNDIS_MAX_CONFIGS) return -1;
-+	
-+	rndis_per_dev_params [configNr].vendorID = vendorID;
-+	rndis_per_dev_params [configNr].vendorDescr = vendorDescr;
-+	
-+	return 0;
-+}
-+
-+int rndis_set_param_medium (u8 configNr, u32 medium, u32 speed)
-+{
-+	DEBUG("%s:\n", __FUNCTION__ );
-+	if (configNr >= RNDIS_MAX_CONFIGS) return -1;
-+	
-+	rndis_per_dev_params [configNr].medium = medium;
-+	rndis_per_dev_params [configNr].speed = speed;
-+	
-+	return 0;
-+}
-+
-+void rndis_add_hdr (struct sk_buff *skb)
-+{
-+	if (!skb) return;
-+	skb_push (skb, sizeof (struct rndis_packet_msg_type));
-+	memset (skb->data, 0, sizeof (struct rndis_packet_msg_type));
-+	*((u32 *) skb->data) = __constant_cpu_to_le32 (1);
-+	*((u32 *) skb->data + 1) = cpu_to_le32(skb->len);
-+	*((u32 *) skb->data + 2) = __constant_cpu_to_le32 (36);
-+	*((u32 *) skb->data + 3) = cpu_to_le32(skb->len - 44);
-+	
-+	return;
-+}
-+
-+void rndis_free_response (int configNr, u8 *buf)
-+{
-+	rndis_resp_t		*r;
-+	struct list_head	*act, *tmp;
-+	
-+	list_for_each_safe (act, tmp, 
-+			    &(rndis_per_dev_params [configNr].resp_queue))
-+	{
-+		r = list_entry (act, rndis_resp_t, list);
-+		if (r && r->buf == buf) {
-+			list_del (&r->list);
-+			kfree (r);
-+		}
-+	}
-+}
-+
-+u8 *rndis_get_next_response (int configNr, u32 *length)
-+{
-+	rndis_resp_t		*r;
-+	struct list_head 	*act, *tmp;
-+	
-+	if (!length) return NULL;
-+	
-+	list_for_each_safe (act, tmp, 
-+			    &(rndis_per_dev_params [configNr].resp_queue))
-+	{
-+		r = list_entry (act, rndis_resp_t, list);
-+		if (!r->send) {
-+			r->send = 1;
-+			*length = r->length;
-+			return r->buf;
-+		}
-+	}
-+	
-+	return NULL;
-+}
-+
-+static rndis_resp_t *rndis_add_response (int configNr, u32 length)
-+{
-+	rndis_resp_t	*r;
-+	
-+	r = kmalloc (sizeof (rndis_resp_t) + length, GFP_ATOMIC);
-+	if (!r) return NULL;
-+	
-+	r->buf = (u8 *) (r + 1);
-+	r->length = length;
-+	r->send = 0;
-+	
-+	list_add_tail (&r->list, 
-+		       &(rndis_per_dev_params [configNr].resp_queue));
-+	return r;
-+}
-+
-+int rndis_rm_hdr (u8 *buf, u32 *length)
-+{
-+	u32 i, messageLen, dataOffset, *tmp;
-+	
-+	tmp = (u32 *) buf; 
-+
-+	if (!buf || !length) return -1;
-+	if (cpu_to_le32p(tmp++) != 1) return -1;
-+	
-+	messageLen = cpu_to_le32p(tmp++);
-+	dataOffset = cpu_to_le32p(tmp++) + 8;
-+
-+	if (messageLen < dataOffset || messageLen > *length) return -1;
-+	
-+	for (i = dataOffset; i < messageLen; i++)
-+		buf [i - dataOffset] = buf [i];
-+		
-+	*length = messageLen - dataOffset;
-+	
-+	return 0;
-+}
-+
-+#ifdef	CONFIG_USB_GADGET_DEBUG_FILES
-+
-+static int rndis_proc_read (char *page, char **start, off_t off, int count, int *eof, 
-+		     void *data)
-+{
-+	char *out = page;
-+	int len;
-+	rndis_params *param = (rndis_params *) data;
-+	
-+	out += snprintf (out, count, 
-+			 "Config Nr. %d\n"
-+			 "used      : %s\n"
-+			 "state     : %s\n"
-+			 "medium    : 0x%08X\n"
-+			 "speed     : %d\n"
-+			 "cable     : %s\n"
-+			 "vendor ID : 0x%08X\n"
-+			 "vendor    : %s\n", 
-+			 param->confignr, (param->used) ? "y" : "n", 
-+			 ({ char *s = "?";
-+			 switch (param->state) {
-+			 case RNDIS_UNINITIALIZED:
-+				s = "RNDIS_UNINITIALIZED"; break;
-+			 case RNDIS_INITIALIZED:
-+				s = "RNDIS_INITIALIZED"; break;
-+			 case RNDIS_DATA_INITIALIZED:
-+				s = "RNDIS_DATA_INITIALIZED"; break;
-+			}; s; }),
-+			 param->medium, 
-+			 (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;
-+}
-+
-+static int rndis_proc_write (struct file *file, const char __user *buffer, 
-+		      unsigned long count, void *data)
-+{
-+	rndis_params *p = data;
-+	u32 speed = 0;
-+	int i, fl_speed = 0;
-+	
-+	for (i = 0; i < count; i++) {
-+		char c;
-+		if (get_user(c, buffer))
-+			return -EFAULT;
-+		switch (c) {
-+		case '0':
-+		case '1':
-+		case '2':
-+		case '3':
-+		case '4':
-+		case '5':
-+		case '6':
-+		case '7':
-+		case '8':
-+		case '9':
-+			fl_speed = 1;
-+			speed = speed*10 + c - '0';
-+			break;
-+		case 'C':
-+		case 'c':
-+			rndis_signal_connect (p->confignr);
-+			break;
-+		case 'D':
-+		case 'd':
-+			rndis_signal_disconnect(p->confignr);
-+			break;
-+		default: 
-+			if (fl_speed) p->speed = speed;
-+			else DEBUG ("%c is not valid\n", c);
-+			break;
-+		}
-+		
-+		buffer++;
-+	}
-+	
-+	return count;
-+}
-+
-+#define	NAME_TEMPLATE	"driver/rndis-%03d"
-+
-+static struct proc_dir_entry *rndis_connect_state [RNDIS_MAX_CONFIGS];
-+
-+#endif	/* CONFIG_USB_GADGET_DEBUG_FILES */
-+
-+
-+int __init rndis_init (void)
-+{
-+	u8 i;
-+
-+	for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
-+#ifdef	CONFIG_USB_GADGET_DEBUG_FILES
-+		char name [20];
-+
-+		sprintf (name, NAME_TEMPLATE, i);
-+		if (!(rndis_connect_state [i]
-+				= create_proc_entry (name, 0660, NULL))) 
-+		{
-+			DEBUG ("%s :remove entries", __FUNCTION__);
-+			while (i) {
-+				sprintf (name, NAME_TEMPLATE, --i);
-+				remove_proc_entry (name, NULL);
-+			}
-+			DEBUG ("\n");
-+			return -EIO;
-+		}
-+
-+		rndis_connect_state [i]->nlink = 1;
-+		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;
-+		rndis_per_dev_params [i].state = RNDIS_UNINITIALIZED;
-+		rndis_per_dev_params [i].media_state
-+				= NDIS_MEDIA_STATE_DISCONNECTED;
-+		INIT_LIST_HEAD (&(rndis_per_dev_params [i].resp_queue));
-+	}
-+	
-+	return 0;
-+}
-+
-+void rndis_exit (void)
-+{
-+#ifdef	CONFIG_USB_GADGET_DEBUG_FILES
-+	u8 i;
-+	char name [20];
-+	
-+	for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
-+		sprintf (name, NAME_TEMPLATE, i);
-+		remove_proc_entry (name, NULL);
-+	}
-+#endif
-+}
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/rndis.h kernel/drivers/usb/gadget/rndis.h
---- /tmp/kernel/drivers/usb/gadget/rndis.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/rndis.h	2005-04-22 17:53:19.504528119 +0200
-@@ -0,0 +1,348 @@
-+/* 
-+ * 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
-+ * 
-+ * 		This program is free software; you can redistribute it and/or
-+ *		modify it under the terms of the GNU General Public License
-+ *		version 2, as published by the Free Software Foundation. 
-+ * 
-+ *		This software was originally developed in conformance with
-+ *		Microsoft's Remote NDIS Specification License Agreement.
-+ */
-+
-+#ifndef _LINUX_RNDIS_H
-+#define _LINUX_RNDIS_H
-+
-+#include "ndis.h"
-+
-+#define RNDIS_MAXIMUM_FRAME_SIZE	1518
-+#define RNDIS_MAX_TOTAL_SIZE		1558
-+
-+/* Remote NDIS Versions */
-+#define RNDIS_MAJOR_VERSION		1
-+#define RNDIS_MINOR_VERSION		0
-+
-+/* Status Values */
-+#define RNDIS_STATUS_SUCCESS		0x00000000U	/* Success           */
-+#define RNDIS_STATUS_FAILURE		0xC0000001U	/* Unspecified error */
-+#define RNDIS_STATUS_INVALID_DATA	0xC0010015U	/* Invalid data      */
-+#define RNDIS_STATUS_NOT_SUPPORTED	0xC00000BBU	/* Unsupported request */
-+#define RNDIS_STATUS_MEDIA_CONNECT	0x4001000BU	/* Device connected  */
-+#define RNDIS_STATUS_MEDIA_DISCONNECT	0x4001000CU	/* Device disconnected */
-+/* For all not specified status messages:
-+ * RNDIS_STATUS_Xxx -> NDIS_STATUS_Xxx 
-+ */
-+
-+/* Message Set for Connectionless (802.3) Devices */
-+#define REMOTE_NDIS_INITIALIZE_MSG	0x00000002U	/* Initialize device */
-+#define REMOTE_NDIS_HALT_MSG		0x00000003U
-+#define REMOTE_NDIS_QUERY_MSG		0x00000004U
-+#define REMOTE_NDIS_SET_MSG		0x00000005U
-+#define REMOTE_NDIS_RESET_MSG		0x00000006U
-+#define REMOTE_NDIS_INDICATE_STATUS_MSG	0x00000007U
-+#define REMOTE_NDIS_KEEPALIVE_MSG	0x00000008U
-+
-+/* Message completion */
-+#define REMOTE_NDIS_INITIALIZE_CMPLT	0x80000002U
-+#define REMOTE_NDIS_QUERY_CMPLT		0x80000004U
-+#define REMOTE_NDIS_SET_CMPLT		0x80000005U
-+#define REMOTE_NDIS_RESET_CMPLT		0x80000006U
-+#define REMOTE_NDIS_KEEPALIVE_CMPLT	0x80000008U
-+
-+/* Device Flags */
-+#define RNDIS_DF_CONNECTIONLESS		0x00000001U
-+#define RNDIS_DF_CONNECTION_ORIENTED	0x00000002U
-+
-+#define RNDIS_MEDIUM_802_3		0x00000000U
-+
-+/* from drivers/net/sk98lin/h/skgepnmi.h */
-+#define OID_PNP_CAPABILITIES			0xFD010100
-+#define OID_PNP_SET_POWER			0xFD010101
-+#define OID_PNP_QUERY_POWER			0xFD010102
-+#define OID_PNP_ADD_WAKE_UP_PATTERN		0xFD010103
-+#define OID_PNP_REMOVE_WAKE_UP_PATTERN		0xFD010104
-+#define OID_PNP_ENABLE_WAKE_UP			0xFD010106
-+
-+
-+/* supported OIDs */
-+static const u32 oid_supported_list [] = 
-+{
-+	/* the general stuff */
-+	OID_GEN_SUPPORTED_LIST,
-+	OID_GEN_HARDWARE_STATUS,
-+	OID_GEN_MEDIA_SUPPORTED,
-+	OID_GEN_MEDIA_IN_USE,
-+	OID_GEN_MAXIMUM_FRAME_SIZE,
-+	OID_GEN_LINK_SPEED,
-+	OID_GEN_TRANSMIT_BLOCK_SIZE,
-+	OID_GEN_RECEIVE_BLOCK_SIZE,
-+	OID_GEN_VENDOR_ID,
-+	OID_GEN_VENDOR_DESCRIPTION,
-+	OID_GEN_VENDOR_DRIVER_VERSION,
-+	OID_GEN_CURRENT_PACKET_FILTER,
-+	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,
-+	OID_GEN_RCV_OK,
-+	OID_GEN_XMIT_ERROR,
-+	OID_GEN_RCV_ERROR,
-+	OID_GEN_RCV_NO_BUFFER,
-+#ifdef	RNDIS_OPTIONAL_STATS
-+	OID_GEN_DIRECTED_BYTES_XMIT,
-+	OID_GEN_DIRECTED_FRAMES_XMIT,
-+	OID_GEN_MULTICAST_BYTES_XMIT,
-+	OID_GEN_MULTICAST_FRAMES_XMIT,
-+	OID_GEN_BROADCAST_BYTES_XMIT,
-+	OID_GEN_BROADCAST_FRAMES_XMIT,
-+	OID_GEN_DIRECTED_BYTES_RCV,
-+	OID_GEN_DIRECTED_FRAMES_RCV,
-+	OID_GEN_MULTICAST_BYTES_RCV,
-+	OID_GEN_MULTICAST_FRAMES_RCV,
-+	OID_GEN_BROADCAST_BYTES_RCV,
-+	OID_GEN_BROADCAST_FRAMES_RCV,
-+	OID_GEN_RCV_CRC_ERROR,
-+	OID_GEN_TRANSMIT_QUEUE_LENGTH,
-+#endif	/* RNDIS_OPTIONAL_STATS */
-+
-+    	/* mandatory 802.3 */
-+	/* the general stuff */
-+	OID_802_3_PERMANENT_ADDRESS,
-+	OID_802_3_CURRENT_ADDRESS,
-+	OID_802_3_MULTICAST_LIST,
-+	OID_802_3_MAC_OPTIONS,
-+	OID_802_3_MAXIMUM_LIST_SIZE,
-+	
-+	/* the statistical stuff */
-+	OID_802_3_RCV_ERROR_ALIGNMENT,
-+	OID_802_3_XMIT_ONE_COLLISION,
-+	OID_802_3_XMIT_MORE_COLLISIONS,
-+#ifdef	RNDIS_OPTIONAL_STATS
-+	OID_802_3_XMIT_DEFERRED,
-+	OID_802_3_XMIT_MAX_COLLISIONS,
-+	OID_802_3_RCV_OVERRUN,
-+	OID_802_3_XMIT_UNDERRUN,
-+	OID_802_3_XMIT_HEARTBEAT_FAILURE,
-+	OID_802_3_XMIT_TIMES_CRS_LOST,
-+	OID_802_3_XMIT_LATE_COLLISIONS,
-+#endif	/* RNDIS_OPTIONAL_STATS */
-+
-+#ifdef	RNDIS_PM
-+	/* PM and wakeup are mandatory for USB: */
-+
-+	/* power management */
-+	OID_PNP_CAPABILITIES,
-+	OID_PNP_QUERY_POWER,
-+	OID_PNP_SET_POWER,
-+
-+	/* wake up host */
-+	OID_PNP_ENABLE_WAKE_UP,
-+	OID_PNP_ADD_WAKE_UP_PATTERN,
-+	OID_PNP_REMOVE_WAKE_UP_PATTERN,
-+#endif
-+};
-+
-+
-+typedef struct rndis_init_msg_type 
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	RequestID;
-+	u32	MajorVersion;
-+	u32	MinorVersion;
-+	u32	MaxTransferSize;
-+} rndis_init_msg_type;
-+
-+typedef struct rndis_init_cmplt_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	RequestID;
-+	u32	Status;
-+	u32	MajorVersion;
-+	u32	MinorVersion;
-+	u32	DeviceFlags;
-+	u32	Medium;
-+	u32	MaxPacketsPerTransfer;
-+	u32	MaxTransferSize;
-+	u32	PacketAlignmentFactor;
-+	u32	AFListOffset;
-+	u32	AFListSize;
-+} rndis_init_cmplt_type;
-+
-+typedef struct rndis_halt_msg_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	RequestID;
-+} rndis_halt_msg_type;
-+
-+typedef struct rndis_query_msg_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	RequestID;
-+	u32	OID;
-+	u32	InformationBufferLength;
-+	u32	InformationBufferOffset;
-+	u32	DeviceVcHandle;
-+} rndis_query_msg_type;
-+
-+typedef struct rndis_query_cmplt_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	RequestID;
-+	u32	Status;
-+	u32	InformationBufferLength;
-+	u32	InformationBufferOffset;
-+} rndis_query_cmplt_type;
-+
-+typedef struct rndis_set_msg_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	RequestID;
-+	u32	OID;
-+	u32	InformationBufferLength;
-+	u32	InformationBufferOffset;
-+	u32	DeviceVcHandle;
-+} rndis_set_msg_type;
-+
-+typedef struct rndis_set_cmplt_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	RequestID;
-+	u32	Status;
-+} rndis_set_cmplt_type;
-+
-+typedef struct rndis_reset_msg_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	Reserved;
-+} rndis_reset_msg_type;
-+
-+typedef struct rndis_reset_cmplt_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	Status;
-+	u32	AddressingReset;
-+} rndis_reset_cmplt_type;
-+
-+typedef struct rndis_indicate_status_msg_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	Status;
-+	u32	StatusBufferLength;
-+	u32	StatusBufferOffset;
-+} rndis_indicate_status_msg_type;
-+
-+typedef struct rndis_keepalive_msg_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	RequestID;
-+} rndis_keepalive_msg_type;
-+
-+typedef struct rndis_keepalive_cmplt_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	RequestID;
-+	u32	Status;
-+} rndis_keepalive_cmplt_type;
-+
-+struct rndis_packet_msg_type
-+{
-+	u32	MessageType;
-+	u32	MessageLength;
-+	u32	DataOffset;
-+	u32	DataLength;
-+	u32	OOBDataOffset;
-+	u32	OOBDataLength;
-+	u32	NumOOBDataElements;
-+	u32	PerPacketInfoOffset;
-+	u32	PerPacketInfoLength;
-+	u32	VcHandle;
-+	u32	Reserved;
-+};
-+
-+struct rndis_config_parameter
-+{
-+	u32	ParameterNameOffset;
-+	u32	ParameterNameLength;
-+	u32	ParameterType;
-+	u32	ParameterValueOffset;
-+	u32	ParameterValueLength;
-+};
-+
-+/* implementation specific */
-+enum rndis_state
-+{
-+	RNDIS_UNINITIALIZED,
-+	RNDIS_INITIALIZED,
-+	RNDIS_DATA_INITIALIZED,
-+};
-+
-+typedef struct rndis_resp_t
-+{
-+	struct list_head	list;
-+	u8			*buf;
-+	u32			length;
-+	int			send;
-+} rndis_resp_t;
-+
-+typedef struct rndis_params
-+{
-+	u8			confignr;
-+	int			used;
-+	enum rndis_state	state;
-+	u32			filter;
-+	u32			medium;
-+	u32			speed;
-+	u32			media_state;
-+	const u8		*host_mac;
-+	struct net_device 	*dev;
-+	struct net_device_stats *stats;
-+	u32			vendorID;
-+	const char		*vendorDescr;
-+	int 			(*ack) (struct net_device *);
-+	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 *));
-+void rndis_deregister (int configNr);
-+int  rndis_set_param_dev (u8 configNr, struct net_device *dev,
-+			 struct net_device_stats *stats);
-+int  rndis_set_param_vendor (u8 configNr, u32 vendorID, 
-+			    const char *vendorDescr);
-+int  rndis_set_param_medium (u8 configNr, u32 medium, u32 speed);
-+void rndis_add_hdr (struct sk_buff *skb);
-+int  rndis_rm_hdr (u8 *buf, u32 *length);
-+u8   *rndis_get_next_response (int configNr, u32 *length);
-+void rndis_free_response (int configNr, u8 *buf);
-+
-+int  rndis_signal_connect (int configNr);
-+int  rndis_signal_disconnect (int configNr);
-+int  rndis_state (int configNr);
-+extern void rndis_set_host_mac (int configNr, const u8 *addr);
-+
-+int __init rndis_init (void);
-+void rndis_exit (void);
-+
-+#endif  /* _LINUX_RNDIS_H */
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/superh_udc.c kernel/drivers/usb/gadget/superh_udc.c
---- /tmp/kernel/drivers/usb/gadget/superh_udc.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/superh_udc.c	2005-04-22 17:53:19.510527142 +0200
-@@ -0,0 +1,1819 @@
-+/*
-+ * Renesas SuperH USB 1.1 device controller (found on SH7705, SH7727...)
-+ *
-+ * Copyright (C) 2003 Renesas Technology Europe Limited
-+ * Copyright (C) 2003 Julian Back (jback@mpc-data.co.uk), MPC Data Limited
-+ *
-+ * 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
-+ */
-+
-+/*
-+ * This is a driver for the USB Device Controller found on Renesas SH
-+ * processors.  This is a full-speed controller which has four
-+ * endpoints in a single fixed configuration.
-+ *
-+ * Limitations
-+ *
-+ * Only tested on SH7705.  Mostly tested with Mass Storage gadget
-+ * using Bulk-Only Transport.  It has been tested with Linux 2.4,
-+ * Linux 2.6, Windows 2000 and Windows XP hosts.
-+ * 
-+ * DMA is not (yet) implemented.
-+ *
-+ * Handling of application stalls is tricky.  We set a bit to stall an
-+ * endpoint.  When the host tries to access the ep it gets a stall and
-+ * another stall bit is latched by the device.  The host clears the
-+ * stall with a clear feature but the hardware doesn't inform us, the
-+ * latched bit is cleared but not the bit we have set, so the next
-+ * time the host accesses the ep it will get another stall and the
-+ * latch will be set again unless we have cleared our stall bit.  The
-+ * solution adopted in this driver is to use a timer to clear the
-+ * application stall bit some time after setting the stall.  This
-+ * seems to work most of the time but is not 100% reliable.  Because
-+ * of this it is best to avoid USB protocols that require the USB
-+ * device to stall the host.  Unfortunately USB mass storage does
-+ * require the device to stall when it gets unsupported commands,
-+ * Linux hosts don't send any of these unsupported commands but
-+ * Windows hosts do.
-+ *
-+ * Another place where the hardware is too clever is in the handling
-+ * of setup packets.  Many setup packets including SET_INTERFACE and
-+ * SET_CONFIGURATION are handled by the hardware without informing the
-+ * driver software.  But we need to inform the gadget driver of at
-+ * least one of these as it uses this to kick of it's data processing.
-+ * The solution adopted is that after we have recieved N setup packets
-+ * following a bus reset a fake SET_CONFIGURATION is sent to the
-+ * gadget.  We also have to arrange things so that the reply to the
-+ * fake packet is not sent out.
-+ *
-+ */
-+
-+#include <linux/config.h>
-+#include <linux/module.h>
-+#include <linux/kernel.h>
-+#include <linux/ioport.h>
-+#include <linux/types.h>
-+#include <linux/version.h>
-+#include <linux/errno.h>
-+#include <linux/delay.h>
-+#include <linux/sched.h>
-+#include <linux/slab.h>
-+#include <linux/init.h>
-+#include <linux/timer.h>
-+#include <linux/list.h>
-+#include <linux/interrupt.h>
-+#include <linux/proc_fs.h>
-+#include <linux/mm.h>
-+
-+#include <asm/atomic.h>
-+#include <asm/byteorder.h>
-+#include <asm/dma.h>
-+#include <asm/io.h>
-+#include <asm/irq.h>
-+#include <asm/system.h>
-+#include <asm/unaligned.h>
-+
-+#include <linux/usb_ch9.h>
-+#include <linux/usb_gadget.h>
-+
-+#undef DEBUG
-+#undef VERY_NOISY
-+
-+#define	DRIVER_DESC		"SuperH USB Peripheral Controller"
-+#define	DRIVER_VERSION		"alpha (11 November 2003)"
-+
-+#ifdef USE_DMA
-+#error "DMA not supported"
-+#endif
-+
-+static const char driver_name [] = "superh_udc";
-+static const char driver_desc [] = DRIVER_DESC;
-+
-+static const char ep0name [] = "ep0";
-+static const char *ep_name [] = {
-+	ep0name,
-+	"ep1out-bulk",
-+	"ep2in-bulk",
-+	"ep3in-bulk",
-+};
-+
-+static struct superh_udc *the_controller;
-+
-+#include "superh_udc.h"
-+
-+/* High priority interrupts */
-+#define F0_HIGH (EP1_FULL | EP2_TR | EP2_EMPTY )
-+#define F1_HIGH (0)
-+
-+/* Low priority interrupts */
-+#define F0_LOW  (BRST | SETUP_TS | EP0o_TS | EP0i_TR | EP0i_TS)
-+#define F1_LOW  (EP3_TR | EP3_TS | VBUSF)
-+
-+/* How long to leave the stall bit set - this value is quite critical
-+ * to making stalls work.  Unfortunately it doesn't seem possible to
-+ * get a value that will work reliably with both fast and slow
-+ * machines.
-+ */
-+#define STALL_TIME     (HZ/75)
-+
-+/* Number of endpoints to check in the unstall timer.  It should not
-+ * be necessary to unstall bulk endpoints using the timer as long as
-+ * the gadget code is aware that this device cannot stall properly
-+ * (see the file backed storage gadget for an example).  But if the
-+ * UDC driver stalls ep0 due to a bad SETUP then the timer is still
-+ * required otherwise the stall will never get cleared.  If it is
-+ * necessary to unstall all endpoints using the timer then set this to
-+ * 4.
-+ */
-+#define EP_TO_UNSTALL  1
-+
-+/* Number of packets to wait for before sending a fake
-+ * SET_CONFIGURATION to the gadget driver
-+ */
-+#define DEFAULT_SETUP_COUNT     7
-+#define RESET_SETUP_COUNT       2
-+
-+/* How long to wait for the number of packets specified above */
-+#define SETUP_TIME              (HZ/10 )
-+
-+static void superh_ep_fifo_flush(struct usb_ep *_ep);
-+static void stop_activity(struct superh_udc *dev, struct usb_gadget_driver *driver);
-+static int superh_ep_set_halt(struct usb_ep *_ep, int value);
-+static void udc_timer(unsigned long _dev);
-+static struct superh_request* process_ep_req(struct superh_ep *ep,
-+					     struct superh_request *req);
-+static void done(struct superh_ep *ep, struct superh_request *req, int status);
-+
-+/*
-+ * IO
-+ */
-+
-+static inline void and_b(u8 mask, unsigned long addr)
-+{
-+	ctrl_outb(ctrl_inb(addr) & mask, addr);
-+}
-+
-+
-+static inline void or_b(u8 mask, unsigned long addr)
-+{
-+	ctrl_outb(ctrl_inb(addr) | mask, addr);
-+}
-+
-+
-+static inline void ep0_idle (struct superh_udc *dev)
-+{
-+	DBG(DBG_VERY_NOISY, "ep0_idle\n");
-+	dev->ep0state = EP0_IDLE;
-+}
-+
-+
-+static void init_udc_timer(struct superh_udc *dev)
-+{
-+	init_timer(&dev->timer);
-+	dev->timer.function = udc_timer;
-+	dev->timer.data = (unsigned long) dev;
-+	dev->timer.expires = jiffies + STALL_TIME;
-+	add_timer(&dev->timer);
-+}
-+
-+/* Send a fake SET_CONFIGURATION to the gadget to start it up.
-+ * Needed because the hardware doesn't let us know when the real packet
-+ * has arrived.
-+ */
-+static void send_fake_config(struct superh_udc *dev)
-+{
-+	struct usb_ctrlrequest r;
-+	dev->fake_config = 1;
-+	dev->setup_countdown = 0;
-+	r.bRequestType = USB_DIR_OUT | USB_TYPE_STANDARD
-+		| USB_RECIP_DEVICE;
-+	r.bRequest = USB_REQ_SET_CONFIGURATION;
-+	r.wValue = 1;  /* configuration to select */
-+	r.wIndex = 0;
-+	r.wLength = 0;
-+	if (dev->driver->setup(&dev->gadget, &r) < 0) {
-+		DMSG("SET_CONFIGURATION failed.\n");
-+	}
-+}
-+
-+/*
-+ * Timer function.  Clears stall from any stalled endpoints as we
-+ * don't get informed when the host has sent a clear feature.
-+ */
-+static void udc_timer(unsigned long _dev)
-+{
-+	struct superh_udc	*dev = (void *)_dev;
-+	int                      i;
-+	unsigned long		flags;
-+
-+	local_irq_save(flags);
-+
-+	if (atomic_read(&dev->in_interrupt) == 0) {
-+
-+		/* Check if a bus reset has been done and we haven't faked a SET_CONFIGURATION */
-+		if (dev->gadget.speed != USB_SPEED_UNKNOWN
-+		    && dev->setup_countdown > 0
-+		    && jiffies - dev->reset_time > SETUP_TIME
-+		    &&list_empty(&dev->ep[0].queue)) {
-+			send_fake_config(dev);
-+		}
-+
-+		/* Check if any end points are halted and restart them */
-+		for (i = 0; i < EP_TO_UNSTALL; i++) {
-+			struct superh_ep *ep = &dev->ep[i];
-+			if (ep->halted) {
-+				DBG(DBG_VERBOSE, "unstalling ep %d\n", i);
-+				superh_ep_set_halt(&ep->ep, 0);
-+				if (likely (!list_empty(&ep->queue))) {
-+					struct superh_request *req
-+						= list_entry(ep->queue.next,
-+							     struct superh_request, queue);
-+					process_ep_req(ep, req);
-+				}
-+			}
-+		}
-+	}
-+
-+	init_udc_timer(dev);
-+
-+	local_irq_restore(flags);
-+}
-+
-+/*
-+ *	done - retire a request; caller blocked irqs
-+ */
-+static void done(struct superh_ep *ep, struct superh_request *req, int status)
-+{
-+	unsigned		stopped = ep->stopped;
-+
-+	DBG(DBG_NOISY, "done: %s %p %d\n", ep->ep.name, req, status);
-+
-+	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;
-+}
-+
-+/*
-+ *	Enable interrupts for the specified endpoint
-+ */
-+static inline void pio_irq_enable(struct superh_ep *ep)
-+{
-+	or_b(ep->interrupt_mask, ep->interrupt_reg);
-+}
-+
-+/*
-+ *	Disable interrupts for the specified endpoint
-+ */
-+static inline void pio_irq_disable(struct superh_ep *ep)
-+{
-+	and_b(~ep->interrupt_mask, ep->interrupt_reg);
-+}
-+
-+/*
-+ * 	nuke - dequeue ALL requests
-+ */
-+static void nuke(struct superh_ep *ep, int status)
-+{
-+	struct superh_request *req;
-+
-+	DBG(DBG_NOISY, "nuke %s %d\n", ep->ep.name, status);
-+
-+	/* called with irqs blocked */
-+#ifdef	USE_DMA
-+	if (ep->dma >= 0 && !ep->stopped)
-+		cancel_dma(ep);
-+#endif
-+	while (!list_empty(&ep->queue)) {
-+		req = list_entry(ep->queue.next,
-+				struct superh_request,
-+				queue);
-+		done(ep, req, status);
-+	}
-+
-+	if (ep->desc)
-+		pio_irq_disable (ep);
-+}
-+
-+static inline void clear_ep_state (struct superh_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 < 4; i++)
-+		nuke(&dev->ep[i], -ECONNABORTED);
-+}
-+
-+/*
-+ * write a packet to an endpoint data register
-+ */
-+static int
-+write_packet(u32 epdr, struct superh_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--))
-+		ctrl_outb(*buf++, epdr);
-+
-+	return length;
-+}
-+
-+static int
-+write_ep0_fifo (struct superh_ep *ep, struct superh_request *req)
-+{
-+	unsigned	count;
-+	int		is_short;
-+
-+	count = write_packet(USBEPDR0I, 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);
-+
-+	ctrl_outb(EP0i_PKTE, USBTRG);
-+
-+	if (unlikely (is_short)) {
-+		ep->dev->ep0state = EP0_END_XFER;
-+
-+		count = req->req.length;
-+		done (ep, req, 0);
-+		/*
-+		 * If we have received a specified number of setups
-+		 * after a bus reset or connect then fake a
-+		 * SET_CONFIGURATION to the driver (as we don't get
-+		 * them from the hardware).
-+		 */
-+		if (ep->dev->setup_countdown >= 0)
-+			ep->dev->setup_countdown--;
-+		if (ep->dev->setup_countdown == 0) {
-+			send_fake_config(ep->dev);
-+		}
-+	}
-+
-+	return is_short;
-+}
-+
-+/*
-+ * handle_ep0_setup
-+ *
-+ * Handles a SETUP request on EP0
-+ */
-+static void handle_ep0_setup(struct superh_udc* dev)
-+{
-+	int i;
-+	union { u8 raw [8]; struct usb_ctrlrequest r; } u;
-+
-+        for (i = 0; i < 8; i++) {
-+		u.raw[i] = ctrl_inb(USBEPDR0S);
-+        }
-+	
-+	/* Send ACK */
-+	ctrl_outb(EP0s_RDFN, USBTRG);
-+
-+	le16_to_cpus (&u.r.wValue);
-+	le16_to_cpus (&u.r.wIndex);
-+	le16_to_cpus (&u.r.wLength);
-+
-+	DBG(DBG_VERBOSE, "SETUP %02x.%02x v%04x i%04x l%04x\n",
-+	    u.r.bRequestType, u.r.bRequest,
-+	    u.r.wValue, u.r.wIndex, u.r.wLength);
-+	
-+	if (u.r.bRequestType & USB_DIR_IN) {
-+		DBG(DBG_VERY_NOISY, "handle_ep0_setup: EP0_IN_DATA_PHASE\n");
-+		dev->ep0state = EP0_IN_DATA_PHASE;
-+	}
-+	else {
-+		DBG(DBG_VERY_NOISY, "handle_ep0_setup: EP0_OUT_DATA_PHASE\n");
-+		dev->ep0state = EP0_OUT_DATA_PHASE;
-+	}
-+	
-+	i = dev->driver->setup(&dev->gadget, &u.r);
-+	if (i < 0) {
-+		DMSG("SETUP %02x.%02x v%04x i%04x l%04x failed\n",
-+		    u.r.bRequestType, u.r.bRequest,
-+		    u.r.wValue, u.r.wIndex, u.r.wLength);
-+		superh_ep_set_halt(&dev->ep[0].ep, 1);
-+	}
-+}
-+
-+/*
-+ * 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.
-+ */
-+static int
-+write_fifo (struct superh_ep *ep, struct superh_request *req)
-+{
-+	unsigned		max;
-+
-+	DBG(DBG_VERY_NOISY, "write_fifo\n");
-+
-+	if ((ep->bEndpointAddress & USB_DIR_IN) != USB_DIR_IN) {
-+		DMSG("write_fifo from invalid EP (%s)\n", ep->ep.name);
-+		return -EINVAL;
-+	}
-+
-+	max = ep->desc->wMaxPacketSize;
-+	do {
-+		unsigned	count;
-+		int		is_last, is_short;
-+
-+		count = write_packet(ep->fifo_reg, 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->ep.maxpacket);
-+
-+			/* FIXME ep.maxpacket should be the current size,
-+			 * modified (for periodic endpoints) when the
-+			 * ep is enabled.  do that, re-init as needed,
-+			 * and change maxpacket refs accordingly.
-+			 */
-+		}
-+
-+		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.
-+		 */
-+		or_b(ep->packet_enable_mask, USBTRG);
-+
-+		/* requests complete when all IN data is in the FIFO */
-+		if (is_last) {
-+			done (ep, req, 0);
-+			if (list_empty(&ep->queue) || unlikely(ep->dma >= 0)) {
-+				pio_irq_disable (ep);
-+			}
-+#ifdef USE_DMA
-+			/* TODO */
-+			if (unlikely(ep->dma >= 0) && !list_empty(&ep->queue)) {
-+				DMSG("%s pio2dma\n", ep->ep.name);
-+				req = list_entry(ep->queue.next,
-+						struct superh_request, queue);
-+				kick_dma(ep,req);
-+				return 0;
-+			}
-+#endif
-+			return 1;
-+		}
-+		/* Only loop if on EP2 as it is double buffered */
-+	} while (ep->bEndpointAddress == (2|USB_DIR_IN)
-+		 && ctrl_inb(USBIFR0) & EP2_EMPTY);
-+	return 0;
-+}
-+
-+/*
-+ * read_ep0_fifo - unload packets from ep0 control-out fifo.  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_ep0_fifo(struct superh_ep *ep, struct superh_request *req)
-+{
-+	u8		*buf;
-+	unsigned	bufferspace, count;
-+
-+	DBG(DBG_VERY_NOISY, "read_ep0_fifo\n");
-+
-+	if (!ep) {
-+		DMSG("read_ep0_fifo invalid ep\n");
-+		return -EINVAL;
-+	}
-+
-+	if (!req) {
-+		DMSG("read_ep0_fifo invalid req\n");
-+		return -EINVAL;
-+	}
-+
-+	if (ep->desc != 0) {
-+		DMSG("read_ep0_fifo from invalid EP (%s)\n", ep->ep.name);
-+		return -EINVAL;
-+	}
-+	
-+	/* make sure there's a packet in the FIFO.
-+	 */
-+	if (likely ((ctrl_inb(USBIFR0) & EP0o_TS) == 0)) {
-+		buf = req->req.buf + req->req.actual;
-+		bufferspace = req->req.length - req->req.actual;
-+	
-+		/* read all bytes from this packet */
-+		count = ctrl_inb(USBEPSZ0O);
-+		req->req.actual += min (count, bufferspace);
-+		DBG(DBG_VERY_NOISY, "read %s %d bytes req %p %d/%d\n",
-+		    ep->ep.name, count,
-+		    req, req->req.actual, req->req.length);
-+		while (likely (count-- != 0)) {
-+			u8	byte = ctrl_inb(USBEPDR0O);
-+			
-+			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--;
-+			}
-+		}
-+		
-+		/* Send ACK */
-+		or_b(EP0o_RDFN, USBTRG);
-+
-+		/* completion */
-+		if (req->req.actual >= req->req.length) {
-+			done (ep, req, 0);
-+			ep0_idle(ep->dev);
-+			return 1;
-+		}
-+	}
-+
-+	return 0;
-+}
-+
-+/*
-+ * 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 superh_ep *ep, struct superh_request *req)
-+{
-+	DBG(DBG_VERY_NOISY, "read_fifo\n");
-+
-+	if ((ep->bEndpointAddress & 0x0f) != 1) {
-+		DMSG("read_fifo from invalid EP (%s)\n", ep->ep.name);
-+		return -EINVAL;
-+	}
-+
-+	for (;;) {
-+		u8		*buf;
-+		unsigned	bufferspace, count, is_short;
-+
-+		/* make sure there's a packet in the FIFO.
-+		 */
-+		if (unlikely ((ctrl_inb(USBIFR0) & EP1_FULL) == 0))
-+			break;
-+		buf = req->req.buf + req->req.actual;
-+		bufferspace = req->req.length - req->req.actual;
-+
-+		/* read all bytes from this packet */
-+		count = ctrl_inb(USBEPSZ1);
-+		req->req.actual += min (count, bufferspace);
-+		is_short = (count < ep->desc->wMaxPacketSize);
-+		DBG(DBG_VERY_NOISY, "read %s %d bytes%s req %p %d/%d\n",
-+			ep->ep.name, count,
-+			is_short ? "/S" : "",
-+			req, req->req.actual, req->req.length);
-+		while (likely (count-- != 0)) {
-+			u8	byte = ctrl_inb(USBEPDR1);
-+
-+			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--;
-+			}
-+		}
-+
-+		or_b(EP1_RDFN, USBTRG);
-+		/* There could now be another packet because of dual buffer */
-+
-+		/* completion */
-+		if (is_short || req->req.actual == req->req.length) {
-+			done (ep, req, 0);
-+			if (list_empty(&ep->queue))
-+				pio_irq_disable (ep);
-+			return 1;
-+		}
-+
-+		/* finished that packet.  the next one may be waiting... */
-+	}
-+	return 0;
-+}
-+
-+/*--------------------------------------------------------------------------*/ 
-+/* Interrupt Handler(s)
-+ */
-+
-+/*
-+ * superh_udc_irq_f0 - high priority interrupt handler
-+ * this deals with data to & from the bulk pipes
-+ */
-+static void superh_udc_irq_f0(int irq, void *_dev, struct pt_regs *regs)
-+{
-+	unsigned char             f0_status;
-+	struct superh_udc         *dev = (struct superh_udc*) _dev;
-+	struct superh_request     *req;
-+	struct superh_ep          *ep;
-+
-+	DBG(DBG_NOISY, "superh_udc_irq_f0 %p\n", dev);
-+
-+	atomic_inc(&dev->in_interrupt);
-+
-+	dev->stats.irqs++;
-+	dev->stats.irq0s++;
-+	f0_status = ctrl_inb(USBIFR0);
-+
-+	/* Acknowledge interrupts */
-+	ctrl_outb(~(f0_status & F0_HIGH), USBIFR0);
-+
-+	if (f0_status & EP1_FULL) {
-+		DBG(DBG_NOISY, "superh_udc_irq_f0 %p: EP1 FULL\n", dev);
-+		ep = &dev->ep[1];
-+		
-+		if (likely (!list_empty(&ep->queue)))
-+			req = list_entry(ep->queue.next,
-+					 struct superh_request, queue);
-+		else
-+			req = 0;
-+
-+		if (req)
-+			read_fifo(ep, req);
-+		else
-+			pio_irq_disable(ep);
-+	}
-+	
-+	if ( f0_status & (EP2_TR | EP2_EMPTY) ) {
-+		DBG(DBG_NOISY, "superh_udc_irq_f0 %p: EP2 TR | EP2_EMPTY\n", dev);
-+		ep = &dev->ep[2];
-+
-+		if (likely (!list_empty(&ep->queue)))
-+			req = list_entry(ep->queue.next,
-+					struct superh_request, queue);
-+		else
-+			req = 0;
-+
-+		if (req) {
-+			if ((f0_status & EP2_TR) && (f0_status & EP2_EMPTY))
-+				write_fifo(ep, req);
-+			else
-+				and_b(~EP2_EMPTY, USBIER0);
-+				
-+		}
-+		else {
-+			pio_irq_disable(ep);
-+		}
-+	}
-+
-+	atomic_dec(&dev->in_interrupt);
-+}
-+
-+/**
-+ * superh_udc_irq_f1 - low priority interrupt handler
-+ *
-+ */
-+static void superh_udc_irq_f1(int irq, void *_dev, struct pt_regs *regs)
-+{
-+	unsigned char       f0_status;
-+	unsigned char       f1_status;
-+	struct superh_udc   *dev = (struct superh_udc*) _dev;
-+
-+	atomic_inc(&dev->in_interrupt);;
-+
-+	dev->stats.irqs++;
-+	dev->stats.irq1s++;
-+
-+	f0_status = ctrl_inb(USBIFR0);
-+	f1_status = ctrl_inb(USBIFR1);
-+
-+	/* Acknowledge interrupts */
-+	ctrl_outb(~(f0_status & F0_LOW), USBIFR0);
-+	ctrl_outb(~(f1_status & F1_LOW), USBIFR1);
-+
-+	/* VBUSF indicates the USB being connected/disconnected */
-+	if (f1_status & VBUSF) {
-+		DBG(DBG_VERY_NOISY, "superh_udc_irq_f1[%lx] VBUSF\n", dev->stats.irqs);
-+		if (!is_usb_connected) {
-+			/* report disconnect just once */
-+			if (dev->gadget.speed != USB_SPEED_UNKNOWN) {
-+				DMSG("disconnect %s\n",
-+					dev->driver ? dev->driver->driver.name : 0);
-+				stop_activity(dev, dev->driver);
-+			}
-+		}
-+		else if (dev->gadget.speed == USB_SPEED_UNKNOWN) {
-+			DMSG("connect\n");
-+			dev->setup_countdown = DEFAULT_SETUP_COUNT;
-+		}
-+	}
-+
-+
-+
-+	/* Bus Reset */
-+	if (f0_status & BRST) {
-+		int i;
-+		DBG(DBG_VERBOSE, "superh_udc_irq_f1[%lx]: BRST bus reset\n", dev->stats.irqs);
-+		/* kill any outstanding requests  */
-+		for (i = 0; i < 4; i++) {
-+			struct superh_ep *ep = &dev->ep[i];
-+			nuke(ep, -ESHUTDOWN);
-+			ep->halted = 0;
-+			ep->stopped = 0;
-+		}
-+
-+		/* reset fifo's and stall's */
-+		ctrl_outb( EP3_CLEAR | EP1_CLEAR | EP2_CLEAR | EP0o_CLEAR | EP0i_CLEAR, USBFCLR );
-+		ctrl_outb( 0, USBEPSTL );
-+		DMSG("gadget driver '%s', address zero\n", dev->driver->driver.name);
-+		if (dev->gadget.speed == USB_SPEED_UNKNOWN)
-+			init_udc_timer(dev);
-+		dev->gadget.speed = USB_SPEED_FULL;
-+		memset(&dev->stats, 0, sizeof dev->stats);
-+		if (dev->setup_countdown < 0)
-+			dev->setup_countdown = RESET_SETUP_COUNT;
-+		dev->reset_time = jiffies;
-+		dev->fake_config = 0;
-+		ep0_idle(dev);
-+	}
-+
-+        /* EPOi Transmit Complete - data to host on EP0 ACKed
-+	 * EP0i Transfer Request - no data in FIFO to send on EP0
-+         * either way we send next data if there is any and the FIFO is not busy
-+	 * it will interrupt again if we later if we don't send anything.
-+	 */
-+	if ((f0_status & EP0i_TR || f0_status & EP0i_TS)
-+	    && (ctrl_inb(USBDASTS) & EP0i_DE) == 0) {
-+		struct superh_ep	*ep = &dev->ep[0];
-+		struct superh_request	*req;
-+		DBG(DBG_VERY_NOISY, "superh_udc_irq_f1[%lx]: ep0i TR\n", dev->stats.irqs);
-+		if (!list_empty(&ep->queue)) {
-+			req = list_entry(ep->queue.next, struct superh_request, queue);
-+			write_ep0_fifo(ep, req);
-+		}
-+		or_b(EP0i_PKTE, USBTRG);
-+	}
-+
-+	/* Setup Command Receive Complete */
-+	if (f0_status & SETUP_TS) {
-+		DBG(DBG_NOISY, "superh_udc_irq_f1[%lx]: SETUP TS\n", dev->stats.irqs);
-+		or_b( EP0o_CLEAR | EP0i_CLEAR, USBFCLR);
-+		handle_ep0_setup(dev);
-+	}
-+
-+	/* EPOo Receive Complete - EP0 has received data from host */
-+	if (f0_status & EP0o_TS) {
-+		struct superh_request     *req;
-+		struct superh_ep          *ep;
-+		DBG(DBG_VERY_NOISY, "superh_int_hndlr_f1[%lx]: ep0o TS\n", dev->stats.irqs);
-+		ep = &dev->ep[0];
-+
-+		if (likely (!list_empty(&ep->queue)))
-+			req = list_entry(ep->queue.next,
-+					 struct superh_request, queue);
-+		else
-+			req = 0;
-+
-+		if (req)
-+			read_ep0_fifo(ep, req);
-+	}
-+
-+	/* EP3 Transmit Request & Transmit Complete */
-+	if ( f1_status & (EP3_TR | EP3_TS) ) {
-+		struct superh_request     *req;
-+		struct superh_ep          *ep;
-+		DBG(DBG_VERY_NOISY, "superh_udc_irq_f1[%lx]: EP3 TR | EP3_TS (%x)\n", dev->stats.irqs, f1_status);
-+		ep = &dev->ep[3];
-+
-+		if (likely (!list_empty(&ep->queue)))
-+			req = list_entry(ep->queue.next,
-+					struct superh_request, queue);
-+		else
-+			req = 0;
-+
-+		if (req) {
-+			if ((f1_status & EP3_TR) && (ctrl_inb(USBDASTS) & EP3_DE) == 0)
-+				write_fifo(ep, req);
-+			
-+		}
-+		else {
-+			pio_irq_disable(ep);
-+		}
-+	}
-+
-+	atomic_dec(&dev->in_interrupt);;
-+}
-+
-+
-+/*--------------------------------------------------------------------------*/ 
-+
-+/*
-+ * endpoint enable/disable
-+ *
-+ * we need to verify the descriptors used to enable endpoints.  since superh
-+ * endpoint configurations are fixed, and are pretty much always enabled,
-+ * there's not a lot to manage here.
-+ *
-+ */
-+static int superh_ep_enable (struct usb_ep *_ep,
-+		const struct usb_endpoint_descriptor *desc)
-+{
-+	struct superh_ep        *ep;
-+	struct superh_udc       *dev;
-+
-+	DBG(DBG_NOISY, "superh_ep_enable\n");
-+
-+	ep = container_of (_ep, struct superh_ep, ep);
-+	if (!_ep || !desc || ep->desc || _ep->name == ep0name
-+			|| desc->bDescriptorType != USB_DT_ENDPOINT
-+			|| ep->bEndpointAddress != desc->bEndpointAddress
-+			|| ep->ep.maxpacket < desc->wMaxPacketSize) {
-+		DMSG("%s, bad ep or descriptor\n", __FUNCTION__);
-+		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", __FUNCTION__, _ep->name);
-+		return -EINVAL;
-+	}
-+
-+#if 0
-+	/* hardware _could_ do smaller, but driver doesn't */
-+	if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK
-+				&& desc->wMaxPacketSize != BULK_FIFO_SIZE)
-+			|| !desc->wMaxPacketSize) {
-+		DMSG("%s, bad %s maxpacket\n", __FUNCTION__, _ep->name);
-+		return -ERANGE;
-+	}
-+#endif
-+
-+	dev = ep->dev;
-+	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
-+		DMSG("%s, bogus device state\n", __FUNCTION__);
-+		return -ESHUTDOWN;
-+	}
-+
-+	ep->desc = desc;
-+	ep->dma = -1;
-+	ep->stopped = 0;
-+
-+	/* flush fifo (mostly for OUT buffers), enable irq */
-+	superh_ep_fifo_flush (_ep);
-+
-+	/* ... reset halt state too, if we could ... */
-+
-+#ifdef	USE_DMA
-+
-+#endif
-+
-+	DBG(DBG_VERBOSE, "enabled %s\n", _ep->name);
-+	return 0;
-+}
-+
-+static int superh_ep_disable (struct usb_ep *_ep)
-+{
-+	struct superh_ep	*ep;
-+
-+	DBG(DBG_NOISY, "superh_ep_disable\n");
-+
-+	ep = container_of (_ep, struct superh_ep, ep);
-+	if (!_ep || !ep->desc) {
-+		DMSG("%s, %s not enabled\n", __FUNCTION__,
-+			_ep ? ep->ep.name : NULL);
-+		return -EINVAL;
-+	}
-+	nuke (ep, -ESHUTDOWN);
-+
-+#ifdef	USE_DMA
-+	/* TODO */
-+	if (ep->dma >= 0) {
-+		*ep->reg_drcmr = 0;
-+		pxa_free_dma (ep->dma);
-+		ep->dma = -1;
-+	}
-+#endif
-+
-+	/* flush fifo (mostly for IN buffers) */
-+	superh_ep_fifo_flush (_ep);
-+
-+	ep->desc = 0;
-+	ep->stopped = 1;
-+
-+	DBG(DBG_VERBOSE, "%s disabled\n", _ep->name);
-+	return 0;
-+}
-+
-+/* for the superh, 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).
-+ */
-+
-+/*
-+ * 	superh_ep_alloc_request - allocate a request data structure
-+ */
-+static struct usb_request *
-+superh_ep_alloc_request (struct usb_ep *_ep, int gfp_flags)
-+{
-+	struct superh_request *req;
-+
-+	/* FIXME for bulk out-dma endpoints, preallocate a frame's worth of
-+	 * (aligned) dma descriptors at the end of the request
-+	 */
-+
-+	req = kmalloc (sizeof *req, gfp_flags);
-+	if (!req)
-+		return 0;
-+
-+	memset (req, 0, sizeof *req);
-+	INIT_LIST_HEAD (&req->queue);
-+	DBG(DBG_VERY_NOISY, "superh_ep_alloc_request: %p %d\n", req, list_empty(&req->queue));
-+
-+	return &req->req;
-+}
-+
-+/*
-+ * 	superh_ep_free_request - deallocate a request data structure
-+ */
-+static void
-+superh_ep_free_request (struct usb_ep *_ep, struct usb_request *_req)
-+{
-+	struct superh_request	*req;
-+
-+	req = container_of (_req, struct superh_request, req);
-+	WARN_ON (!list_empty (&req->queue));
-+	kfree(req);
-+}
-+
-+/* SH cache needs flushing with DMA I/O (it's dma-incoherent), but there's
-+ * no device-affinity and the heap works perfectly well for i/o buffers.
-+ * TODO: check this
-+ */
-+static void *
-+superh_ep_alloc_buffer(struct usb_ep *_ep, unsigned bytes,
-+		       dma_addr_t *dma, int gfp_flags)
-+{
-+	char			*retval;
-+
-+	retval = kmalloc (bytes, gfp_flags);
-+	if (retval)
-+		*dma = virt_to_bus (retval);
-+	return retval;
-+}
-+
-+static void
-+superh_ep_free_buffer(struct usb_ep *_ep, void *buf, dma_addr_t dma,
-+		unsigned bytes)
-+{
-+	kfree (buf);
-+}
-+
-+static struct superh_request*
-+process_ep_req(struct superh_ep *ep, struct superh_request *req)
-+{
-+	struct superh_udc *dev = ep->dev;
-+
-+	if (ep->desc == 0 /* ep0 */) {
-+		switch (dev->ep0state) {
-+		case EP0_IN_DATA_PHASE:
-+			DBG(DBG_VERY_NOISY, "superh_ep_queue: EP0_IN_DATA_PHASE\n");
-+			dev->stats.write.ops++;
-+			if (write_ep0_fifo(ep, req))
-+				req = 0;
-+			break;
-+			
-+		case EP0_OUT_DATA_PHASE:
-+			DBG(DBG_VERY_NOISY, "superh_ep_queue: EP0_OUT_DATA_PHASE\n");
-+			dev->stats.read.ops++;
-+			if (read_ep0_fifo(ep, req))
-+				req = 0;
-+			break;
-+			
-+		default:
-+			DMSG("ep0 i/o, odd state %d\n", dev->ep0state);
-+			return 0;
-+		}
-+#ifdef	USE_DMA
-+		/* either start dma or prime pio pump */
-+	}
-+	else if (ep->dma >= 0) {
-+		kick_dma(ep, req);
-+#endif
-+		/* can the FIFO can satisfy the request immediately? */
-+	}
-+	else if ((ep->bEndpointAddress & USB_DIR_IN) != 0) {
-+		if ((ep->desc->bEndpointAddress & 0x0f) == 2
-+		    && (ctrl_inb(USBIFR0) & EP2_TR) != 0
-+		    && write_fifo(ep, req)) {
-+			req = 0;
-+		}
-+		else if ((ep->desc->bEndpointAddress & 0x0f) == 3
-+		    && (ctrl_inb(USBIFR1) & EP3_TR) != 0
-+		    && write_fifo(ep, req)) {
-+			req = 0;
-+		}
-+	}
-+
-+	if (likely (((req && ep->desc) && ep->dma < 0) || ep->desc == 0))
-+		pio_irq_enable(ep);
-+
-+	return req;
-+} 
-+
-+
-+static int
-+superh_ep_queue(struct usb_ep *_ep, struct usb_request *_req, int gfp_flags)
-+{
-+	struct superh_request	*req;
-+	struct superh_ep	*ep;
-+	struct superh_udc	*dev;
-+	unsigned long		flags;
-+
-+	req = container_of(_req, struct superh_request, req);
-+	ep = container_of(_ep, struct superh_ep, ep);
-+
-+	DBG(DBG_VERY_NOISY, "superh_ep_queue\n");
-+
-+	/* If we have just sent a fake configuration request then
-+	 * this is the reply.  We don't want to send it to the host
-+	 * so just ignore it.
-+	 */
-+	if (ep->desc == 0 /* ep0 */ && ep->dev->fake_config) {
-+		DBG(DBG_NOISY, "Ignoring bogus SET_CONFIGURATION response\n");
-+		done(ep, req, 0);
-+		ep->dev->fake_config = 0;
-+		return 1;
-+	}
-+
-+	if (unlikely (!_req || !_req->complete || !_req->buf
-+		      || !list_empty(&req->queue))) {
-+		DMSG("%s, bad params %s, %p, %p, %p, %d\n", __FUNCTION__,
-+		     ep->ep.name, _req, _req->complete, _req->buf,
-+		     list_empty(&req->queue));
-+		return -EINVAL;
-+	}
-+
-+	if (unlikely (!_ep || (!ep->desc && ep->ep.name != ep0name))) {
-+		DMSG("%s, bad ep\n", __FUNCTION__);
-+		return -EINVAL;
-+	}
-+
-+	dev = ep->dev;
-+	if (unlikely (!dev->driver
-+			|| dev->gadget.speed == USB_SPEED_UNKNOWN)) {
-+		DMSG("%s, bogus device state\n", __FUNCTION__);
-+		return -ESHUTDOWN;
-+	}
-+
-+#ifdef	USE_DMA
-+	/* TODO */
-+	if (ep->dma >= 0) {
-+		unsigned long	start = (unsigned long) _req->buf;
-+
-+		clean_dcache_range(start, start + _req->length);
-+		/* or for USB_DIR_OUT, invalidate_dcache_range (...) */
-+	}
-+#endif
-+
-+	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 && !ep->halted) {
-+		req = process_ep_req(ep, req);
-+	}
-+	
-+	/* pio or dma irq handler advances the queue. */
-+	if (likely (req != 0))
-+		list_add_tail(&req->queue, &ep->queue);
-+
-+	local_irq_restore(flags);
-+
-+	return 0;
-+}
-+
-+static int
-+superh_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
-+{
-+	struct superh_ep	*ep;
-+	struct superh_request	*req;
-+	unsigned long		flags;
-+
-+	DBG(DBG_NOISY, "superh_ep_dequeue %s\n", _ep->name);
-+
-+	ep = container_of(_ep, struct superh_ep, ep);
-+	req = container_of(_req, struct superh_request, req);
-+	if (!_ep || !_req || ep->ep.name == ep0name)
-+		return -EINVAL;
-+
-+	local_irq_save(flags);
-+#ifdef	USE_DMA
-+	if (ep->dma >= 0 && ep->queue.next == &req->queue && !ep->stopped) {
-+		cancel_dma(ep);
-+		done(ep, req, -ECONNRESET);
-+		/* restart i/o */
-+		if (!list_empty(&ep->queue)) {
-+			req = list_entry(ep->queue.next,
-+					struct superh_request, queue);
-+			kick_dma(ep, req);
-+		}
-+	} else
-+#endif
-+	if (!list_empty(&req->queue))
-+		done(ep, req, -ECONNRESET);
-+	else
-+		req = 0;
-+	local_irq_restore(flags);
-+
-+	return req ? 0 : -EOPNOTSUPP;
-+}
-+
-+/* stall/unstall an endpoint, 0 clears the stall, 1 sets it */
-+static int
-+superh_ep_set_halt(struct usb_ep *_ep, int value)
-+{
-+	struct superh_ep	*ep;
-+	unsigned long		flags;
-+
-+	ep = container_of(_ep, struct superh_ep, ep);
-+	if (unlikely (!_ep
-+			|| (!ep->desc && ep->ep.name != ep0name))
-+			|| ep->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
-+		DMSG("%s, bad ep\n", __FUNCTION__);
-+		return -EINVAL;
-+	}
-+
-+	if (ep->halted == value)
-+		return 0;
-+
-+	local_irq_save(flags);
-+
-+	if (value == 1 && (ep->bEndpointAddress & USB_DIR_IN) != 0
-+	    && ((ctrl_inb(USBDASTS) & ep->data_present_mask) != 0
-+		|| !list_empty(&ep->queue))) {
-+		local_irq_restore(flags);
-+		DBG(DBG_VERBOSE, "Can't %s on %s\n", value ? " halt" : "clear halt", _ep->name);
-+		return -EAGAIN;
-+	}
-+
-+	if (value) {
-+		or_b(ep->stall_mask, USBEPSTL);
-+		if (!ep->desc) {
-+			ep->dev->ep0state = EP0_STALL;
-+		}
-+		/* disable ep interrupts and set a timer to clear the stall */
-+		pio_irq_disable(ep);
-+		mod_timer(&ep->dev->timer, jiffies + STALL_TIME);
-+	}
-+	else {
-+		and_b(~ep->stall_mask, USBEPSTL);
-+	}
-+
-+	ep->halted = value;
-+
-+	local_irq_restore(flags);
-+
-+	DBG(DBG_VERBOSE, "%s %s\n", _ep->name, value ? " halt" : "clear halt");
-+
-+	return 0;
-+}
-+
-+static int superh_ep_fifo_status(struct usb_ep *_ep)
-+{
-+	struct superh_ep        *ep;
-+
-+	DBG(DBG_NOISY, "superh_ep_fifo_status\n");
-+
-+	ep = container_of(_ep, struct superh_ep, ep);
-+	if (!_ep) {
-+		DMSG("%s, bad ep\n", __FUNCTION__);
-+		return -ENODEV;
-+	}
-+	if ((ep->bEndpointAddress & USB_DIR_IN) != 0)
-+		return -EOPNOTSUPP;
-+	if (ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
-+		return 0;
-+	else {
-+		switch (ep->desc->bEndpointAddress & 0x0f) {
-+		case 0:
-+			return ctrl_inb(USBEPSZ0O);
-+		case 1:
-+			return ctrl_inb(USBEPSZ1);
-+		}
-+	}
-+	
-+	return 0;
-+}
-+
-+static void superh_ep_fifo_flush(struct usb_ep *_ep)
-+{
-+	struct superh_ep        *ep;
-+
-+	DBG(DBG_NOISY, "superh_ep_fifo_flush\n");
-+
-+	ep = container_of(_ep, struct superh_ep, ep);
-+	if (!_ep || ep->ep.name == ep0name || !list_empty(&ep->queue)) {
-+		DMSG("%s, bad ep\n", __FUNCTION__);
-+		return;
-+	}
-+
-+	or_b(ep->clear_mask, USBFCLR);
-+}
-+
-+static struct usb_ep_ops superh_ep_ops = {
-+	.enable		= superh_ep_enable,
-+	.disable	= superh_ep_disable,
-+
-+	.alloc_request	= superh_ep_alloc_request,
-+	.free_request	= superh_ep_free_request,
-+
-+	.alloc_buffer	= superh_ep_alloc_buffer,
-+	.free_buffer	= superh_ep_free_buffer,
-+
-+	.queue		= superh_ep_queue,
-+	.dequeue	= superh_ep_dequeue,
-+
-+	.set_halt	= superh_ep_set_halt,
-+	.fifo_status	= superh_ep_fifo_status,
-+	.fifo_flush	= superh_ep_fifo_flush,
-+};
-+
-+/* ---------------------------------------------------------------------------
-+ * 	device-scoped parts of the api to the usb controller hardware
-+ * ---------------------------------------------------------------------------
-+ */
-+
-+static int superh_udc_get_frame(struct usb_gadget *_gadget)
-+{
-+	DBG(DBG_VERY_NOISY, "superh_udc_get_frame\n");
-+
-+	return -EOPNOTSUPP;
-+}
-+
-+static const struct usb_gadget_ops superh_udc_ops = {
-+	.get_frame	 = superh_udc_get_frame,
-+	// no remote wakeup
-+	// always selfpowered
-+};
-+
-+
-+/* if we're trying to save space, don't bother with this proc file */
-+
-+#if defined(CONFIG_PROC_FS) && !defined(CONFIG_EMBEDDED)
-+#  define	UDC_PROC_FILE
-+#endif
-+
-+#ifdef UDC_PROC_FILE
-+
-+static const char proc_node_name [] = "driver/udc";
-+
-+static int
-+udc_proc_read(char *page, char **start, off_t off, int count,
-+		int *eof, void *_dev)
-+{
-+	char			*buf = page;
-+	struct superh_udc	*dev = _dev;
-+	char			*next = buf;
-+	unsigned		size = count;
-+	unsigned long		flags;
-+	int			t;
-+	int			i;
-+
-+	local_irq_save(flags);
-+
-+	/* basic device status */
-+	t = snprintf(next, size,
-+		"%s\n%s version: %s\nGadget driver: %s\nHost %s\n\n",
-+		driver_desc,
-+		driver_name, DRIVER_VERSION,
-+		dev->driver ? dev->driver->driver.name : "(none)",
-+		is_usb_connected ? "full speed" : "disconnected");
-+	size -= t;
-+	next += t;
-+
-+	/* device registers */
-+	t = snprintf(next, size,
-+		     "ifr0 %02X, ifr1 %02X, isr0 %02X, isr1 %02X, ier0 %02X, ier1 %02X\n",
-+		     ctrl_inb(USBIFR0), ctrl_inb(USBIFR1),
-+		     ctrl_inb(USBISR0), ctrl_inb(USBISR1),
-+		     ctrl_inb(USBIER0), ctrl_inb(USBIER1));
-+	size -= t;
-+	next += t;
-+
-+	t = snprintf(next, size,
-+		     "epsz0o %02X, epsz1 %02X, dasts %02X, dmar %02X\n",
-+		     ctrl_inb(USBEPSZ0O), ctrl_inb(USBEPSZ1),
-+		     ctrl_inb(USBDASTS), ctrl_inb(USBDMA));
-+	size -= t;
-+	next += t;
-+
-+	t = snprintf(next, size,
-+		     "epstl %02X, xvercr %02X\n",
-+		     ctrl_inb(USBEPSTL), ctrl_inb(USBXVERCR));
-+	size -= t;
-+	next += t;
-+
-+	if (!is_usb_connected || !dev->driver)
-+		goto done;
-+
-+	t = snprintf(next, size, "ep0 IN %lu/%lu, OUT %lu/%lu; irq0s %lu; irq1s %lu\n\n",
-+		dev->stats.write.bytes, dev->stats.write.ops,
-+		dev->stats.read.bytes, dev->stats.read.ops,
-+		dev->stats.irq0s, dev->stats.irq1s);
-+	size -= t;
-+	next += t;
-+
-+	/* dump endpoint queues */
-+	for (i = 0; i < 4; i++) {
-+		struct superh_ep	*ep = &dev->ep [i];
-+		struct superh_request	*req;
-+		int			t;
-+
-+		if (i != 0) {
-+			const struct usb_endpoint_descriptor	*d;
-+
-+			d = ep->desc;
-+			if (!d)
-+				continue;
-+			t = snprintf(next, size,
-+				"%s max %d %s\n",
-+				ep->ep.name, le16_to_cpu (d->wMaxPacketSize),
-+				(ep->dma >= 0) ? "dma" : "pio");
-+
-+		} else /* ep0 should only have one transfer queued */
-+			t = snprintf(next, size, "ep0 max 8 pio\n");
-+		if (t <= 0 || t > size)
-+			goto done;
-+		size -= t;
-+		next += t;
-+
-+		if (list_empty(&ep->queue)) {
-+			t = snprintf(next, size, "\t(nothing queued)\n");
-+			if (t <= 0 || t > size)
-+				goto done;
-+			size -= t;
-+			next += t;
-+			continue;
-+		}
-+		list_for_each_entry(req, &ep->queue, queue) {
-+#ifdef	USE_DMA
-+			if (ep->dma >= 0 && req->queue.prev == &ep->queue)
-+				t = snprintf(next, size,
-+					"\treq %p len %d/%d "
-+					"buf %p (dma%d dcmd %08x)\n",
-+					&req->req, req->req.actual,
-+					req->req.length, req->req.buf,
-+					ep->dma, DCMD(ep->dma)
-+					// low 13 bits == bytes-to-go
-+					);
-+			else
-+#endif
-+				t = snprintf(next, size,
-+					"\treq %p len %d/%d buf %p\n",
-+					&req->req, req->req.actual,
-+					req->req.length, req->req.buf);
-+			if (t <= 0 || t > size)
-+				goto done;
-+			size -= t;
-+			next += t;
-+		}
-+	}
-+
-+done:
-+	local_irq_restore(flags);
-+	return count - size;
-+}
-+
-+#endif	/* UDC_PROC_FILE */
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ * 	udc_disable - disable USB device controller
-+ */
-+static void udc_disable(struct superh_udc *dev)
-+{
-+	/* block all irqs */
-+	ctrl_outb( 0, USBIER0);
-+	ctrl_outb( 0, USBIER1);
-+
-+	/* Disable the USB module */
-+	or_b(0x80, STBCR3);
-+	
-+	/* Disable the USB clock */
-+	ctrl_outw(0xA500, UCLKCR);
-+
-+	ep0_idle (dev);
-+	dev->gadget.speed = USB_SPEED_UNKNOWN;
-+}
-+
-+/*
-+ * 	udc_reinit - initialize software state
-+ */
-+static void udc_reinit(struct superh_udc *dev)
-+{
-+	u32	i;
-+
-+	/* device/ep0 records init */
-+	INIT_LIST_HEAD (&dev->gadget.ep_list);
-+	dev->gadget.ep0 = &dev->ep[0].ep;
-+	INIT_LIST_HEAD (&dev->gadget.ep0->ep_list);
-+	dev->ep0state = EP0_IDLE;
-+
-+	/* basic endpoint records init */
-+	for (i = 0; i < 4; i++) {
-+		struct superh_ep *ep = &dev->ep[i];
-+
-+		ep->ep.name = ep_name[i];
-+		ep->ep.ops = &superh_ep_ops;
-+		if (i != 0)
-+			list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
-+
-+		ep->dev = dev;
-+		ep->desc = 0;
-+		ep->stopped = 0;
-+		ep->halted = 0;
-+		ep->dma = -1;
-+		INIT_LIST_HEAD (&ep->queue);
-+
-+		/* address may need USB_DIR_IN, attributes likely wrong */
-+		ep->bEndpointAddress = i;
-+		ep->bmAttributes = USB_ENDPOINT_XFER_BULK;
-+	}
-+
-+	/* TODO at least from here on, static initialization
-+	 * would work just as well and would need less code space
-+	 */
-+
-+	/* ep0 == control */
-+	dev->ep[ 0].ep.maxpacket   = EP0_FIFO_SIZE;
-+	dev->ep[ 0].data_present_mask = EP0i_DE;
-+	dev->ep[ 0].stall_mask = EP0_STL;
-+	dev->ep[ 0].interrupt_mask = EP0o_TS | EP0i_TR | EP0i_TS;
-+	dev->ep[ 0].interrupt_reg = USBIER0;
-+	dev->ep[ 0].clear_mask = EP0i_CLEAR | EP0o_CLEAR;
-+	dev->ep[ 0].fifo_reg = 0;
-+	dev->ep[ 0].packet_enable_mask = 0;
-+
-+	dev->ep[ 1].ep.maxpacket   = BULK_FIFO_SIZE;
-+	dev->ep[ 1].bEndpointAddress |= USB_DIR_OUT;
-+	dev->ep[ 1].data_present_mask = 0x00;
-+	dev->ep[ 1].stall_mask = EP1_STL;
-+	dev->ep[ 1].interrupt_mask = EP1_FULL;
-+	dev->ep[ 1].interrupt_reg = USBIER0;
-+	dev->ep[ 1].clear_mask = EP1_CLEAR;
-+	dev->ep[ 1].fifo_reg = 0;
-+	dev->ep[ 1].packet_enable_mask = 0;
-+
-+	dev->ep[ 2].ep.maxpacket   = BULK_FIFO_SIZE;
-+	dev->ep[ 2].bEndpointAddress |= USB_DIR_IN;
-+	dev->ep[ 2].data_present_mask = EP2_DE;
-+	dev->ep[ 2].stall_mask = EP2_STL;
-+	dev->ep[ 2].interrupt_mask = EP2_TR | EP2_EMPTY;
-+	dev->ep[ 2].interrupt_reg = USBIER0;
-+	dev->ep[ 2].clear_mask = EP2_CLEAR;
-+	dev->ep[ 2].fifo_reg = USBEPDR2;
-+	dev->ep[ 2].packet_enable_mask = EP2_PKTE;
-+
-+	dev->ep[ 3].ep.maxpacket   = INT_FIFO_SIZE;
-+	dev->ep[ 3].bEndpointAddress |= USB_DIR_IN;
-+	dev->ep[ 3].data_present_mask = EP3_DE;
-+	dev->ep[ 3].stall_mask = EP3_STL;
-+	dev->ep[ 3].interrupt_mask = EP3_TR | EP3_TS;
-+	dev->ep[ 3].interrupt_reg = USBIER1;
-+	dev->ep[ 3].clear_mask = EP3_CLEAR;
-+	dev->ep[ 3].fifo_reg = USBEPDR3;
-+	dev->ep[ 3].packet_enable_mask = EP3_PKTE;
-+}
-+
-+/* until it's enabled, this UDC should be completely invisible
-+ * to any USB host.
-+ */
-+static void udc_enable (struct superh_udc *dev)
-+{
-+#if defined(CONFIG_CPU_SUBTYPE_SH7727)
-+	// Reset and then Select Function USB1_pwr_en out (USB) c.f. Section 26, Table 26.1 PTE2
-+	and_w(PN_PB2_MSK, PECR);
-+	or_w(PN_PB2_OF, PECR);
-+
-+	// Reset and then Select Function UCLK c.f. Section 26, Table 26.1, PTD6
-+	and_w(PN_PB6_MSK, PDCR);
-+	or_w(PN_PB6_OF, PDCR);
-+
-+	// Stop USB module prior to setting clocks c.f. Section 9.2.3
-+	and_b(~MSTP14, STBCR3);
-+	or_b(MSTP14, STBCR3);
-+
-+	// Select external clock, 1/1 divisor c.f. Section 11.3.1
-+	or_b(USBDIV_11|USBCKS_EC, EXCPGCR);
-+
-+	// Start USB c.f. Section 9.2.3
-+	and_b(~MSTP14, STBCR3);
-+
-+	// Disable pullup c.f. Section 23.5.19
-+	or_b(PULLUP_E, USBDMA);
-+	//and_b(~PULLUP_E, USBDMA);
-+
-+	// Set port 1 to function, disabled c.f. Section 22.2.1
-+	or_w(USB_TRANS_TRAN | USB_SEL_FUNC, EXPFC);
-+
-+	// Enable pullup c.f. Section 23.5.19a
-+	and_b(~PULLUP_E, USBDMA);
-+	//or_b(PULLUP_E, USBDMA);
-+#elif defined(CONFIG_CPU_SUBTYPE_SH7705)
-+	/* Disable the USB module */
-+	or_b(0x80, STBCR3);
-+	
-+	/* Set the clock to external & enable */
-+	ctrl_outw(0xA5E0, UCLKCR);
-+
-+	/* Enable the USB module */
-+	and_b(0x7f, STBCR3);
-+
-+	/* Enable USB pins. */
-+	ctrl_outw(0x01FD, PMCR);	/* VBUS */
-+	or_b(PULLUP_E, PMDR);
-+#endif
-+	dev->gadget.speed = USB_SPEED_UNKNOWN;
-+	dev->stats.irqs = 0;
-+	dev->stats.irq0s = 0;
-+	dev->stats.irq1s = 0;
-+
-+	// reset fifo's and stall's
-+	or_b( EP3_CLEAR | EP1_CLEAR | EP2_CLEAR | EP0o_CLEAR | EP0i_CLEAR, USBFCLR);
-+	or_b(0, USBEPSTL);
-+
-+	/* Setup interrupt priority by using the interrupt select registers */
-+	ctrl_outb(F0_LOW, USBISR0);
-+	ctrl_outb(F1_LOW, USBISR1);
-+
-+	/* Enable some interrupts */
-+	or_b( BRST | SETUP_TS | EP0o_TS | EP0i_TR | EP0i_TS, USBIER0);
-+	or_b( VBUSF, USBIER1);
-+}
-+
-+/* 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 superh_udc	*dev = the_controller;
-+	int			retval;
-+
-+	if (!driver
-+	    /*|| driver->speed != USB_SPEED_FULL
-+			|| !driver->bind
-+			|| !driver->unbind
-+			|| !driver->disconnect
-+			|| !driver->setup*/)
-+		return -EINVAL;
-+	if (!dev)
-+		return -ENODEV;
-+	if (dev->driver)
-+		return -EBUSY;
-+
-+	/* first hook up the driver ... */
-+	dev->driver = driver;
-+
-+	retval = driver->bind(&dev->gadget);
-+	if (retval) {
-+		DMSG("bind to driver %s --> error %d\n",
-+				driver->driver.name, retval);
-+		dev->driver = 0;
-+		return retval;
-+	}
-+
-+	/* ... then enable host detection and ep0; and we're ready
-+	 * for set_configuration as well as eventual disconnect.
-+	 * NOTE:  this shouldn't power up until later.
-+	 */
-+	udc_enable(dev);
-+
-+	DMSG("registered gadget driver '%s'\n", driver->driver.name);
-+	dump_state(dev);
-+	return 0;
-+}
-+
-+EXPORT_SYMBOL(usb_gadget_register_driver);
-+
-+static void
-+stop_activity(struct superh_udc *dev, struct usb_gadget_driver *driver)
-+{
-+	int i;
-+
-+	/* don't disconnect drivers more than once */
-+	if (dev->gadget.speed == USB_SPEED_UNKNOWN)
-+		driver = 0;
-+	dev->gadget.speed = USB_SPEED_UNKNOWN;
-+
-+	/* prevent new request submissions, kill any outstanding requests  */
-+	for (i = 0; i < 4; i++) {
-+		struct superh_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 superh_udc	*dev = the_controller;
-+
-+	if (!dev)
-+		return -ENODEV;
-+	if (!driver || driver != dev->driver)
-+		return -EINVAL;
-+
-+	local_irq_disable();
-+	udc_disable(dev);
-+	stop_activity(dev, driver);
-+	driver->unbind(&dev->gadget);
-+	dev->driver = 0;
-+	local_irq_enable();
-+
-+	DMSG("unregistered gadget driver '%s'\n", driver->driver.name);
-+	dump_state(dev);
-+	return 0;
-+}
-+
-+EXPORT_SYMBOL(usb_gadget_unregister_driver);
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,40)
-+MODULE_DESCRIPTION(driver_desc);
-+#endif
-+MODULE_AUTHOR("Julian Back");
-+MODULE_LICENSE("GPL");
-+
-+/*
-+ *	cleanup - free resources allocated during init
-+ */
-+static void /*__exit and */ __init cleanup(void)
-+{
-+	struct superh_udc *dev = the_controller;
-+
-+	if (!dev)
-+		return;
-+
-+	udc_disable(dev);
-+#ifdef	UDC_PROC_FILE
-+	remove_proc_entry(proc_node_name, NULL);
-+#endif
-+	usb_gadget_unregister_driver(dev->driver);
-+
-+	if (dev->got_irq0) {
-+		free_irq(USBF0_IRQ, dev);
-+		dev->got_irq0 = 0;
-+	}
-+
-+	if (dev->got_irq1) {
-+		free_irq(USBF1_IRQ, dev);
-+		dev->got_irq1 = 0;
-+	}
-+
-+	the_controller = 0;
-+}
-+module_exit (cleanup);
-+
-+/*
-+ * 	init - allocate resources
-+ */
-+static int __init init(void)
-+{
-+	static struct superh_udc memory;
-+
-+	struct superh_udc *dev;
-+	int retval;
-+
-+	printk(KERN_DEBUG "%s: version %s\n", driver_name, DRIVER_VERSION);
-+
-+	/* initialize data */
-+	dev = &memory;
-+
-+	memset(dev, 0, sizeof *dev);
-+	dev->gadget.ops = &superh_udc_ops;
-+	dev->gadget.name = driver_name;
-+	dev->gadget.dev.bus_id = "udc";
-+	dev->gadget.speed = USB_SPEED_UNKNOWN;
-+
-+	dev->vbusmn = 0;
-+
-+	atomic_set(&dev->in_interrupt, 0);
-+
-+	the_controller = dev;
-+	udc_disable(dev);
-+	udc_reinit(dev);
-+
-+	/* irq setup after old hardware state is cleaned up */
-+	retval = request_irq(USBF0_IRQ, superh_udc_irq_f0,
-+			     0/*SA_INTERRUPT | SA_SAMPLE_RANDOM*/,
-+			     driver_name, dev);
-+	if (retval != 0) {
-+		printk(KERN_ERR "%s: can't get irq %i, err %d\n",
-+		       driver_name, USBF0_IRQ, retval);
-+		goto failed;
-+	}
-+	dev->got_irq0 = 1;
-+
-+	retval = request_irq(USBF1_IRQ, superh_udc_irq_f1,
-+			     0/*SA_INTERRUPT | SA_SAMPLE_RANDOM*/,
-+			     driver_name, dev);
-+	if (retval != 0) {
-+		printk(KERN_ERR "%s: can't get irq %i, err %d\n",
-+		       driver_name, USBF1_IRQ, retval);
-+		goto failed;
-+	}
-+	dev->got_irq1 = 1;
-+
-+	printk(KERN_INFO "%s, IRQs %d %d\n", driver_desc,
-+	       USBF0_IRQ, USBF1_IRQ);
-+	dump_state(dev);
-+
-+	dev->setup_countdown = DEFAULT_SETUP_COUNT;
-+
-+#ifdef	UDC_PROC_FILE
-+	create_proc_read_entry(proc_node_name, 0, NULL, udc_proc_read, dev);
-+#endif
-+
-+	return 0;
-+
-+failed:
-+	cleanup();
-+	return retval;
-+}
-+module_init (init);
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/superh_udc.h kernel/drivers/usb/gadget/superh_udc.h
---- /tmp/kernel/drivers/usb/gadget/superh_udc.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/superh_udc.h	2005-04-22 17:53:19.513526654 +0200
-@@ -0,0 +1,363 @@
-+/*
-+ * Renesas SuperH USB 1.1 device controller (found on SH7705, SH7727...)
-+ *
-+ * Copyright (C) 2003 Renesas Technology Europe Limited
-+ * Copyright (C) 2003 Julian Back (jback@mpc-data.co.uk), MPC Data Limited
-+ *
-+ * 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_SUPERH_UDC_H
-+#define __LINUX_USB_GADGET_SUPERH_UDC_H
-+
-+#include <linux/types.h>
-+
-+struct superh_udc;
-+
-+struct superh_ep {
-+	struct usb_ep				ep;
-+	struct superh_udc			*dev;
-+
-+	const struct usb_endpoint_descriptor	*desc;
-+	struct list_head			queue;
-+	int					dma; 
-+
-+	u8					bEndpointAddress;
-+	u8					bmAttributes;
-+
-+	unsigned				stopped : 1;
-+	unsigned                                halted : 1;
-+
-+	u8                                      data_present_mask;
-+	u8                                      stall_mask;
-+	u8                                      interrupt_mask;
-+	u8                                      clear_mask;
-+	u8                                      packet_enable_mask;
-+	unsigned                                interrupt_reg;
-+	unsigned                                fifo_reg;
-+};
-+
-+struct superh_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)8)
-+#define BULK_FIFO_SIZE	((unsigned)64)
-+#define ISO_FIFO_SIZE	((unsigned)0)
-+#define INT_FIFO_SIZE	((unsigned)8)
-+
-+struct udc_stats {
-+	struct ep0stats {
-+		unsigned long		ops;
-+		unsigned long		bytes;
-+	} read, write;
-+	unsigned long			irqs;
-+	unsigned long                   irq0s;
-+	unsigned long                   irq1s;
-+};
-+
-+struct superh_udc {
-+	struct usb_gadget			gadget;
-+	struct usb_gadget_driver		*driver;
-+	atomic_t		                in_interrupt;
-+
-+	enum ep0_state				ep0state;
-+	struct udc_stats			stats;
-+	unsigned int                            vbusmn;
-+	unsigned long                           vbusf_time;
-+	unsigned				got_irq0 : 1,
-+  	                                        got_irq1 : 1,
-+						fake_config: 1;
-+	int                                     setup_countdown;
-+	unsigned long                           reset_time;
-+	struct timer_list			timer;
-+	struct superh_ep			ep [4];
-+};
-+
-+/* 2.5 changes ... */
-+
-+#ifndef container_of
-+#define container_of    list_entry
-+#endif
-+
-+#ifndef WARN_ON
-+#define WARN_ON BUG_ON
-+#endif
-+
-+/* one I/O pin should be used to detect disconnect */
-+#define is_usb_connected        ((ctrl_inb(USBIFR1) & VBUSF) != 0)
-+
-+/* Register addresses - should really be in include/asm-sh */
-+
-+#ifdef CONFIG_CPU_SUBTYPE_SH7705
-+
-+#define USBEPDR0I     0xA4480000
-+#define USBEPDR0O     0xA4480004
-+#define USBEPDR0S     0xA4480008
-+#define USBEPDR1      0xA448000C
-+#define USBEPDR2      0xA4480010
-+#define USBEPDR3      0xA4480014
-+#define USBIFR0       0xA4480018
-+#define USBIFR1       0xA448001C
-+#define USBTRG        0xA4480020
-+#define USBFCLR       0xA4480024
-+#define USBEPSZ0O     0xA4480028
-+#define USBDASTS      0xA448002C
-+#define USBEPSTL      0xA4480030
-+#define USBIER0       0xA4480034
-+#define USBIER1       0xA4480038
-+#define USBEPSZ1      0xA448003C
-+#define USBDMA        0xA4480040
-+#define USBISR0       0xA4480044
-+#define USBISR1       0xA4480048
-+
-+#define USBXVERCR     0xA4480060
-+
-+#define STBCR3        0xA40A0000
-+#define UCLKCR        0xA40A0008
-+
-+#define PMCR          0xA4000118
-+#define PNCR          0xA400011A
-+#define PNCR2         0xA405015A
-+
-+#define PMDR          0xA4000138
-+
-+#endif
-+
-+/*
-+ * Standby Control Register (STBCR3) c.f. 9.2.3
-+ */
-+
-+#define MSTP14          0x10
-+
-+/* 
-+ * EXCPG Control Register (EXCPGCR) c.f. Section 11.3.1
-+ */
-+
-+#define USBDIVS_EL0	0x00
-+#define USBDIVS_EL1	0x01
-+#define USBDIVS_EL2	0x02
-+
-+#define	USBCKS_EL1	0x04
-+#define	USBCKS_EL2	0x10
-+#define	USBCKS_EL3	0x20
-+
-+#define USBDIV_11	0x00
-+#define USBDIV_12	0x01
-+#define USBDIV_13	0x02
-+
-+#define	USBCKS_PC	0x00
-+#define	USBCKS_IC	0x20
-+#define	USBCKS_BC	0x24
-+#define	USBCKS_EC	0x30
-+
-+
-+/*
-+ * Extra Pin Function Controller (EXPFC) c.f. Section 22.2.1
-+ */
-+
-+#define	USB_TRANS_TRAN	0x00
-+#define	USB_TRANS_DIG	0x02
-+
-+#define	USB_SEL_HOST	0x00
-+#define	USB_SEL_FUNC	0x01
-+
-+
-+/*
-+ * USBDMA Setting Register (USBDMAR) c.f. Section 23.5.19
-+ */
-+
-+#define EP1_DMAE        0x01
-+#define EP2_DMAE        0x02
-+
-+#if defined(CONFIG_CPU_SUBTYPE_SH7727)
-+#define PULLUP_E        0x04
-+#endif
-+
-+#if defined(CONFIG_SH_EDOSK7705)
-+#define PULLUP_E        0x01
-+#endif
-+
-+/*
-+ * USB Interrupt Flag Register 0 (USBIFR0) c.f. Section 23.5.7
-+ */
-+
-+#define BRST            0x80
-+#define EP1_FULL        0x40
-+#define EP2_TR          0x20
-+#define EP2_EMPTY       0x10
-+#define SETUP_TS        0x08
-+#define EP0o_TS         0x04
-+#define EP0i_TR         0x02
-+#define EP0i_TS         0x01
-+
-+
-+/*
-+ * USB Interrupt Flag Register 1 (USBIFR1) c.f. Section 23.5.8
-+ */
-+
-+#define VBUSMN          0x08
-+#define EP3_TR          0x04
-+#define EP3_TS          0x02
-+#define VBUSF           0x01
-+
-+/*
-+ * USB Trigger Register (USBTRG) c.f. Section 23.5.9
-+ */
-+
-+#define EP0i_PKTE       0x01
-+#define EP0o_PKTE       0x02
-+#define EP0o_RDFN       0x02
-+#define EP0s_PKTE       0x04
-+#define EP0s_RDFN       0x04
-+
-+#define EP2_PKTE        0x10
-+#define EP1_PKTE        0x20
-+#define EP1_RDFN        0x20
-+#define EP3_PKTE        0x40
-+
-+
-+/*
-+ * USBFIFO Clear Register (USBFCLR) c.f. Section 23.5.10
-+ */
-+
-+#define EP3_CLEAR       0x40
-+#define EP1_CLEAR       0x20
-+#define EP2_CLEAR       0x10
-+#define EP0o_CLEAR      0x02
-+#define EP0i_CLEAR      0x01
-+
-+
-+/*
-+ * USBEPSTL Endpoint Stall Register
-+ */
-+#define EP3_STL      0x08
-+#define EP2_STL      0x04
-+#define EP1_STL      0x02
-+#define EP0_STL      0x01
-+
-+/*
-+ * USBDASTS Data Status Register
-+ */
-+#define EP3_DE       0x20
-+#define EP2_DE       0x10
-+#define EP0i_DE      0x01
-+
-+/*
-+ * Port Control Registers (PNCR) c.f. Section 26.2
-+ */
-+#define PN_PB0_OF       0x0000
-+#define PN_PB0_PO       0x0001
-+#define PN_PB0_PI_ON    0x0002
-+#define PN_PB0_PI_OFF   0x0003
-+#define PN_PB0_MSK     ~0x0003
-+
-+#define PN_PB1_OF       0x0000
-+#define PN_PB1_PO       0x0004
-+#define PN_PB1_PI_ON    0x0008
-+#define PN_PB1_PI_OFF   0x000c
-+#define PN_PB1_MSK     ~0x000c
-+
-+#define PN_PB2_OF       0x0000
-+#define PN_PB2_PO       0x0010
-+#define PN_PB2_PI_ON    0x0020
-+#define PN_PB2_PI_OFF   0x0030
-+#define PN_PB2_MSK     ~0x0030
-+
-+#define PN_PB3_OF       0x0000
-+#define PN_PB3_PO       0x0040
-+#define PN_PB3_PI_ON    0x0080
-+#define PN_PB3_PI_OFF   0x00c0
-+#define PN_PB3_MSK     ~0x00c0
-+
-+#define PN_PB4_OF       0x0000
-+#define PN_PB4_PO       0x0100
-+#define PN_PB4_PI_ON    0x0200
-+#define PN_PB4_PI_OFF   0x0300
-+#define PN_PB4_MSK     ~0x0300
-+
-+#define PN_PB5_OF       0x0000
-+#define PN_PB5_PO       0x0400
-+#define PN_PB5_PI_ON    0x0800
-+#define PN_PB5_PI_OFF   0x0c00
-+#define PN_PB5_MSK     ~0x0c00
-+
-+#define PN_PB6_OF       0x0000
-+#define PN_PB6_PO       0x1000
-+#define PN_PB6_PI_ON    0x2000
-+#define PN_PB6_PI_OFF   0x3000
-+#define PN_PB6_MSK     ~0x3000
-+
-+#define PN_PB7_OF       0x0000
-+#define PN_PB7_PO       0x4000
-+#define PN_PB7_PI_ON    0x8000
-+#define PN_PB7_PI_OFF   0xc000
-+#define PN_PB7_MSK     ~0xc000
-+
-+/*
-+ * 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 */
-+
-+#ifdef DEBUG
-+
-+#define DMSG(stuff...) printk(KERN_DEBUG "udc: " stuff)
-+
-+#if defined(VERY_NOISY)
-+#    define UDC_DEBUG DBG_VERY_NOISY
-+#elif defined(NOISY)
-+#    define UDC_DEBUG DBG_NOISY
-+#elif defined(VERBOSE)
-+#    define UDC_DEBUG DBG_VERBOSE
-+#else
-+#    define UDC_DEBUG DBG_NORMAL
-+#endif
-+
-+static void __attribute__ ((__unused__))
-+dump_state(struct superh_udc *dev)
-+{
-+	if (!is_usb_connected)
-+		return;
-+}
-+
-+
-+#else
-+
-+#define DMSG(stuff...)		do{}while(0)
-+
-+#define UDC_DEBUG ((unsigned)0)
-+
-+#define	dump_state(x)	do{}while(0)
-+
-+#endif
-+
-+#define DBG(lvl, stuff...) do{if ((lvl) <= UDC_DEBUG) DMSG(stuff);}while(0)
-+
-+#define WARN(stuff...) printk(KERN_WARNING "udc: " stuff)
-+
-+#endif /* __LINUX_USB_GADGET_SUPERH_UDC_H */
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/usbstring.c kernel/drivers/usb/gadget/usbstring.c
---- /tmp/kernel/drivers/usb/gadget/usbstring.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/usbstring.c	2005-04-22 17:53:19.516526166 +0200
-@@ -0,0 +1,136 @@
-+/*
-+ * Copyright (C) 2003 David Brownell
-+ *
-+ * This program is free software; you can redistribute it and/or modify
-+ * it under the terms of the GNU Lesser General Public License as published
-+ * by the Free Software Foundation; either version 2.1 of the License, or
-+ * (at your option) any later version.
-+ */
-+
-+#include <linux/errno.h>
-+#include <linux/kernel.h>
-+#include <linux/list.h>
-+#include <linux/string.h>
-+#include <linux/init.h>
-+
-+#include <linux/usb_ch9.h>
-+#include <linux/usb_gadget.h>
-+
-+#include <asm/byteorder.h>
-+#include <asm/unaligned.h>
-+
-+
-+static int utf8_to_utf16le(const char *s, u16 *cp, unsigned len)
-+{
-+	int	count = 0;
-+	u8	c;
-+	u16	uchar;
-+
-+	/* this insists on correct encodings, though not minimal ones.
-+	 * BUT it currently rejects legit 4-byte UTF-8 code points,
-+	 * which need surrogate pairs.  (Unicode 3.1 can use them.)
-+	 */
-+	while (len != 0 && (c = (u8) *s++) != 0) {
-+		if (unlikely(c & 0x80)) {
-+			// 2-byte sequence:
-+			// 00000yyyyyxxxxxx = 110yyyyy 10xxxxxx
-+			if ((c & 0xe0) == 0xc0) {
-+				uchar = (c & 0x1f) << 6;
-+
-+				c = (u8) *s++;
-+				if ((c & 0xc0) != 0xc0)
-+					goto fail;
-+				c &= 0x3f;
-+				uchar |= c;
-+
-+			// 3-byte sequence (most CJKV characters):
-+			// zzzzyyyyyyxxxxxx = 1110zzzz 10yyyyyy 10xxxxxx
-+			} else if ((c & 0xf0) == 0xe0) {
-+				uchar = (c & 0x0f) << 12;
-+
-+				c = (u8) *s++;
-+				if ((c & 0xc0) != 0xc0)
-+					goto fail;
-+				c &= 0x3f;
-+				uchar |= c << 6;
-+
-+				c = (u8) *s++;
-+				if ((c & 0xc0) != 0xc0)
-+					goto fail;
-+				c &= 0x3f;
-+				uchar |= c;
-+
-+				/* no bogus surrogates */
-+				if (0xd800 <= uchar && uchar <= 0xdfff)
-+					goto fail;
-+
-+			// 4-byte sequence (surrogate pairs, currently rare):
-+			// 11101110wwwwzzzzyy + 110111yyyyxxxxxx
-+			//     = 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx
-+			// (uuuuu = wwww + 1)
-+			// FIXME accept the surrogate code points (only)
-+
-+			} else
-+				goto fail;
-+		} else
-+			uchar = c;
-+		put_unaligned (cpu_to_le16 (uchar), cp++);
-+		count++;
-+		len--;
-+	}
-+	return count;
-+fail:
-+	return -1;
-+}
-+
-+
-+/**
-+ * usb_gadget_get_string - fill out a string descriptor 
-+ * @table: of c strings encoded using UTF-8
-+ * @id: string id, from low byte of wValue in get string descriptor
-+ * @buf: at least 256 bytes
-+ *
-+ * Finds the UTF-8 string matching the ID, and converts it into a
-+ * string descriptor in utf16-le.
-+ * Returns length of descriptor (always even) or negative errno
-+ *
-+ * If your driver needs stings in multiple languages, you'll probably
-+ * "switch (wIndex) { ... }"  in your ep0 string descriptor logic,
-+ * using this routine after choosing which set of UTF-8 strings to use.
-+ * Note that US-ASCII is a strict subset of UTF-8; any string bytes with
-+ * the eighth bit set will be multibyte UTF-8 characters, not ISO-8859/1
-+ * characters (which are also widely used in C strings).
-+ */
-+int
-+usb_gadget_get_string (struct usb_gadget_strings *table, int id, u8 *buf)
-+{
-+	struct usb_string	*s;
-+	int			len;
-+
-+	/* descriptor 0 has the language id */
-+	if (id == 0) {
-+		buf [0] = 4;
-+		buf [1] = USB_DT_STRING;
-+		buf [2] = (u8) table->language;
-+		buf [3] = (u8) (table->language >> 8);
-+		return 4;
-+	}
-+	for (s = table->strings; s && s->s; s++)
-+		if (s->id == id)
-+			break;
-+
-+	/* unrecognized: stall. */
-+	if (!s || !s->s)
-+		return -EINVAL;
-+
-+	/* string descriptors have length, tag, then UTF16-LE text */
-+	len = min ((size_t) 126, strlen (s->s));
-+	memset (buf + 2, 0, 2 * len);	/* zero all the bytes */
-+	len = utf8_to_utf16le(s->s, (u16 *)&buf[2], len);
-+	if (len < 0)
-+		return -EINVAL;
-+	buf [0] = (len + 1) * 2;
-+	buf [1] = USB_DT_STRING;
-+	return buf [0];
-+}
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/drivers/usb/gadget/zero.c kernel/drivers/usb/gadget/zero.c
---- /tmp/kernel/drivers/usb/gadget/zero.c	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/drivers/usb/gadget/zero.c	2005-04-22 17:53:19.521525352 +0200
-@@ -0,0 +1,1363 @@
-+/*
-+ * zero.c -- Gadget Zero, for USB development
-+ *
-+ * Copyright (C) 2003-2004 David Brownell
-+ * All rights reserved.
-+ *
-+ * Redistribution and use in source and binary forms, with or without
-+ * modification, are permitted provided that the following conditions
-+ * are met:
-+ * 1. Redistributions of source code must retain the above copyright
-+ *    notice, this list of conditions, and the following disclaimer,
-+ *    without modification.
-+ * 2. Redistributions in binary form must reproduce the above copyright
-+ *    notice, this list of conditions and the following disclaimer in the
-+ *    documentation and/or other materials provided with the distribution.
-+ * 3. The names of the above-listed copyright holders may not be used
-+ *    to endorse or promote products derived from this software without
-+ *    specific prior written permission.
-+ *
-+ * ALTERNATIVELY, this software may be 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.
-+ *
-+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-+ */
-+
-+
-+/*
-+ * Gadget Zero only needs two bulk endpoints, and is an example of how you
-+ * can write a hardware-agnostic gadget driver running inside a USB device.
-+ *
-+ * Hardware details are visible (see CONFIG_USB_ZERO_* below) but don't
-+ * affect most of the driver.
-+ *
-+ * Use it with the Linux host/master side "usbtest" driver to get a basic
-+ * functional test of your device-side usb stack, or with "usb-skeleton".
-+ *
-+ * 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
-+ *
-+ * Many drivers will only have one configuration, letting them be much
-+ * simpler if they also don't support high speed operation (like this
-+ * driver does).
-+ */
-+
-+#define DEBUG 1
-+// #define VERBOSE
-+
-+#include <linux/config.h>
-+#include <linux/kernel.h>
-+#include <linux/module.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/uts.h>
-+#include <linux/version.h>
-+
-+#include <asm/byteorder.h>
-+#include <asm/io.h>
-+#include <asm/irq.h>
-+#include <asm/system.h>
-+#include <asm/unaligned.h>
-+
-+#include <linux/usb_ch9.h>
-+#include <linux/usb_gadget.h>
-+
-+#include "gadget_chips.h"
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+#define DRIVER_VERSION		"St Patrick's Day 2004"
-+
-+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 xprintk(d,level,fmt,args...) \
-+	printk(level "%s %s: " fmt , shortname , (d)->gadget->dev.bus_id , \
-+		## args)
-+
-+#ifdef 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
-+#define VDBG	DBG
-+#else
-+#define VDBG(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)
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static unsigned buflen = 4096;
-+static unsigned qlen = 32;
-+static unsigned pattern = 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.
-+ */
-+static int loopdefault = 0;
-+
-+
-+MODULE_PARM (buflen, "i");
-+MODULE_PARM_DESC (buflen, "size of i/o buffers");
-+
-+MODULE_PARM (qlen, "i");
-+MODULE_PARM_DESC (qlen, "depth of loopback buffering");
-+
-+MODULE_PARM (pattern, "i");
-+MODULE_PARM_DESC (pattern, "0 for default all-zeroes, 1 for mod63");
-+
-+MODULE_PARM (loopdefault, "b");
-+MODULE_PARM_DESC (loopdefault, "true to have default config be loopback");
-+
-+/*
-+ * 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_PARM (autoresume, "i");
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* 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.
-+ */
-+#ifndef	CONFIG_USB_ZERO_HNPTEST
-+#define DRIVER_VENDOR_NUM	0x0525		/* NetChip */
-+#define DRIVER_PRODUCT_NUM	0xa4a0		/* Linux-USB "Gadget Zero" */
-+#else
-+#define DRIVER_VENDOR_NUM	0x1a0a		/* OTG test device IDs */
-+#define DRIVER_PRODUCT_NUM	0xbadd
-+#endif
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ * 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,
-+
-+	.bcdUSB =		__constant_cpu_to_le16 (0x0200),
-+	.bDeviceClass =		USB_CLASS_VENDOR_SPEC,
-+
-+	.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 */
-+};
-+
-+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,
-+};
-+
-+#ifdef	CONFIG_USB_GADGET_DUALSPEED
-+
-+/*
-+ * 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,
-+};
-+
-+static const struct usb_descriptor_header *hs_source_sink_function [] = {
-+	(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,
-+};
-+
-+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,
-+};
-+
-+/* maxpacket and other transfer characteristics vary by speed. */
-+#define ep_desc(g,hs,fs) (((g)->speed==USB_SPEED_HIGH)?(hs):(fs))
-+
-+#else
-+
-+/* if there's no high speed support, maxpacket doesn't change. */
-+#define ep_desc(g,hs,fs) fs
-+
-+#endif	/* !CONFIG_USB_GADGET_DUALSPEED */
-+
-+static char				manufacturer [50];
-+static char				serial [40];
-+
-+/* 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, },
-+	{  }			/* end of list */
-+};
-+
-+static struct usb_gadget_strings	stringtab = {
-+	.language	= 0x0409,	/* en-us */
-+	.strings	= strings,
-+};
-+
-+/*
-+ * 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;
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+	int				hs = (gadget->speed == USB_SPEED_HIGH);
-+#endif
-+
-+	/* two configurations will always be index 0 and index 1 */
-+	if (index > 1)
-+		return -EINVAL;
-+	is_source_sink = loopdefault ? (index == 1) : (index == 0);
-+
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+	if (type == USB_DT_OTHER_SPEED_CONFIG)
-+		hs = !hs;
-+	if (hs)
-+		function = is_source_sink
-+			? hs_source_sink_function
-+			: hs_loopback_function;
-+	else
-+#endif
-+		function = is_source_sink
-+			? fs_source_sink_function
-+			: fs_loopback_function;
-+
-+	/* for now, don't advertise srp-only devices */
-+	if (!gadget->is_otg)
-+		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_request *
-+alloc_ep_req (struct usb_ep *ep, unsigned length)
-+{
-+	struct usb_request	*req;
-+
-+	req = usb_ep_alloc_request (ep, GFP_ATOMIC);
-+	if (req) {
-+		req->length = length;
-+		req->buf = usb_ep_alloc_buffer (ep, length,
-+				&req->dma, GFP_ATOMIC);
-+		if (!req->buf) {
-+			usb_ep_free_request (ep, req);
-+			req = NULL;
-+		}
-+	}
-+	return req;
-+}
-+
-+static void free_ep_req (struct usb_ep *ep, struct usb_request *req)
-+{
-+	if (req->buf)
-+		usb_ep_free_buffer (ep, req->buf, req->dma, req->length);
-+	usb_ep_free_request (ep, req);
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* optionally require specific source/sink data patterns  */
-+
-+static int
-+check_read_data (
-+	struct zero_dev		*dev,
-+	struct usb_ep		*ep,
-+	struct usb_request	*req
-+)
-+{
-+	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;
-+	}
-+	return 0;
-+}
-+
-+static void
-+reinit_write_data (
-+	struct zero_dev		*dev,
-+	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;
-+	}
-+}
-+
-+/* 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);
-+		else
-+			reinit_write_data (dev, 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, int gfp_flags)
-+{
-+	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->driver_data, ep, req);
-+
-+	status = usb_ep_queue (ep, req, gfp_flags);
-+	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 gfp_flags)
-+{
-+	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, gfp_flags) != 0) {
-+					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, gfp_flags) != 0) {
-+					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 gfp_flags)
-+{
-+	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 gfp_flags)
-+{
-+	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...*/
-+		INFO (dev, "can't change configurations\n");
-+		return -ESPIPE;
-+	}
-+	zero_reset_config (dev);
-+
-+	switch (number) {
-+	case CONFIG_SOURCE_SINK:
-+		result = set_source_sink_config (dev, gfp_flags);
-+		break;
-+	case CONFIG_LOOPBACK:
-+		result = set_loopback_config (dev, gfp_flags);
-+		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;
-+
-+	/* 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 (ctrl->wValue >> 8) {
-+
-+		case USB_DT_DEVICE:
-+			value = min (ctrl->wLength, (u16) sizeof device_desc);
-+			memcpy (req->buf, &device_desc, value);
-+			break;
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+		case USB_DT_DEVICE_QUALIFIER:
-+			if (!gadget->is_dualspeed)
-+				break;
-+			value = min (ctrl->wLength, (u16) sizeof dev_qualifier);
-+			memcpy (req->buf, &dev_qualifier, value);
-+			break;
-+
-+		case USB_DT_OTHER_SPEED_CONFIG:
-+			if (!gadget->is_dualspeed)
-+				break;
-+			// FALLTHROUGH
-+#endif /* CONFIG_USB_GADGET_DUALSPEED */
-+		case USB_DT_CONFIG:
-+			value = config_buf (gadget, req->buf,
-+					ctrl->wValue >> 8,
-+					ctrl->wValue & 0xff);
-+			if (value >= 0)
-+				value = min (ctrl->wLength, (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,
-+					ctrl->wValue & 0xff, req->buf);
-+			if (value >= 0)
-+				value = min (ctrl->wLength, (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, ctrl->wValue, GFP_ATOMIC);
-+		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 (ctrl->wLength, (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 && ctrl->wIndex == 0 && ctrl->wValue == 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, GFP_ATOMIC);
-+			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 (ctrl->wIndex != 0) {
-+			value = -EDOM;
-+			break;
-+		}
-+		*(u8 *)req->buf = 0;
-+		value = min (ctrl->wLength, (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 (ctrl->wValue || ctrl->wIndex)
-+			break;
-+		/* just read that many bytes into the buffer */
-+		if (ctrl->wLength > USB_BUFSIZ)
-+			break;
-+		value = ctrl->wLength;
-+		break;
-+	case 0x5c:	/* control READ test -- return the buffer */
-+		if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
-+			goto unknown;
-+		if (ctrl->wValue || ctrl->wIndex)
-+			break;
-+		/* expect those bytes are still in the buffer; send back */
-+		if (ctrl->wLength > USB_BUFSIZ
-+				|| ctrl->wLength != req->length)
-+			break;
-+		value = ctrl->wLength;
-+		break;
-+
-+	default:
-+unknown:
-+		VDBG (dev,
-+			"unknown control req%02x.%02x v%04x i%04x l%d\n",
-+			ctrl->bRequestType, ctrl->bRequest,
-+			ctrl->wValue, ctrl->wIndex, ctrl->wLength);
-+	}
-+
-+	/* respond with data transfer before status phase? */
-+	if (value >= 0) {
-+		req->length = value;
-+		req->zero = value < ctrl->wLength
-+				&& (value % gadget->ep0->maxpacket) == 0;
-+		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);
-+	}
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
-+static void
-+zero_unbind (struct usb_gadget *gadget)
-+{
-+	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)
-+		free_ep_req (gadget->ep0, dev->req);
-+	del_timer_sync (&dev->resume);
-+	kfree (dev);
-+	set_gadget_data (gadget, NULL);
-+}
-+
-+static int
-+zero_bind (struct usb_gadget *gadget)
-+{
-+	struct zero_dev		*dev;
-+	struct usb_ep		*ep;
-+
-+	/* 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.
-+	 */
-+	usb_ep_autoconfig_reset (gadget);
-+	ep = usb_ep_autoconfig (gadget, &fs_source_desc);
-+	if (!ep) {
-+autoconf_fail:
-+		printk (KERN_ERR "%s: can't autoconfigure on %s\n",
-+			shortname, gadget->name);
-+		return -ENODEV;
-+	}
-+	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 */
-+
-+
-+	/*
-+	 * DRIVER POLICY CHOICE:  you may want to do this differently.
-+	 * One thing to avoid is reusing a bcdDevice revision code
-+	 * with different host-visible configurations or behavior
-+	 * restrictions -- using ep1in/ep2out vs ep1out/ep3in, etc
-+	 */
-+	if (gadget_is_net2280 (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0201);
-+	} else if (gadget_is_pxa (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0203);
-+#if 0
-+	} else if (gadget_is_sh(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0204);
-+		/* SH has only one configuration; see "loopdefault" */
-+		device_desc.bNumConfigurations = 1;
-+		/* FIXME make 1 == default.bConfigurationValue */
-+#endif
-+	} else if (gadget_is_sa1100 (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0205);
-+	} else if (gadget_is_goku (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0206);
-+	} else if (gadget_is_mq11xx (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0207);
-+	} else if (gadget_is_omap (gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0208);
-+	} else if (gadget_is_lh7a40x(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0209);
-+	} else if (gadget_is_n9604(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0210);
-+	} else if (gadget_is_pxa27x(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0211);
-+	} else if (gadget_is_s3c2410(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0212);
-+	} else if (gadget_is_at91(gadget)) {
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x0213);
-+	} 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.
-+		 *
-+		 * things like configuration and altsetting numbering
-+		 * can need hardware-specific attention though.
-+		 */
-+		printk (KERN_WARNING "%s: controller '%s' not recognized\n",
-+			shortname, gadget->name);
-+		device_desc.bcdDevice = __constant_cpu_to_le16 (0x9999);
-+	}
-+
-+
-+	/* ok, we made sense of the hardware ... */
-+	dev = kmalloc (sizeof *dev, SLAB_KERNEL);
-+	if (!dev)
-+		return -ENOMEM;
-+	memset (dev, 0, sizeof *dev);
-+	spin_lock_init (&dev->lock);
-+	dev->gadget = gadget;
-+	set_gadget_data (gadget, dev);
-+
-+	/* preallocate control response and buffer */
-+	dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
-+	if (!dev->req)
-+		goto enomem;
-+	dev->req->buf = usb_ep_alloc_buffer (gadget->ep0, USB_BUFSIZ,
-+				&dev->req->dma, GFP_KERNEL);
-+	if (!dev->req->buf)
-+		goto enomem;
-+
-+	dev->req->complete = zero_setup_complete;
-+
-+	device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
-+
-+#ifdef CONFIG_USB_GADGET_DUALSPEED
-+	/* 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;
-+#endif
-+
-+	if (gadget->is_otg) {
-+		otg_descriptor.bmAttributes |= USB_OTG_HNP,
-+		source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
-+		loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
-+	}
-+
-+	if (gadget->is_otg) {
-+		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);
-+
-+	init_timer (&dev->resume);
-+	dev->resume.function = zero_autoresume;
-+	dev->resume.data = (unsigned long) dev;
-+	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);
-+
-+	snprintf (manufacturer, sizeof manufacturer,
-+		UTS_SYSNAME " " UTS_RELEASE " with %s",
-+		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,
-+	.bind		= zero_bind,
-+	.unbind		= zero_unbind,
-+
-+	.setup		= zero_setup,
-+	.disconnect	= zero_disconnect,
-+
-+	.suspend	= zero_suspend,
-+	.resume		= zero_resume,
-+
-+	.driver 	= {
-+		.name		= (char *) shortname,
-+		// .shutdown = ...
-+		// .suspend = ...
-+		// .resume = ...
-+	},
-+};
-+
-+MODULE_AUTHOR ("David Brownell");
-+MODULE_LICENSE ("Dual BSD/GPL");
-+
-+
-+static int __init init (void)
-+{
-+	/* a real value would likely come through some id prom
-+	 * or module option.  this one takes at least two packets.
-+	 */
-+	strncpy (serial, "0123456789.0123456789.0123456789", sizeof serial);
-+	serial [sizeof serial - 1] = 0;
-+
-+	return usb_gadget_register_driver (&zero_driver);
-+}
-+module_init (init);
-+
-+static void __exit cleanup (void)
-+{
-+	usb_gadget_unregister_driver (&zero_driver);
-+}
-+module_exit (cleanup);
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/include/linux/moduleparam.h kernel/include/linux/moduleparam.h
---- /tmp/kernel/include/linux/moduleparam.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/include/linux/moduleparam.h	2005-04-22 17:53:19.357552052 +0200
-@@ -0,0 +1,25 @@
-+#ifndef _LINUX_MODULE_PARAMS_H
-+#define _LINUX_MODULE_PARAMS_H
-+/* Macros for (very simple) module parameter compatibility with 2.6. */
-+#include <linux/module.h>
-+
-+/* type is byte, short, ushort, int, uint, long, ulong, bool. (2.6
-+   has more, but they are not supported).  perm is permissions when
-+   it appears in sysfs: 0 means doens't appear, 0444 means read-only
-+   by everyone, 0644 means changable dynamically by root, etc.  name
-+   must be in scope (unlike MODULE_PARM).
-+*/
-+#define module_param(name, type, perm)					     \
-+	static inline void *__check_existence_##name(void) { return &name; } \
-+	MODULE_PARM(name, _MODULE_PARM_STRING_ ## type)
-+
-+#define _MODULE_PARM_STRING_byte "b"
-+#define _MODULE_PARM_STRING_short "h"
-+#define _MODULE_PARM_STRING_ushort "h"
-+#define _MODULE_PARM_STRING_int "i"
-+#define _MODULE_PARM_STRING_uint "i"
-+#define _MODULE_PARM_STRING_long "l"
-+#define _MODULE_PARM_STRING_ulong "l"
-+#define _MODULE_PARM_STRING_bool "i"
-+
-+#endif /* _LINUX_MODULE_PARAM_TYPES_H */
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/include/linux/usb_cdc.h kernel/include/linux/usb_cdc.h
---- /tmp/kernel/include/linux/usb_cdc.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/include/linux/usb_cdc.h	2005-04-22 17:53:19.360551563 +0200
-@@ -0,0 +1,204 @@
-+/*
-+ * USB Communications Device Class (CDC) definitions
-+ *
-+ * CDC says how to talk to lots of different types of network adapters,
-+ * notably ethernet adapters and various modems.  It's used mostly with
-+ * firmware based USB peripherals.
-+ *
-+ * (C) Copyright 2005 by David Brownell
-+ * All Rights Reserved.
-+ *
-+ * This software is licensed under the GNU GPL version 2.
-+ */
-+
-+#define USB_CDC_SUBCLASS_ACM			0x02
-+#define USB_CDC_SUBCLASS_ETHERNET		0x06
-+#define USB_CDC_SUBCLASS_WHCM			0x08
-+#define USB_CDC_SUBCLASS_DMM			0x09
-+#define USB_CDC_SUBCLASS_MDLM			0x0a
-+#define USB_CDC_SUBCLASS_OBEX			0x0b
-+
-+#define USB_CDC_PROTO_NONE			0
-+
-+#define USB_CDC_ACM_PROTO_AT_V25TER		1
-+#define USB_CDC_ACM_PROTO_AT_PCCA101		2
-+#define USB_CDC_ACM_PROTO_AT_PCCA101_WAKE	3
-+#define USB_CDC_ACM_PROTO_AT_GSM		4
-+#define USB_CDC_ACM_PROTO_AT_3G			5
-+#define USB_CDC_ACM_PROTO_AT_CDMA		6
-+#define USB_CDC_ACM_PROTO_VENDOR		0xff
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* 2.6 "sparse" support for checking beyond what GCC does */
-+
-+#define	__le16	u16
-+#define	__le32	u32
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ * Class-Specific descriptors ... there are a couple dozen of them
-+ */
-+
-+#define USB_CDC_HEADER_TYPE		0x00		/* header_desc */
-+#define USB_CDC_CALL_MANAGEMENT_TYPE	0x01		/* call_mgmt_descriptor */
-+#define USB_CDC_ACM_TYPE		0x02		/* acm_descriptor */
-+#define USB_CDC_UNION_TYPE		0x06		/* union_desc */
-+#define USB_CDC_COUNTRY_TYPE		0x07
-+#define USB_CDC_ETHERNET_TYPE		0x0f		/* ether_desc */
-+#define USB_CDC_WHCM_TYPE		0x11
-+#define USB_CDC_MDLM_TYPE		0x12		/* mdlm_desc */
-+#define USB_CDC_MDLM_DETAIL_TYPE	0x13		/* mdlm_detail_desc */
-+#define USB_CDC_DMM_TYPE		0x14
-+#define USB_CDC_OBEX_TYPE		0x15
-+
-+/* "Header Functional Descriptor" from CDC spec  5.2.3.1 */
-+struct usb_cdc_header_desc {
-+	__u8	bLength;
-+	__u8	bDescriptorType;
-+	__u8	bDescriptorSubType;
-+
-+	__le16	bcdCDC;
-+} __attribute__ ((packed));
-+
-+/* "Call Management Descriptor" from CDC spec  5.2.3.2 */
-+struct usb_cdc_call_mgmt_descriptor {
-+	__u8	bLength;
-+	__u8	bDescriptorType;
-+	__u8	bDescriptorSubType;
-+
-+	__u8	bmCapabilities;
-+#define USB_CDC_CALL_MGMT_CAP_CALL_MGMT		0x01
-+#define USB_CDC_CALL_MGMT_CAP_DATA_INTF		0x02
-+
-+	__u8	bDataInterface;
-+} __attribute__ ((packed));
-+
-+/* "Abstract Control Management Descriptor" from CDC spec  5.2.3.3 */
-+struct usb_cdc_acm_descriptor {
-+	__u8	bLength;
-+	__u8	bDescriptorType;
-+	__u8	bDescriptorSubType;
-+
-+	__u8	bmCapabilities;
-+} __attribute__ ((packed));
-+
-+/* "Union Functional Descriptor" from CDC spec 5.2.3.8 */
-+struct usb_cdc_union_desc {
-+	__u8	bLength;
-+	__u8	bDescriptorType;
-+	__u8	bDescriptorSubType;
-+
-+	__u8	bMasterInterface0;
-+	__u8	bSlaveInterface0;
-+	/* ... and there could be other slave interfaces */
-+} __attribute__ ((packed));
-+
-+/* "Ethernet Networking Functional Descriptor" from CDC spec 5.2.3.16 */
-+struct usb_cdc_ether_desc {
-+	__u8	bLength;
-+	__u8	bDescriptorType;
-+	__u8	bDescriptorSubType;
-+
-+	__u8	iMACAddress;
-+	__le32	bmEthernetStatistics;
-+	__le16	wMaxSegmentSize;
-+	__le16	wNumberMCFilters;
-+	__u8	bNumberPowerFilters;
-+} __attribute__ ((packed));
-+
-+/* "MDLM Functional Descriptor" from CDC WMC spec 6.7.2.3 */
-+struct usb_cdc_mdlm_desc {
-+	__u8	bLength;
-+	__u8	bDescriptorType;
-+	__u8	bDescriptorSubType;
-+
-+	__le16	bcdVersion;
-+	__u8	bGUID[16];
-+} __attribute__ ((packed));
-+
-+/* "MDLM Detail Functional Descriptor" from CDC WMC spec 6.7.2.4 */
-+struct usb_cdc_mdlm_detail_desc {
-+	__u8	bLength;
-+	__u8	bDescriptorType;
-+	__u8	bDescriptorSubType;
-+
-+	/* type is associated with mdlm_desc.bGUID */
-+	__u8	bGuidDescriptorType;
-+	__u8	bDetailData[];
-+} __attribute__ ((packed));
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ * Class-Specific Control Requests (6.2)
-+ *
-+ * section 3.6.2.1 table 4 has the ACM profile, for modems.
-+ * section 3.8.2 table 10 has the ethernet profile.
-+ *
-+ * Microsoft's RNDIS stack for Ethernet is a vendor-specific CDC ACM variant,
-+ * heavily dependent on the encapsulated (proprietary) command mechanism.
-+ */
-+
-+#define USB_CDC_SEND_ENCAPSULATED_COMMAND	0x00
-+#define USB_CDC_GET_ENCAPSULATED_RESPONSE	0x01
-+#define USB_CDC_REQ_SET_LINE_CODING		0x20
-+#define USB_CDC_REQ_GET_LINE_CODING		0x21
-+#define USB_CDC_REQ_SET_CONTROL_LINE_STATE	0x22
-+#define USB_CDC_REQ_SEND_BREAK			0x23
-+#define USB_CDC_SET_ETHERNET_MULTICAST_FILTERS	0x40
-+#define USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER	0x41
-+#define USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER	0x42
-+#define USB_CDC_SET_ETHERNET_PACKET_FILTER	0x43
-+#define USB_CDC_GET_ETHERNET_STATISTIC		0x44
-+
-+/* Line Coding Structure from CDC spec 6.2.13 */
-+struct usb_cdc_line_coding {
-+	__le32	dwDTERate;
-+	__u8	bCharFormat;
-+#define USB_CDC_1_STOP_BITS			0
-+#define USB_CDC_1_5_STOP_BITS			1
-+#define USB_CDC_2_STOP_BITS			2
-+
-+	__u8	bParityType;
-+#define USB_CDC_NO_PARITY			0
-+#define USB_CDC_ODD_PARITY			1
-+#define USB_CDC_EVEN_PARITY			2
-+#define USB_CDC_MARK_PARITY			3
-+#define USB_CDC_SPACE_PARITY			4
-+
-+	__u8	bDataBits;
-+} __attribute__ ((packed));
-+
-+/* table 62; bits in multicast filter */
-+#define	USB_CDC_PACKET_TYPE_PROMISCUOUS		(1 << 0)
-+#define	USB_CDC_PACKET_TYPE_ALL_MULTICAST	(1 << 1) /* no filter */
-+#define	USB_CDC_PACKET_TYPE_DIRECTED		(1 << 2)
-+#define	USB_CDC_PACKET_TYPE_BROADCAST		(1 << 3)
-+#define	USB_CDC_PACKET_TYPE_MULTICAST		(1 << 4) /* filtered */
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ * Class-Specific Notifications (6.3) sent by interrupt transfers
-+ *
-+ * section 3.8.2 table 11 of the CDC spec lists Ethernet notifications
-+ * section 3.6.2.1 table 5 specifies ACM notifications, accepted by RNDIS
-+ * RNDIS also defines its own bit-incompatible notifications
-+ */
-+
-+#define USB_CDC_NOTIFY_NETWORK_CONNECTION	0x00
-+#define USB_CDC_NOTIFY_RESPONSE_AVAILABLE	0x01
-+#define USB_CDC_NOTIFY_SERIAL_STATE		0x20
-+#define USB_CDC_NOTIFY_SPEED_CHANGE		0x2a
-+
-+struct usb_cdc_notification {
-+	__u8	bmRequestType;
-+	__u8	bNotificationType;
-+	__le16	wValue;
-+	__le16	wIndex;
-+	__le16	wLength;
-+} __attribute__ ((packed));
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/include/linux/usb_ch9.h kernel/include/linux/usb_ch9.h
---- /tmp/kernel/include/linux/usb_ch9.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/include/linux/usb_ch9.h	2005-04-22 17:53:19.363551075 +0200
-@@ -0,0 +1,384 @@
-+/*
-+ * This file holds USB constants and structures that are needed for USB
-+ * device APIs.  These are used by the USB device model, which is defined
-+ * in chapter 9 of the USB 2.0 specification.  Linux has several APIs in C
-+ * that need these:
-+ *
-+ * - the master/host side Linux-USB kernel driver API;
-+ * - the "usbfs" user space API; and
-+ * - (eventually) a Linux "gadget" slave/device side driver API.
-+ *
-+ * USB 2.0 adds an additional "On The Go" (OTG) mode, which lets systems
-+ * act either as a USB master/host or as a USB slave/device.  That means
-+ * the master and slave side APIs will benefit from working well together.
-+ */
-+
-+#ifndef __LINUX_USB_CH9_H
-+#define __LINUX_USB_CH9_H
-+
-+#include <asm/types.h>		/* __u8 etc */
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* CONTROL REQUEST SUPPORT */
-+
-+/*
-+ * USB directions
-+ *
-+ * This bit flag is used in endpoint descriptors' bEndpointAddress field.
-+ * It's also one of three fields in control requests bRequestType.
-+ */
-+#define USB_DIR_OUT			0		/* to device */
-+#define USB_DIR_IN			0x80		/* to host */
-+
-+/*
-+ * USB types, the second of three bRequestType fields
-+ */
-+#define USB_TYPE_MASK			(0x03 << 5)
-+#define USB_TYPE_STANDARD		(0x00 << 5)
-+#define USB_TYPE_CLASS			(0x01 << 5)
-+#define USB_TYPE_VENDOR			(0x02 << 5)
-+#define USB_TYPE_RESERVED		(0x03 << 5)
-+
-+/*
-+ * USB recipients, the third of three bRequestType fields
-+ */
-+#define USB_RECIP_MASK			0x1f
-+#define USB_RECIP_DEVICE		0x00
-+#define USB_RECIP_INTERFACE		0x01
-+#define USB_RECIP_ENDPOINT		0x02
-+#define USB_RECIP_OTHER			0x03
-+
-+/*
-+ * Standard requests, for the bRequest field of a SETUP packet.
-+ *
-+ * These are qualified by the bRequestType field, so that for example
-+ * TYPE_CLASS or TYPE_VENDOR specific feature flags could be retrieved
-+ * by a GET_STATUS request.
-+ */
-+#define USB_REQ_GET_STATUS		0x00
-+#define USB_REQ_CLEAR_FEATURE		0x01
-+#define USB_REQ_SET_FEATURE		0x03
-+#define USB_REQ_SET_ADDRESS		0x05
-+#define USB_REQ_GET_DESCRIPTOR		0x06
-+#define USB_REQ_SET_DESCRIPTOR		0x07
-+#define USB_REQ_GET_CONFIGURATION	0x08
-+#define USB_REQ_SET_CONFIGURATION	0x09
-+#define USB_REQ_GET_INTERFACE		0x0A
-+#define USB_REQ_SET_INTERFACE		0x0B
-+#define USB_REQ_SYNCH_FRAME		0x0C
-+
-+/*
-+ * USB feature flags are written using USB_REQ_{CLEAR,SET}_FEATURE, and
-+ * are read as a bit array returned by USB_REQ_GET_STATUS.  (So there
-+ * are at most sixteen features of each type.)
-+ */
-+#define USB_DEVICE_SELF_POWERED		0	/* (read only) */
-+#define USB_DEVICE_REMOTE_WAKEUP	1	/* dev may initiate wakeup */
-+#define USB_DEVICE_TEST_MODE		2	/* (high speed only) */
-+#define USB_DEVICE_B_HNP_ENABLE		3	/* dev may initiate HNP */
-+#define USB_DEVICE_A_HNP_SUPPORT	4	/* RH port supports HNP */
-+#define USB_DEVICE_A_ALT_HNP_SUPPORT	5	/* other RH port does */
-+#define USB_DEVICE_DEBUG_MODE		6	/* (special devices only) */
-+
-+#define USB_ENDPOINT_HALT		0	/* IN/OUT will STALL */
-+
-+
-+/**
-+ * struct usb_ctrlrequest - SETUP data for a USB device control request
-+ * @bRequestType: matches the USB bmRequestType field
-+ * @bRequest: matches the USB bRequest field
-+ * @wValue: matches the USB wValue field (le16 byte order)
-+ * @wIndex: matches the USB wIndex field (le16 byte order)
-+ * @wLength: matches the USB wLength field (le16 byte order)
-+ *
-+ * This structure is used to send control requests to a USB device.  It matches
-+ * the different fields of the USB 2.0 Spec section 9.3, table 9-2.  See the
-+ * USB spec for a fuller description of the different fields, and what they are
-+ * used for.
-+ *
-+ * Note that the driver for any interface can issue control requests.
-+ * For most devices, interfaces don't coordinate with each other, so
-+ * such requests may be made at any time.
-+ */
-+struct usb_ctrlrequest {
-+	__u8 bRequestType;
-+	__u8 bRequest;
-+	__u16 wValue;
-+	__u16 wIndex;
-+	__u16 wLength;
-+} __attribute__ ((packed));
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/*
-+ * STANDARD DESCRIPTORS ... as returned by GET_DESCRIPTOR, or
-+ * (rarely) accepted by SET_DESCRIPTOR.
-+ *
-+ * Note that all multi-byte values here are encoded in little endian
-+ * byte order "on the wire".  But when exposed through Linux-USB APIs,
-+ * they've been converted to cpu byte order.
-+ */
-+
-+/*
-+ * Descriptor types ... USB 2.0 spec table 9.5
-+ */
-+#define USB_DT_DEVICE			0x01
-+#define USB_DT_CONFIG			0x02
-+#define USB_DT_STRING			0x03
-+#define USB_DT_INTERFACE		0x04
-+#define USB_DT_ENDPOINT			0x05
-+#define USB_DT_DEVICE_QUALIFIER		0x06
-+#define USB_DT_OTHER_SPEED_CONFIG	0x07
-+#define USB_DT_INTERFACE_POWER		0x08
-+/* these are from a minor usb 2.0 revision (ECN) */
-+#define USB_DT_OTG			0x09
-+#define USB_DT_DEBUG			0x0a
-+#define USB_DT_INTERFACE_ASSOCIATION	0x0b
-+
-+/* conventional codes for class-specific descriptors */
-+#define USB_DT_CS_DEVICE		0x21
-+#define USB_DT_CS_CONFIG		0x22
-+#define USB_DT_CS_STRING		0x23
-+#define USB_DT_CS_INTERFACE		0x24
-+#define USB_DT_CS_ENDPOINT		0x25
-+
-+/* All standard descriptors have these 2 fields at the beginning */
-+struct usb_descriptor_header {
-+	__u8  bLength;
-+	__u8  bDescriptorType;
-+} __attribute__ ((packed));
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* USB_DT_DEVICE: Device descriptor */
-+struct usb_device_descriptor {
-+	__u8  bLength;
-+	__u8  bDescriptorType;
-+
-+	__u16 bcdUSB;
-+	__u8  bDeviceClass;
-+	__u8  bDeviceSubClass;
-+	__u8  bDeviceProtocol;
-+	__u8  bMaxPacketSize0;
-+	__u16 idVendor;
-+	__u16 idProduct;
-+	__u16 bcdDevice;
-+	__u8  iManufacturer;
-+	__u8  iProduct;
-+	__u8  iSerialNumber;
-+	__u8  bNumConfigurations;
-+} __attribute__ ((packed));
-+
-+#define USB_DT_DEVICE_SIZE		18
-+
-+
-+/*
-+ * Device and/or Interface Class codes
-+ * as found in bDeviceClass or bInterfaceClass
-+ * and defined by www.usb.org documents
-+ */
-+#define USB_CLASS_PER_INTERFACE		0	/* for DeviceClass */
-+#define USB_CLASS_AUDIO			1
-+#define USB_CLASS_COMM			2
-+#define USB_CLASS_HID			3
-+#define USB_CLASS_PHYSICAL		5
-+#define USB_CLASS_STILL_IMAGE		6
-+#define USB_CLASS_PRINTER		7
-+#define USB_CLASS_MASS_STORAGE		8
-+#define USB_CLASS_HUB			9
-+#define USB_CLASS_CDC_DATA		0x0a
-+#define USB_CLASS_CSCID			0x0b	/* chip+ smart card */
-+#define USB_CLASS_CONTENT_SEC		0x0d	/* content security */
-+#define USB_CLASS_VIDEO			0x0e
-+#define USB_CLASS_APP_SPEC		0xfe
-+#define USB_CLASS_VENDOR_SPEC		0xff
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* USB_DT_CONFIG: Configuration descriptor information.
-+ *
-+ * USB_DT_OTHER_SPEED_CONFIG is the same descriptor, except that the
-+ * descriptor type is different.  Highspeed-capable devices can look
-+ * different depending on what speed they're currently running.  Only
-+ * devices with a USB_DT_DEVICE_QUALIFIER have any OTHER_SPEED_CONFIG
-+ * descriptors.
-+ */
-+struct usb_config_descriptor {
-+	__u8  bLength;
-+	__u8  bDescriptorType;
-+
-+	__u16 wTotalLength;
-+	__u8  bNumInterfaces;
-+	__u8  bConfigurationValue;
-+	__u8  iConfiguration;
-+	__u8  bmAttributes;
-+	__u8  bMaxPower;
-+} __attribute__ ((packed));
-+
-+#define USB_DT_CONFIG_SIZE		9
-+
-+/* from config descriptor bmAttributes */
-+#define USB_CONFIG_ATT_ONE		(1 << 7)	/* must be set */
-+#define USB_CONFIG_ATT_SELFPOWER	(1 << 6)	/* self powered */
-+#define USB_CONFIG_ATT_WAKEUP		(1 << 5)	/* can wakeup */
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* USB_DT_STRING: String descriptor */
-+struct usb_string_descriptor {
-+	__u8  bLength;
-+	__u8  bDescriptorType;
-+
-+	__u16 wData[1];		/* UTF-16LE encoded */
-+} __attribute__ ((packed));
-+
-+/* note that "string" zero is special, it holds language codes that
-+ * the device supports, not Unicode characters.
-+ */
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* USB_DT_INTERFACE: Interface descriptor */
-+struct usb_interface_descriptor {
-+	__u8  bLength;
-+	__u8  bDescriptorType;
-+
-+	__u8  bInterfaceNumber;
-+	__u8  bAlternateSetting;
-+	__u8  bNumEndpoints;
-+	__u8  bInterfaceClass;
-+	__u8  bInterfaceSubClass;
-+	__u8  bInterfaceProtocol;
-+	__u8  iInterface;
-+} __attribute__ ((packed));
-+
-+#define USB_DT_INTERFACE_SIZE		9
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* USB_DT_ENDPOINT: Endpoint descriptor */
-+struct usb_endpoint_descriptor {
-+	__u8  bLength;
-+	__u8  bDescriptorType;
-+
-+	__u8  bEndpointAddress;
-+	__u8  bmAttributes;
-+	__u16 wMaxPacketSize;
-+	__u8  bInterval;
-+
-+	// NOTE:  these two are _only_ in audio endpoints.
-+	// use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof.
-+	__u8  bRefresh;
-+	__u8  bSynchAddress;
-+} __attribute__ ((packed));
-+
-+#define USB_DT_ENDPOINT_SIZE		7
-+#define USB_DT_ENDPOINT_AUDIO_SIZE	9	/* Audio extension */
-+
-+
-+/*
-+ * Endpoints
-+ */
-+#define USB_ENDPOINT_NUMBER_MASK	0x0f	/* in bEndpointAddress */
-+#define USB_ENDPOINT_DIR_MASK		0x80
-+
-+#define USB_ENDPOINT_XFERTYPE_MASK	0x03	/* in bmAttributes */
-+#define USB_ENDPOINT_XFER_CONTROL	0
-+#define USB_ENDPOINT_XFER_ISOC		1
-+#define USB_ENDPOINT_XFER_BULK		2
-+#define USB_ENDPOINT_XFER_INT		3
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* USB_DT_DEVICE_QUALIFIER: Device Qualifier descriptor */
-+struct usb_qualifier_descriptor {
-+	__u8  bLength;
-+	__u8  bDescriptorType;
-+
-+	__u16 bcdUSB;
-+	__u8  bDeviceClass;
-+	__u8  bDeviceSubClass;
-+	__u8  bDeviceProtocol;
-+	__u8  bMaxPacketSize0;
-+	__u8  bNumConfigurations;
-+	__u8  bRESERVED;
-+} __attribute__ ((packed));
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* USB_DT_OTG (from OTG 1.0a supplement) */
-+struct usb_otg_descriptor {
-+	__u8  bLength;
-+	__u8  bDescriptorType;
-+
-+	__u8  bmAttributes;	/* support for HNP, SRP, etc */
-+} __attribute__ ((packed));
-+
-+/* from usb_otg_descriptor.bmAttributes */
-+#define USB_OTG_SRP		(1 << 0)
-+#define USB_OTG_HNP		(1 << 1)	/* swap host/device roles */
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* USB_DT_DEBUG:  for special highspeed devices, replacing serial console */
-+struct usb_debug_descriptor {
-+	__u8  bLength;
-+	__u8  bDescriptorType;
-+
-+	/* bulk endpoints with 8 byte maxpacket */
-+	__u8  bDebugInEndpoint;
-+	__u8  bDebugOutEndpoint;
-+};
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* USB_DT_INTERFACE_ASSOCIATION: groups interfaces */
-+struct usb_interface_assoc_descriptor {
-+	__u8  bLength;
-+	__u8  bDescriptorType;
-+
-+	__u8  bFirstInterface;
-+	__u8  bInterfaceCount;
-+	__u8  bFunctionClass;
-+	__u8  bFunctionSubClass;
-+	__u8  bFunctionProtocol;
-+	__u8  iFunction;
-+} __attribute__ ((packed));
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* USB 2.0 defines three speeds, here's how Linux identifies them */
-+
-+enum usb_device_speed {
-+	USB_SPEED_UNKNOWN = 0,			/* enumerating */
-+	USB_SPEED_LOW, USB_SPEED_FULL,		/* usb 1.1 */
-+	USB_SPEED_HIGH				/* usb 2.0 */
-+};
-+
-+enum usb_device_state {
-+	/* NOTATTACHED isn't in the USB spec, and this state acts
-+	 * the same as ATTACHED ... but it's clearer this way.
-+	 */
-+	USB_STATE_NOTATTACHED = 0,
-+
-+	/* the chapter 9 device states */
-+	USB_STATE_ATTACHED,
-+	USB_STATE_POWERED,
-+	USB_STATE_DEFAULT,			/* limited function */
-+	USB_STATE_ADDRESS,
-+	USB_STATE_CONFIGURED,			/* most functions */
-+
-+	USB_STATE_SUSPENDED
-+
-+	/* NOTE:  there are actually four different SUSPENDED
-+	 * states, returning to POWERED, DEFAULT, ADDRESS, or
-+	 * CONFIGURED respectively when SOF tokens flow again.
-+	 */
-+};
-+
-+#endif	/* __LINUX_USB_CH9_H */
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/include/linux/usb_gadget.h kernel/include/linux/usb_gadget.h
---- /tmp/kernel/include/linux/usb_gadget.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/include/linux/usb_gadget.h	2005-04-22 17:53:19.367550424 +0200
-@@ -0,0 +1,896 @@
-+/*
-+ * <linux/usb_gadget.h>
-+ *
-+ * We call the USB code inside a Linux-based peripheral device a "gadget"
-+ * driver, except for the hardware-specific bus glue.  One USB host can
-+ * master many USB gadgets, but the gadgets are only slaved to one host.
-+ *
-+ *
-+ * (C) Copyright 2002-2004 by David Brownell
-+ * All Rights Reserved.
-+ *
-+ * This software is licensed under the GNU GPL version 2.
-+ */
-+
-+#ifndef __LINUX_USB_GADGET_H
-+#define __LINUX_USB_GADGET_H
-+
-+#ifdef __KERNEL__
-+
-+struct usb_ep;
-+
-+/**
-+ * struct usb_request - describes one i/o request
-+ * @buf: Buffer used for data.  Always provide this; some controllers
-+ * 	only use PIO, or don't use DMA for some endpoints.
-+ * @dma: DMA address corresponding to 'buf'.  If you don't set this
-+ * 	field, and the usb controller needs one, it is responsible
-+ * 	for mapping and unmapping the buffer.
-+ * @length: Length of that data
-+ * @no_interrupt: If true, hints that no completion irq is needed.
-+ *	Helpful sometimes with deep request queues that are handled
-+ *	directly by DMA controllers.
-+ * @zero: If true, when writing data, makes the last packet be "short"
-+ *     by adding a zero length packet as needed;
-+ * @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.
-+ *	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).
-+ *	Errors (for reads or writes) stop the queue from advancing
-+ *	until the completion function returns, so that any transfers
-+ *	invalidated by the error may first be dequeued.
-+ * @context: For use by the completion callback
-+ * @list: For use by the gadget driver.
-+ * @status: Reports completion code, zero or a negative errno.
-+ * 	Normally, faults block the transfer queue from advancing until
-+ * 	the completion callback returns.
-+ * 	Code "-ESHUTDOWN" indicates completion caused by device disconnect,
-+ * 	or when the driver disabled the endpoint.
-+ * @actual: Reports bytes transferred to/from the buffer.  For reads (OUT
-+ * 	transfers) this may be less than the requested length.  If the
-+ * 	short_not_ok flag is set, short reads are treated as errors
-+ * 	even when status otherwise indicates successful completion.
-+ * 	Note that for writes (IN transfers) some data bytes may still
-+ * 	reside in a device-side FIFO when the request is reported as
-+ *	complete.
-+ *
-+ * These are allocated/freed through the endpoint they're used with.  The
-+ * hardware's driver can add extra per-request data to the memory it returns,
-+ * which often avoids separate memory allocations (potential failures),
-+ * later when the request is queued.
-+ *
-+ * Request flags affect request handling, such as whether a zero length
-+ * packet is written (the "zero" flag), whether a short read should be
-+ * treated as an error (blocking request queue advance, the "short_not_ok"
-+ * flag), or hinting that an interrupt is not required (the "no_interrupt"
-+ * flag, for use with deep request queues).
-+ *
-+ * Bulk endpoints can use any size buffers, and can also be used for interrupt
-+ * transfers. interrupt-only endpoints can be much less functional.
-+ */
-+	// NOTE this is analagous to 'struct urb' on the host side,
-+	// except that it's thinner and promotes more pre-allocation.
-+
-+struct usb_request {
-+	void			*buf;
-+	unsigned		length;
-+	dma_addr_t		dma;
-+
-+	unsigned		no_interrupt:1;
-+	unsigned		zero:1;
-+	unsigned		short_not_ok:1;
-+
-+	void			(*complete)(struct usb_ep *ep,
-+					struct usb_request *req);
-+	void			*context;
-+	struct list_head	list;
-+
-+	int			status;
-+	unsigned		actual;
-+};
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* endpoint-specific parts of the api to the usb controller hardware.
-+ * unlike the urb model, (de)multiplexing layers are not required.
-+ * (so this api could slash overhead if used on the host side...)
-+ *
-+ * note that device side usb controllers commonly differ in how many
-+ * endpoints they support, as well as their capabilities.
-+ */
-+struct usb_ep_ops {
-+	int (*enable) (struct usb_ep *ep,
-+		const struct usb_endpoint_descriptor *desc);
-+	int (*disable) (struct usb_ep *ep);
-+
-+	struct usb_request *(*alloc_request) (struct usb_ep *ep,
-+		int gfp_flags);
-+	void (*free_request) (struct usb_ep *ep, struct usb_request *req);
-+
-+	void *(*alloc_buffer) (struct usb_ep *ep, unsigned bytes,
-+		dma_addr_t *dma, int gfp_flags);
-+	void (*free_buffer) (struct usb_ep *ep, void *buf, dma_addr_t dma,
-+		unsigned bytes);
-+	// NOTE:  on 2.6, drivers may also use dma_map() and
-+	// dma_sync_single_*() to directly manage dma overhead. 
-+
-+	int (*queue) (struct usb_ep *ep, struct usb_request *req,
-+		int gfp_flags);
-+	int (*dequeue) (struct usb_ep *ep, struct usb_request *req);
-+
-+	int (*set_halt) (struct usb_ep *ep, int value);
-+	int (*fifo_status) (struct usb_ep *ep);
-+	void (*fifo_flush) (struct usb_ep *ep);
-+};
-+
-+/**
-+ * struct usb_ep - device side representation of USB endpoint
-+ * @name:identifier for the endpoint, such as "ep-a" or "ep9in-bulk"
-+ * @ops: Function pointers used to access hardware-specific operations.
-+ * @ep_list:the gadget's ep_list holds all of its endpoints
-+ * @maxpacket:The maximum packet size used on this endpoint.  The initial
-+ *	value can sometimes be reduced (hardware allowing), according to
-+ *      the endpoint descriptor used to configure the endpoint.
-+ * @driver_data:for use by the gadget driver.  all other fields are
-+ * 	read-only to gadget drivers.
-+ *
-+ * the bus controller driver lists all the general purpose endpoints in
-+ * gadget->ep_list.  the control endpoint (gadget->ep0) is not in that list,
-+ * and is accessed only in response to a driver setup() callback.
-+ */
-+struct usb_ep {
-+	void			*driver_data;
-+
-+	const char		*name;
-+	const struct usb_ep_ops	*ops;
-+	struct list_head	ep_list;
-+	unsigned		maxpacket:16;
-+};
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/**
-+ * usb_ep_enable - configure endpoint, making it usable
-+ * @ep:the endpoint being configured.  may not be the endpoint named "ep0".
-+ * 	drivers discover endpoints through the ep_list of a usb_gadget.
-+ * @desc:descriptor for desired behavior.  caller guarantees this pointer
-+ * 	remains valid until the endpoint is disabled; the data byte order
-+ * 	is little-endian (usb-standard).
-+ *
-+ * when configurations are set, or when interface settings change, the driver
-+ * will enable or disable the relevant endpoints.  while it is enabled, an
-+ * endpoint may be used for i/o until the driver receives a disconnect() from
-+ * the host or until the endpoint is disabled.
-+ *
-+ * the ep0 implementation (which calls this routine) must ensure that the
-+ * hardware capabilities of each endpoint match the descriptor provided
-+ * for it.  for example, an endpoint named "ep2in-bulk" would be usable
-+ * for interrupt transfers as well as bulk, but it likely couldn't be used
-+ * for iso transfers or for endpoint 14.  some endpoints are fully
-+ * configurable, with more generic names like "ep-a".  (remember that for
-+ * USB, "in" means "towards the USB master".)
-+ *
-+ * returns zero, or a negative error code.
-+ */
-+static inline int
-+usb_ep_enable (struct usb_ep *ep, const struct usb_endpoint_descriptor *desc)
-+{
-+	return ep->ops->enable (ep, desc);
-+}
-+
-+/**
-+ * usb_ep_disable - endpoint is no longer usable
-+ * @ep:the endpoint being unconfigured.  may not be the endpoint named "ep0".
-+ *
-+ * no other task may be using this endpoint when this is called.
-+ * any pending and uncompleted requests will complete with status
-+ * indicating disconnect (-ESHUTDOWN) before this call returns.
-+ * gadget drivers must call usb_ep_enable() again before queueing
-+ * requests to the endpoint.
-+ *
-+ * returns zero, or a negative error code.
-+ */
-+static inline int
-+usb_ep_disable (struct usb_ep *ep)
-+{
-+	return ep->ops->disable (ep);
-+}
-+
-+/**
-+ * usb_ep_alloc_request - allocate a request object to use with this endpoint
-+ * @ep:the endpoint to be used with with the request
-+ * @gfp_flags:GFP_* flags to use
-+ *
-+ * Request objects must be allocated with this call, since they normally
-+ * need controller-specific setup and may even need endpoint-specific
-+ * resources such as allocation of DMA descriptors.
-+ * Requests may be submitted with usb_ep_queue(), and receive a single
-+ * completion callback.  Free requests with usb_ep_free_request(), when
-+ * they are no longer needed.
-+ *
-+ * Returns the request, or null if one could not be allocated.
-+ */
-+static inline struct usb_request *
-+usb_ep_alloc_request (struct usb_ep *ep, int gfp_flags)
-+{
-+	return ep->ops->alloc_request (ep, gfp_flags);
-+}
-+
-+/**
-+ * usb_ep_free_request - frees a request object
-+ * @ep:the endpoint associated with the request
-+ * @req:the request being freed
-+ *
-+ * Reverses the effect of usb_ep_alloc_request().
-+ * Caller guarantees the request is not queued, and that it will
-+ * no longer be requeued (or otherwise used).
-+ */
-+static inline void
-+usb_ep_free_request (struct usb_ep *ep, struct usb_request *req)
-+{
-+	ep->ops->free_request (ep, req);
-+}
-+
-+/**
-+ * usb_ep_alloc_buffer - allocate an I/O buffer
-+ * @ep:the endpoint associated with the buffer
-+ * @len:length of the desired buffer
-+ * @dma:pointer to the buffer's DMA address; must be valid
-+ * @gfp_flags:GFP_* flags to use
-+ *
-+ * Returns a new buffer, or null if one could not be allocated.
-+ * The buffer is suitably aligned for dma, if that endpoint uses DMA,
-+ * and the caller won't have to care about dma-inconsistency
-+ * or any hidden "bounce buffer" mechanism.  No additional per-request
-+ * DMA mapping will be required for such buffers.
-+ * Free it later with usb_ep_free_buffer().
-+ *
-+ * You don't need to use this call to allocate I/O buffers unless you
-+ * want to make sure drivers don't incur costs for such "bounce buffer"
-+ * copies or per-request DMA mappings.
-+ */
-+static inline void *
-+usb_ep_alloc_buffer (struct usb_ep *ep, unsigned len, dma_addr_t *dma,
-+	int gfp_flags)
-+{
-+	return ep->ops->alloc_buffer (ep, len, dma, gfp_flags);
-+}
-+
-+/**
-+ * usb_ep_free_buffer - frees an i/o buffer
-+ * @ep:the endpoint associated with the buffer
-+ * @buf:CPU view address of the buffer
-+ * @dma:the buffer's DMA address
-+ * @len:length of the buffer
-+ *
-+ * reverses the effect of usb_ep_alloc_buffer().
-+ * caller guarantees the buffer will no longer be accessed
-+ */
-+static inline void
-+usb_ep_free_buffer (struct usb_ep *ep, void *buf, dma_addr_t dma, unsigned len)
-+{
-+	ep->ops->free_buffer (ep, buf, dma, len);
-+}
-+
-+/**
-+ * usb_ep_queue - queues (submits) an I/O request to an endpoint.
-+ * @ep:the endpoint associated with the request
-+ * @req:the request being submitted
-+ * @gfp_flags: GFP_* flags to use in case the lower level driver couldn't
-+ * 	pre-allocate all necessary memory with the request.
-+ *
-+ * This tells the device controller to perform the specified request through
-+ * that endpoint (reading or writing a buffer).  When the request completes,
-+ * including being canceled by usb_ep_dequeue(), the request's completion
-+ * routine is called to return the request to the driver.  Any endpoint
-+ * (except control endpoints like ep0) may have more than one transfer
-+ * request queued; they complete in FIFO order.  Once a gadget driver
-+ * submits a request, that request may not be examined or modified until it
-+ * is given back to that driver through the completion callback.
-+ *
-+ * Each request is turned into one or more packets.  The controller driver
-+ * never merges adjacent requests into the same packet.  OUT transfers
-+ * will sometimes use data that's already buffered in the hardware.
-+ * Drivers can rely on the fact that the first byte of the request's buffer
-+ * always corresponds to the first byte of some USB packet, for both
-+ * IN and OUT transfers.
-+ *
-+ * Bulk endpoints can queue any amount of data; the transfer is packetized
-+ * automatically.  The last packet will be short if the request doesn't fill it
-+ * out completely.  Zero length packets (ZLPs) should be avoided in portable
-+ * protocols since not all usb hardware can successfully handle zero length
-+ * packets.  (ZLPs may be explicitly written, and may be implicitly written if
-+ * the request 'zero' flag is set.)  Bulk endpoints may also be used
-+ * for interrupt transfers; but the reverse is not true, and some endpoints
-+ * won't support every interrupt transfer.  (Such as 768 byte packets.)
-+ *
-+ * Interrupt-only endpoints are less functional than bulk endpoints, for
-+ * example by not supporting queueing or not handling buffers that are
-+ * larger than the endpoint's maxpacket size.  They may also treat data
-+ * toggle differently.
-+ *
-+ * Control endpoints ... after getting a setup() callback, the driver queues
-+ * one response (even if it would be zero length).  That enables the
-+ * status ack, after transfering data as specified in the response.  Setup
-+ * functions may return negative error codes to generate protocol stalls.
-+ * (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.
-+ *
-+ * For periodic endpoints, like interrupt or isochronous ones, the usb host
-+ * arranges to poll once per interval, and the gadget driver usually will
-+ * have queued some data to transfer at that time.
-+ *
-+ * Returns zero, or a negative error code.  Endpoints that are not enabled
-+ * report errors; errors will also be
-+ * reported when the usb peripheral is disconnected.
-+ */
-+static inline int
-+usb_ep_queue (struct usb_ep *ep, struct usb_request *req, int gfp_flags)
-+{
-+	return ep->ops->queue (ep, req, gfp_flags);
-+}
-+
-+/**
-+ * usb_ep_dequeue - dequeues (cancels, unlinks) an I/O request from an endpoint
-+ * @ep:the endpoint associated with the request
-+ * @req:the request being canceled
-+ *
-+ * if the request is still active on the endpoint, it is dequeued and its
-+ * completion routine is called (with status -ECONNRESET); else a negative
-+ * error code is returned.
-+ *
-+ * note that some hardware can't clear out write fifos (to unlink the request
-+ * at the head of the queue) except as part of disconnecting from usb.  such
-+ * restrictions prevent drivers from supporting configuration changes,
-+ * even to configuration zero (a "chapter 9" requirement).
-+ */
-+static inline int usb_ep_dequeue (struct usb_ep *ep, struct usb_request *req)
-+{
-+	return ep->ops->dequeue (ep, req);
-+}
-+
-+/**
-+ * usb_ep_set_halt - sets the endpoint halt feature.
-+ * @ep: the non-isochronous endpoint being stalled
-+ *
-+ * Use this to stall an endpoint, perhaps as an error report.
-+ * Except for control endpoints,
-+ * the endpoint stays halted (will not stream any data) until the host
-+ * clears this feature; drivers may need to empty the endpoint's request
-+ * queue first, to make sure no inappropriate transfers happen.
-+ *
-+ * Note that while an endpoint CLEAR_FEATURE will be invisible to the
-+ * gadget driver, a SET_INTERFACE will not be.  To reset endpoints for the
-+ * current altsetting, see usb_ep_clear_halt().  When switching altsettings,
-+ * it's simplest to use usb_ep_enable() or usb_ep_disable() for the endpoints.
-+ *
-+ * Returns zero, or a negative error code.  On success, this call sets
-+ * underlying hardware state that blocks data transfers.
-+ * Attempts to halt IN endpoints will fail (returning -EAGAIN) if any
-+ * transfer requests are still queued, or if the controller hardware
-+ * (usually a FIFO) still holds bytes that the host hasn't collected.
-+ */
-+static inline int
-+usb_ep_set_halt (struct usb_ep *ep)
-+{
-+	return ep->ops->set_halt (ep, 1);
-+}
-+
-+/**
-+ * usb_ep_clear_halt - clears endpoint halt, and resets toggle
-+ * @ep:the bulk or interrupt endpoint being reset
-+ *
-+ * Use this when responding to the standard usb "set interface" request,
-+ * for endpoints that aren't reconfigured, after clearing any other state
-+ * in the endpoint's i/o queue.
-+ *
-+ * Returns zero, or a negative error code.  On success, this call clears
-+ * the underlying hardware state reflecting endpoint halt and data toggle.
-+ * Note that some hardware can't support this request (like pxa2xx_udc),
-+ * and accordingly can't correctly implement interface altsettings.
-+ */
-+static inline int
-+usb_ep_clear_halt (struct usb_ep *ep)
-+{
-+	return ep->ops->set_halt (ep, 0);
-+}
-+
-+/**
-+ * usb_ep_fifo_status - returns number of bytes in fifo, or error
-+ * @ep: the endpoint whose fifo status is being checked.
-+ *
-+ * FIFO endpoints may have "unclaimed data" in them in certain cases,
-+ * such as after aborted transfers.  Hosts may not have collected all
-+ * the IN data written by the gadget driver (and reported by a request
-+ * completion).  The gadget driver may not have collected all the data
-+ * written OUT to it by the host.  Drivers that need precise handling for
-+ * fault reporting or recovery may need to use this call.
-+ *
-+ * This returns the number of such bytes in the fifo, or a negative
-+ * errno if the endpoint doesn't use a FIFO or doesn't support such
-+ * precise handling.
-+ */
-+static inline int
-+usb_ep_fifo_status (struct usb_ep *ep)
-+{
-+	if (ep->ops->fifo_status)
-+		return ep->ops->fifo_status (ep);
-+	else
-+		return -EOPNOTSUPP;
-+}
-+
-+/**
-+ * usb_ep_fifo_flush - flushes contents of a fifo
-+ * @ep: the endpoint whose fifo is being flushed.
-+ *
-+ * This call may be used to flush the "unclaimed data" that may exist in
-+ * an endpoint fifo after abnormal transaction terminations.  The call
-+ * must never be used except when endpoint is not being used for any
-+ * protocol translation.
-+ */
-+static inline void
-+usb_ep_fifo_flush (struct usb_ep *ep)
-+{
-+	if (ep->ops->fifo_flush)
-+		ep->ops->fifo_flush (ep);
-+}
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+struct usb_gadget;
-+
-+/* the rest of the api to the controller hardware: device operations,
-+ * which don't involve endpoints (or i/o).
-+ */
-+struct usb_gadget_ops {
-+	int	(*get_frame)(struct usb_gadget *);
-+	int	(*wakeup)(struct usb_gadget *);
-+	int	(*set_selfpowered) (struct usb_gadget *, int is_selfpowered);
-+	int	(*vbus_session) (struct usb_gadget *, int is_active);
-+	int	(*vbus_draw) (struct usb_gadget *, unsigned mA);
-+	int	(*pullup) (struct usb_gadget *, int is_on);
-+	int	(*ioctl)(struct usb_gadget *,
-+				unsigned code, unsigned long param);
-+};
-+
-+/**
-+ * struct usb_gadget - represents a usb slave device
-+ * @ops: Function pointers used to access hardware-specific operations.
-+ * @ep0: Endpoint zero, used when reading or writing responses to
-+ * 	driver setup() requests
-+ * @ep_list: List of other endpoints supported by the device.
-+ * @speed: Speed of current connection to USB host.
-+ * @is_dualspeed: True if the controller supports both high and full speed
-+ *	operation.  If it does, the gadget driver must also support both.
-+ * @is_otg: True if the USB device port uses a Mini-AB jack, so that the
-+ *	gadget driver must provide a USB OTG descriptor.
-+ * @is_a_peripheral: False unless is_otg, the "A" end of a USB cable
-+ *	is in the Mini-AB jack, and HNP has been used to switch roles
-+ *	so that the "A" device currently acts as A-Peripheral, not A-Host.
-+ * @a_hnp_support: OTG device feature flag, indicating that the A-Host
-+ *	supports HNP at this port.
-+ * @a_alt_hnp_support: OTG device feature flag, indicating that the A-Host
-+ *	only supports HNP on a different root port.
-+ * @b_hnp_enable: OTG device feature flag, indicating that the A-Host
-+ *	enabled HNP support.
-+ * @name: Identifies the controller hardware type.  Used in diagnostics
-+ * 	and sometimes configuration.
-+ * @dev: Driver model state for this abstract device.
-+ *
-+ * Gadgets have a mostly-portable "gadget driver" implementing device
-+ * functions, handling all usb configurations and interfaces.  Gadget
-+ * drivers talk to hardware-specific code indirectly, through ops vectors.
-+ * That insulates the gadget driver from hardware details, and packages
-+ * the hardware endpoints through generic i/o queues.  The "usb_gadget"
-+ * and "usb_ep" interfaces provide that insulation from the hardware.
-+ *
-+ * Except for the driver data, all fields in this structure are
-+ * read-only to the gadget driver.  That driver data is part of the
-+ * "driver model" infrastructure in 2.6 (and later) kernels, and for
-+ * earlier systems is grouped in a similar structure that's not known
-+ * to the rest of the kernel.
-+ *
-+ * Values of the three OTG device feature flags are updated before the
-+ * setup() call corresponding to USB_REQ_SET_CONFIGURATION, and before
-+ * driver suspend() calls.  They are valid only when is_otg, and when the
-+ * device is acting as a B-Peripheral (so is_a_peripheral is false).
-+ */
-+struct usb_gadget {
-+	/* readonly to gadget driver */
-+	const struct usb_gadget_ops	*ops;
-+	struct usb_ep			*ep0;
-+	struct list_head		ep_list;	/* of usb_ep */
-+	enum usb_device_speed		speed;
-+	unsigned			is_dualspeed:1;
-+	unsigned			is_otg:1;
-+	unsigned			is_a_peripheral:1;
-+	unsigned			b_hnp_enable:1;
-+	unsigned			a_hnp_support:1;
-+	unsigned			a_alt_hnp_support:1;
-+	const char			*name;
-+
-+	struct __gadget_device {
-+		const char		*bus_id;
-+		void			*driver_data;
-+	} dev;
-+};
-+
-+static inline void set_gadget_data (struct usb_gadget *gadget, void *data)
-+	{ gadget->dev.driver_data = data; }
-+static inline void *get_gadget_data (struct usb_gadget *gadget)
-+	{ return gadget->dev.driver_data; }
-+
-+
-+/* iterates the non-control endpoints; 'tmp' is a struct usb_ep pointer */
-+#define gadget_for_each_ep(tmp,gadget) \
-+	list_for_each_entry(tmp, &(gadget)->ep_list, ep_list)
-+
-+#ifndef list_for_each_entry
-+/* not available in 2.4.18 */
-+#define list_for_each_entry(pos, head, member)				\
-+	for (pos = list_entry((head)->next, typeof(*pos), member),	\
-+		     prefetch(pos->member.next);			\
-+	     &pos->member != (head); 					\
-+	     pos = list_entry(pos->member.next, typeof(*pos), member),	\
-+		     prefetch(pos->member.next))
-+#endif
-+
-+
-+/**
-+ * usb_gadget_frame_number - returns the current frame number
-+ * @gadget: controller that reports the frame number
-+ *
-+ * Returns the usb frame number, normally eleven bits from a SOF packet,
-+ * or negative errno if this device doesn't support this capability.
-+ */
-+static inline int usb_gadget_frame_number (struct usb_gadget *gadget)
-+{
-+	return gadget->ops->get_frame (gadget);
-+}
-+
-+/**
-+ * usb_gadget_wakeup - tries to wake up the host connected to this gadget
-+ * @gadget: controller used to wake up the host
-+ *
-+ * Returns zero on success, else negative error code if the hardware
-+ * doesn't support such attempts, or its support has not been enabled
-+ * by the usb host.  Drivers must return device descriptors that report
-+ * their ability to support this, or hosts won't enable it.
-+ *
-+ * This may also try to use SRP to wake the host and start enumeration,
-+ * even if OTG isn't otherwise in use.  OTG devices may also start
-+ * remote wakeup even when hosts don't explicitly enable it.
-+ */
-+static inline int usb_gadget_wakeup (struct usb_gadget *gadget)
-+{
-+	if (!gadget->ops->wakeup)
-+		return -EOPNOTSUPP;
-+	return gadget->ops->wakeup (gadget);
-+}
-+
-+/**
-+ * usb_gadget_set_selfpowered - sets the device selfpowered feature.
-+ * @gadget:the device being declared as self-powered
-+ *
-+ * this affects the device status reported by the hardware driver
-+ * to reflect that it now has a local power supply.
-+ *
-+ * returns zero on success, else negative errno.
-+ */
-+static inline int
-+usb_gadget_set_selfpowered (struct usb_gadget *gadget)
-+{
-+	if (!gadget->ops->set_selfpowered)
-+		return -EOPNOTSUPP;
-+	return gadget->ops->set_selfpowered (gadget, 1);
-+}
-+
-+/**
-+ * usb_gadget_clear_selfpowered - clear the device selfpowered feature.
-+ * @gadget:the device being declared as bus-powered
-+ *
-+ * this affects the device status reported by the hardware driver.
-+ * some hardware may not support bus-powered operation, in which
-+ * case this feature's value can never change.
-+ *
-+ * returns zero on success, else negative errno.
-+ */
-+static inline int
-+usb_gadget_clear_selfpowered (struct usb_gadget *gadget)
-+{
-+	if (!gadget->ops->set_selfpowered)
-+		return -EOPNOTSUPP;
-+	return gadget->ops->set_selfpowered (gadget, 0);
-+}
-+
-+/**
-+ * usb_gadget_vbus_connect - Notify controller that VBUS is powered
-+ * @gadget:The device which now has VBUS power.
-+ *
-+ * This call is used by a driver for an external transceiver (or GPIO)
-+ * that detects a VBUS power session starting.  Common responses include
-+ * resuming the controller, activating the D+ (or D-) pullup to let the
-+ * host detect that a USB device is attached, and starting to draw power
-+ * (8mA or possibly more, especially after SET_CONFIGURATION).
-+ *
-+ * Returns zero on success, else negative errno.
-+ */
-+static inline int
-+usb_gadget_vbus_connect(struct usb_gadget *gadget)
-+{
-+	if (!gadget->ops->vbus_session)
-+		return -EOPNOTSUPP;
-+	return gadget->ops->vbus_session (gadget, 1);
-+}
-+
-+/**
-+ * usb_gadget_vbus_draw - constrain controller's VBUS power usage
-+ * @gadget:The device whose VBUS usage is being described
-+ * @mA:How much current to draw, in milliAmperes.  This should be twice
-+ *	the value listed in the configuration descriptor bMaxPower field.
-+ *
-+ * This call is used by gadget drivers during SET_CONFIGURATION calls,
-+ * reporting how much power the device may consume.  For example, this
-+ * could affect how quickly batteries are recharged.
-+ *
-+ * Returns zero on success, else negative errno.
-+ */
-+static inline int
-+usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA)
-+{
-+	if (!gadget->ops->vbus_draw)
-+		return -EOPNOTSUPP;
-+	return gadget->ops->vbus_draw (gadget, mA);
-+}
-+
-+/**
-+ * usb_gadget_vbus_disconnect - notify controller about VBUS session end
-+ * @gadget:the device whose VBUS supply is being described
-+ *
-+ * This call is used by a driver for an external transceiver (or GPIO)
-+ * that detects a VBUS power session ending.  Common responses include
-+ * reversing everything done in usb_gadget_vbus_connect().
-+ *
-+ * Returns zero on success, else negative errno.
-+ */
-+static inline int
-+usb_gadget_vbus_disconnect(struct usb_gadget *gadget)
-+{
-+	if (!gadget->ops->vbus_session)
-+		return -EOPNOTSUPP;
-+	return gadget->ops->vbus_session (gadget, 0);
-+}
-+
-+/**
-+ * usb_gadget_connect - software-controlled connect to USB host
-+ * @gadget:the peripheral being connected
-+ *
-+ * Enables the D+ (or potentially D-) pullup.  The host will start
-+ * enumerating this gadget when the pullup is active and a VBUS session
-+ * is active (the link is powered).  This pullup is always enabled unless
-+ * usb_gadget_disconnect() has been used to disable it.
-+ *
-+ * Returns zero on success, else negative errno.
-+ */
-+static inline int
-+usb_gadget_connect (struct usb_gadget *gadget)
-+{
-+	if (!gadget->ops->pullup)
-+		return -EOPNOTSUPP;
-+	return gadget->ops->pullup (gadget, 1);
-+}
-+
-+/**
-+ * usb_gadget_disconnect - software-controlled disconnect from USB host
-+ * @gadget:the peripheral being disconnected
-+ *
-+ * Disables the D+ (or potentially D-) pullup, which the host may see
-+ * as a disconnect (when a VBUS session is active).  Not all systems
-+ * support software pullup controls.
-+ *
-+ * This routine may be used during the gadget driver bind() call to prevent
-+ * the peripheral from ever being visible to the USB host, unless later
-+ * usb_gadget_connect() is called.  For example, user mode components may
-+ * need to be activated before the system can talk to hosts.
-+ *
-+ * Returns zero on success, else negative errno.
-+ */
-+static inline int
-+usb_gadget_disconnect (struct usb_gadget *gadget)
-+{
-+	if (!gadget->ops->pullup)
-+		return -EOPNOTSUPP;
-+	return gadget->ops->pullup (gadget, 0);
-+}
-+
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/**
-+ * struct usb_gadget_driver - driver for usb 'slave' devices
-+ * @function: String describing the gadget's function
-+ * @speed: Highest speed the driver handles.
-+ * @bind: Invoked when the driver is bound to a gadget, usually
-+ * 	after registering the driver.
-+ * 	At that point, ep0 is fully initialized, and ep_list holds
-+ * 	the currently-available endpoints.
-+ * 	Called in a context that permits sleeping.
-+ * @setup: Invoked for ep0 control requests that aren't handled by
-+ * 	the hardware level driver. Most calls must be handled by
-+ * 	the gadget driver, including descriptor and configuration
-+ * 	management.  The 16 bit members of the setup data are in
-+ * 	cpu order. Called in_interrupt; this may not sleep.  Driver
-+ *	queues a response to ep0, or returns negative to stall.
-+ * @disconnect: Invoked after all transfers have been stopped,
-+ * 	when the host is disconnected.  May be called in_interrupt; this
-+ * 	may not sleep.  Some devices can't detect disconnect, so this might
-+ *	not be called except as part of controller shutdown.
-+ * @unbind: Invoked when the driver is unbound from a gadget,
-+ * 	usually from rmmod (after a disconnect is reported).
-+ * 	Called in a context that permits sleeping.
-+ * @suspend: Invoked on USB suspend.  May be called in_interrupt.
-+ * @resume: Invoked on USB resume.  May be called in_interrupt.
-+ * @driver: Driver model state for this driver.
-+ *
-+ * Devices are disabled till a gadget driver successfully bind()s, which
-+ * means the driver will handle setup() requests needed to enumerate (and
-+ * meet "chapter 9" requirements) then do some useful work.
-+ *
-+ * If gadget->is_otg is true, the gadget driver must provide an OTG
-+ * descriptor during enumeration, or else fail the bind() call.  In such
-+ * cases, no USB traffic may flow until both bind() returns without
-+ * having called usb_gadget_disconnect(), and the USB host stack has
-+ * initialized.
-+ *
-+ * Drivers use hardware-specific knowledge to configure the usb hardware.
-+ * endpoint addressing is only one of several hardware characteristics that
-+ * are in descriptors the ep0 implementation returns from setup() calls.
-+ *
-+ * Except for ep0 implementation, most driver code shouldn't need change to
-+ * run on top of different usb controllers.  It'll use endpoints set up by
-+ * that ep0 implementation.
-+ *
-+ * The usb controller driver handles a few standard usb requests.  Those
-+ * include set_address, and feature flags for devices, interfaces, and
-+ * endpoints (the get_status, set_feature, and clear_feature requests).
-+ *
-+ * Accordingly, the driver's setup() callback must always implement all
-+ * get_descriptor requests, returning at least a device descriptor and
-+ * a configuration descriptor.  Drivers must make sure the endpoint
-+ * descriptors match any hardware constraints. Some hardware also constrains
-+ * other descriptors. (The pxa250 allows only configurations 1, 2, or 3).
-+ *
-+ * The driver's setup() callback must also implement set_configuration,
-+ * and should also implement set_interface, get_configuration, and
-+ * get_interface.  Setting a configuration (or interface) is where
-+ * endpoints should be activated or (config 0) shut down.
-+ *
-+ * (Note that only the default control endpoint is supported.  Neither
-+ * hosts nor devices generally support control traffic except to ep0.)
-+ *
-+ * Most devices will ignore USB suspend/resume operations, and so will
-+ * not provide those callbacks.  However, some may need to change modes
-+ * when the host is not longer directing those activities.  For example,
-+ * local controls (buttons, dials, etc) may need to be re-enabled since
-+ * the (remote) host can't do that any longer; or an error state might
-+ * be cleared, to make the device behave identically whether or not
-+ * power is maintained.
-+ */
-+struct usb_gadget_driver {
-+	char			*function;
-+	enum usb_device_speed	speed;
-+	int			(*bind)(struct usb_gadget *);
-+	void			(*unbind)(struct usb_gadget *);
-+	int			(*setup)(struct usb_gadget *,
-+					const struct usb_ctrlrequest *);
-+	void			(*disconnect)(struct usb_gadget *);
-+	void			(*suspend)(struct usb_gadget *);
-+	void			(*resume)(struct usb_gadget *);
-+
-+	// FIXME support safe rmmod
-+	struct __gadget_driver {
-+		const char	*name;
-+		void		*driver_data;
-+	} driver;
-+};
-+
-+
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* driver modules register and unregister, as usual.
-+ * these calls must be made in a context that can sleep.
-+ *
-+ * these will usually be implemented directly by the hardware-dependent
-+ * usb bus interface driver, which will only support a single driver.
-+ */
-+
-+/**
-+ * usb_gadget_register_driver - register a gadget driver
-+ * @driver:the driver being registered
-+ *
-+ * Call this in your gadget driver's module initialization function,
-+ * to tell the underlying usb controller driver about your driver.
-+ * The driver's bind() function will be called to bind it to a
-+ * gadget.  This function must be called in a context that can sleep.
-+ */
-+int usb_gadget_register_driver (struct usb_gadget_driver *driver);
-+
-+/**
-+ * usb_gadget_unregister_driver - unregister a gadget driver
-+ * @driver:the driver being unregistered
-+ *
-+ * Call this in your gadget driver's module cleanup function,
-+ * to tell the underlying usb controller that your driver is
-+ * going away.  If the controller is connected to a USB host,
-+ * it will first disconnect().  The driver is also requested
-+ * to unbind() and clean up any device state, before this procedure
-+ * finally returns.
-+ * This function must be called in a context that can sleep.
-+ */
-+int usb_gadget_unregister_driver (struct usb_gadget_driver *driver);
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* utility to simplify dealing with string descriptors */
-+
-+/**
-+ * struct usb_string - wraps a C string and its USB id
-+ * @id:the (nonzero) ID for this string
-+ * @s:the string, in UTF-8 encoding
-+ *
-+ * If you're using usb_gadget_get_string(), use this to wrap a string
-+ * together with its ID.
-+ */
-+struct usb_string {
-+	u8			id;
-+	const char		*s;
-+};
-+
-+/**
-+ * struct usb_gadget_strings - a set of USB strings in a given language
-+ * @language:identifies the strings' language (0x0409 for en-us)
-+ * @strings:array of strings with their ids
-+ *
-+ * If you're using usb_gadget_get_string(), use this to wrap all the
-+ * strings for a given language.
-+ */
-+struct usb_gadget_strings {
-+	u16			language;	/* 0x0409 for en-us */
-+	struct usb_string	*strings;
-+};
-+
-+/* put descriptor for string with that id into buf (buflen >= 256) */
-+int usb_gadget_get_string (struct usb_gadget_strings *table, int id, u8 *buf);
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* utility to simplify managing config descriptors */
-+
-+/* write vector of descriptors into buffer */
-+int usb_descriptor_fillbuf(void *, unsigned,
-+		const struct usb_descriptor_header **);
-+
-+/* build config descriptor from single descriptor vector */
-+int usb_gadget_config_buf(const struct usb_config_descriptor *config,
-+	void *buf, unsigned buflen, const struct usb_descriptor_header **desc);
-+
-+/*-------------------------------------------------------------------------*/
-+
-+/* utility wrapping a simple endpoint selection policy */
-+
-+extern struct usb_ep *usb_ep_autoconfig (struct usb_gadget *,
-+			struct usb_endpoint_descriptor *) __init;
-+
-+extern void usb_ep_autoconfig_reset (struct usb_gadget *) __init;
-+
-+#endif  /* __KERNEL__ */
-+
-+#endif	/* __LINUX_USB_GADGET_H */
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/include/linux/usb_gadgetfs.h kernel/include/linux/usb_gadgetfs.h
---- /tmp/kernel/include/linux/usb_gadgetfs.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/include/linux/usb_gadgetfs.h	2005-04-22 17:53:19.370549935 +0200
-@@ -0,0 +1,75 @@
-+
-+#include <asm/types.h>
-+#include <asm/ioctl.h>
-+
-+#include <linux/usb_ch9.h>
-+
-+/*
-+ * Filesystem based user-mode API to USB Gadget controller hardware
-+ *
-+ * Almost everything can be done with only read and write operations,
-+ * on endpoint files found in one directory.  They are configured by
-+ * writing descriptors, and then may be used for normal stream style
-+ * i/o requests.  When ep0 is configured, the device can enumerate;
-+ * when it's closed, the device disconnects from usb.
-+ *
-+ * Configuration and device descriptors get written to /dev/gadget/$CHIP,
-+ * which may then be used to read usb_gadgetfs_event structs.  The driver
-+ * may activate endpoints as it handles SET_CONFIGURATION setup events,
-+ * or earlier; writing endpoint descriptors to /dev/gadget/$ENDPOINT
-+ * then performing data transfers by reading or writing.
-+ */
-+
-+/*
-+ * Events are delivered on the ep0 file descriptor, if the user mode driver
-+ * reads from this file descriptor after writing the descriptors.  Don't
-+ * stop polling this descriptor, if you write that kind of driver.
-+ */
-+
-+enum usb_gadgetfs_event_type {
-+	GADGETFS_NOP = 0,
-+
-+	GADGETFS_CONNECT,
-+	GADGETFS_DISCONNECT,
-+	GADGETFS_SETUP,
-+	GADGETFS_SUSPEND,
-+	// and likely more !
-+};
-+
-+struct usb_gadgetfs_event {
-+	enum usb_gadgetfs_event_type	type;
-+	union {
-+		// NOP, DISCONNECT, SUSPEND: nothing
-+		// ... some hardware can't report disconnection
-+
-+		// CONNECT: just the speed
-+		enum usb_device_speed	speed;
-+
-+		// SETUP: packet; DATA phase i/o precedes next event
-+		// (setup.bmRequestType & USB_DIR_IN) flags direction 
-+		// ... includes SET_CONFIGURATION, SET_INTERFACE
-+		struct usb_ctrlrequest	setup;
-+	} u;
-+};
-+
-+
-+/* endpoint ioctls */
-+
-+/* IN transfers may be reported to the gadget driver as complete
-+ * 	when the fifo is loaded, before the host reads the data;
-+ * OUT transfers may be reported to the host's "client" driver as
-+ * 	complete when they're sitting in the FIFO unread.
-+ * THIS returns how many bytes are "unclaimed" in the endpoint fifo
-+ * (needed for precise fault handling, when the hardware allows it)
-+ */
-+#define	GADGETFS_FIFO_STATUS	_IO('g',1)
-+
-+/* discards any unclaimed data in the fifo. */
-+#define	GADGETFS_FIFO_FLUSH	_IO('g',2)
-+
-+/* resets endpoint halt+toggle; used to implement set_interface.
-+ * some hardware (like pxa2xx) can't support this.
-+ */
-+#define	GADGETFS_CLEAR_HALT	_IO('g',3)
-+
-+
-diff -x '*~' -x '.*' -r -N -u /tmp/kernel/include/linux/usb_scanner_ioctl.h kernel/include/linux/usb_scanner_ioctl.h
---- /tmp/kernel/include/linux/usb_scanner_ioctl.h	1970-01-01 01:00:00.000000000 +0100
-+++ kernel/include/linux/usb_scanner_ioctl.h	2005-04-22 17:53:19.372549610 +0200
-@@ -0,0 +1,9 @@
-+/* USB Scanner IOCTLS */
-+
-+/* read vendor and product IDs from the scanner */
-+#define SCANNER_IOCTL_VENDOR _IOR('U', 0x20, int)
-+#define SCANNER_IOCTL_PRODUCT _IOR('U', 0x21, int)
-+/* send/recv a control message to the scanner */
-+#define SCANNER_IOCTL_CTRLMSG _IOWR('U', 0x22, struct usb_ctrlrequest )
-+
-+