17 files changed, 5130 insertions, 54 deletions

diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index dd4cd5a51370..3219d137340a 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -297,13 +297,34 @@ config USB_S3C2410_DEBUG
 
 # musb builds in ../musb along with host support
 config USB_GADGET_MUSB_HDRC
-        boolean "Inventra HDRC USB Peripheral (TI, ...)"
+        boolean "Inventra HDRC USB Peripheral (TI, ADI, ...)"
         depends on USB_MUSB_HDRC && (USB_MUSB_PERIPHERAL || USB_MUSB_OTG)
         select USB_GADGET_DUALSPEED
         select USB_GADGET_SELECTED
         help
           This OTG-capable silicon IP is used in dual designs including
-          the TI DaVinci, OMAP 243x, OMAP 343x, and TUSB 6010.
+          the TI DaVinci, OMAP 243x, OMAP 343x, TUSB 6010, and ADI Blackfin
+
+config USB_GADGET_IMX
+        boolean "Freescale IMX USB Peripheral Controller"
+        depends on ARCH_MX1
+        help
+           Freescale's IMX series include an integrated full speed
+           USB 1.1 device controller.  The controller in the IMX series
+           is register-compatible.
+
+           It has Six 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 "imx_udc" and force all
+           gadget drivers to also be dynamically linked.
+
+config USB_IMX
+        tristate
+        depends on USB_GADGET_IMX
+        default USB_GADGET
+        select USB_GADGET_SELECTED
 
 config USB_GADGET_M66592
         boolean "Renesas M66592 USB Peripheral Controller"
@@ -377,6 +398,24 @@ config USB_FSL_QE
         default USB_GADGET
         select USB_GADGET_SELECTED
 
+config USB_GADGET_CI13XXX
+        boolean "MIPS USB CI13xxx"
+        depends on PCI
+        select USB_GADGET_DUALSPEED
+        help
+          MIPS USB IP core family device controller
+          Currently it only supports IP part number CI13412
+
+          Say "y" to link the driver statically, or "m" to build a
+          dynamically linked module called "ci13xxx_udc" and force all
+          gadget drivers to also be dynamically linked.
+
+config USB_CI13XXX
+        tristate
+        depends on USB_GADGET_CI13XXX
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
 config USB_GADGET_NET2280
         boolean "NetChip 228x"
         depends on PCI
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index bd4041b47dce..39a51d746cb7 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -10,6 +10,7 @@ obj-$(CONFIG_USB_NET2280)	+= net2280.o
 obj-$(CONFIG_USB_AMD5536UDC)    += amd5536udc.o
 obj-$(CONFIG_USB_PXA25X)        += pxa25x_udc.o
 obj-$(CONFIG_USB_PXA27X)        += pxa27x_udc.o
+obj-$(CONFIG_USB_IMX)           += imx_udc.o
 obj-$(CONFIG_USB_GOKU)          += goku_udc.o
 obj-$(CONFIG_USB_OMAP)          += omap_udc.o
 obj-$(CONFIG_USB_LH7A40X)       += lh7a40x_udc.o
@@ -19,6 +20,7 @@ obj-$(CONFIG_USB_ATMEL_USBA)	+= atmel_usba_udc.o
 obj-$(CONFIG_USB_FSL_USB2)      += fsl_usb2_udc.o
 obj-$(CONFIG_USB_M66592)        += m66592-udc.o
 obj-$(CONFIG_USB_FSL_QE)        += fsl_qe_udc.o
+obj-$(CONFIG_USB_CI13XXX)       += ci13xxx_udc.o
 
 #
 # USB gadget drivers
diff --git a/drivers/usb/gadget/ci13xxx_udc.c b/drivers/usb/gadget/ci13xxx_udc.c
new file mode 100644
index 000000000000..bebf911c7e5f
--- /dev/null
+++ b/drivers/usb/gadget/ci13xxx_udc.c
@@ -0,0 +1,2830 @@
+/*
+ * ci13xxx_udc.c - MIPS USB IP core family device controller
+ *
+ * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
+ *
+ * Author: David Lopo
+ *
+ * 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.
+ */
+
+/*
+ * Description: MIPS USB IP core family device controller
+ *              Currently it only supports IP part number CI13412
+ *
+ * This driver is composed of several blocks:
+ * - HW:     hardware interface
+ * - DBG:    debug facilities (optional)
+ * - UTIL:   utilities
+ * - ISR:    interrupts handling
+ * - ENDPT:  endpoint operations (Gadget API)
+ * - GADGET: gadget operations (Gadget API)
+ * - BUS:    bus glue code, bus abstraction layer
+ * - PCI:    PCI core interface and PCI resources (interrupts, memory...)
+ *
+ * Compile Options
+ * - CONFIG_USB_GADGET_DEBUG_FILES: enable debug facilities
+ * - STALL_IN:  non-empty bulk-in pipes cannot be halted
+ *              if defined mass storage compliance succeeds but with warnings
+ *              => case 4: Hi >  Dn
+ *              => case 5: Hi >  Di
+ *              => case 8: Hi <> Do
+ *              if undefined usbtest 13 fails
+ * - TRACE:     enable function tracing (depends on DEBUG)
+ *
+ * Main Features
+ * - Chapter 9 & Mass Storage Compliance with Gadget File Storage
+ * - Chapter 9 Compliance with Gadget Zero (STALL_IN undefined)
+ * - Normal & LPM support
+ *
+ * USBTEST Report
+ * - OK: 0-12, 13 (STALL_IN defined) & 14
+ * - Not Supported: 15 & 16 (ISO)
+ *
+ * TODO List
+ * - OTG
+ * - Isochronous & Interrupt Traffic
+ * - Handle requests which spawns into several TDs
+ * - GET_STATUS(device) - always reports 0
+ * - Gadget API (majority of optional features)
+ * - Suspend & Remote Wakeup
+ */
+#include <linux/device.h>
+#include <linux/dmapool.h>
+#include <linux/dma-mapping.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+#include "ci13xxx_udc.h"
+
+
+/******************************************************************************
+ * DEFINE
+ *****************************************************************************/
+/* ctrl register bank access */
+static DEFINE_SPINLOCK(udc_lock);
+
+/* driver name */
+#define UDC_DRIVER_NAME   "ci13xxx_udc"
+
+/* control endpoint description */
+static const struct usb_endpoint_descriptor
+ctrl_endpt_desc = {
+        .bLength         = USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType = USB_DT_ENDPOINT,
+
+        .bmAttributes    = USB_ENDPOINT_XFER_CONTROL,
+        .wMaxPacketSize  = cpu_to_le16(CTRL_PAYLOAD_MAX),
+};
+
+/* UDC descriptor */
+static struct ci13xxx *_udc;
+
+/* Interrupt statistics */
+#define ISR_MASK   0x1F
+static struct {
+        u32 test;
+        u32 ui;
+        u32 uei;
+        u32 pci;
+        u32 uri;
+        u32 sli;
+        u32 none;
+        struct {
+                u32 cnt;
+                u32 buf[ISR_MASK+1];
+                u32 idx;
+        } hndl;
+} isr_statistics;
+
+/**
+ * ffs_nr: find first (least significant) bit set
+ * @x: the word to search
+ *
+ * This function returns bit number (instead of position)
+ */
+static int ffs_nr(u32 x)
+{
+        int n = ffs(x);
+
+        return n ? n-1 : 32;
+}
+
+/******************************************************************************
+ * HW block
+ *****************************************************************************/
+/* register bank descriptor */
+static struct {
+        unsigned      lpm;    /* is LPM? */
+        void __iomem *abs;    /* bus map offset */
+        void __iomem *cap;    /* bus map offset + CAP offset + CAP data */
+        size_t        size;   /* bank size */
+} hw_bank;
+
+/* UDC register map */
+#define ABS_CAPLENGTH       (0x100UL)
+#define ABS_HCCPARAMS       (0x108UL)
+#define ABS_DCCPARAMS       (0x124UL)
+#define ABS_TESTMODE        (hw_bank.lpm ? 0x0FCUL : 0x138UL)
+/* offset to CAPLENTGH (addr + data) */
+#define CAP_USBCMD          (0x000UL)
+#define CAP_USBSTS          (0x004UL)
+#define CAP_USBINTR         (0x008UL)
+#define CAP_DEVICEADDR      (0x014UL)
+#define CAP_ENDPTLISTADDR   (0x018UL)
+#define CAP_PORTSC          (0x044UL)
+#define CAP_DEVLC           (0x0B4UL)
+#define CAP_USBMODE         (hw_bank.lpm ? 0x0C8UL : 0x068UL)
+#define CAP_ENDPTSETUPSTAT  (hw_bank.lpm ? 0x0D8UL : 0x06CUL)
+#define CAP_ENDPTPRIME      (hw_bank.lpm ? 0x0DCUL : 0x070UL)
+#define CAP_ENDPTFLUSH      (hw_bank.lpm ? 0x0E0UL : 0x074UL)
+#define CAP_ENDPTSTAT       (hw_bank.lpm ? 0x0E4UL : 0x078UL)
+#define CAP_ENDPTCOMPLETE   (hw_bank.lpm ? 0x0E8UL : 0x07CUL)
+#define CAP_ENDPTCTRL       (hw_bank.lpm ? 0x0ECUL : 0x080UL)
+#define CAP_LAST            (hw_bank.lpm ? 0x12CUL : 0x0C0UL)
+
+/* maximum number of enpoints: valid only after hw_device_reset() */
+static unsigned hw_ep_max;
+
+/**
+ * hw_ep_bit: calculates the bit number
+ * @num: endpoint number
+ * @dir: endpoint direction
+ *
+ * This function returns bit number
+ */
+static inline int hw_ep_bit(int num, int dir)
+{
+        return num + (dir ? 16 : 0);
+}
+
+/**
+ * hw_aread: reads from register bitfield
+ * @addr: address relative to bus map
+ * @mask: bitfield mask
+ *
+ * This function returns register bitfield data
+ */
+static u32 hw_aread(u32 addr, u32 mask)
+{
+        return ioread32(addr + hw_bank.abs) & mask;
+}
+
+/**
+ * hw_awrite: writes to register bitfield
+ * @addr: address relative to bus map
+ * @mask: bitfield mask
+ * @data: new data
+ */
+static void hw_awrite(u32 addr, u32 mask, u32 data)
+{
+        iowrite32(hw_aread(addr, ~mask) | (data & mask),
+                  addr + hw_bank.abs);
+}
+
+/**
+ * hw_cread: reads from register bitfield
+ * @addr: address relative to CAP offset plus content
+ * @mask: bitfield mask
+ *
+ * This function returns register bitfield data
+ */
+static u32 hw_cread(u32 addr, u32 mask)
+{
+        return ioread32(addr + hw_bank.cap) & mask;
+}
+
+/**
+ * hw_cwrite: writes to register bitfield
+ * @addr: address relative to CAP offset plus content
+ * @mask: bitfield mask
+ * @data: new data
+ */
+static void hw_cwrite(u32 addr, u32 mask, u32 data)
+{
+        iowrite32(hw_cread(addr, ~mask) | (data & mask),
+                  addr + hw_bank.cap);
+}
+
+/**
+ * hw_ctest_and_clear: tests & clears register bitfield
+ * @addr: address relative to CAP offset plus content
+ * @mask: bitfield mask
+ *
+ * This function returns register bitfield data
+ */
+static u32 hw_ctest_and_clear(u32 addr, u32 mask)
+{
+        u32 reg = hw_cread(addr, mask);
+
+        iowrite32(reg, addr + hw_bank.cap);
+        return reg;
+}
+
+/**
+ * hw_ctest_and_write: tests & writes register bitfield
+ * @addr: address relative to CAP offset plus content
+ * @mask: bitfield mask
+ * @data: new data
+ *
+ * This function returns register bitfield data
+ */
+static u32 hw_ctest_and_write(u32 addr, u32 mask, u32 data)
+{
+        u32 reg = hw_cread(addr, ~0);
+
+        iowrite32((reg & ~mask) | (data & mask), addr + hw_bank.cap);
+        return (reg & mask) >> ffs_nr(mask);
+}
+
+/**
+ * hw_device_reset: resets chip (execute without interruption)
+ * @base: register base address
+ *
+ * This function returns an error code
+ */
+static int hw_device_reset(void __iomem *base)
+{
+        u32 reg;
+
+        /* bank is a module variable */
+        hw_bank.abs = base;
+
+        hw_bank.cap = hw_bank.abs;
+        hw_bank.cap += ABS_CAPLENGTH;
+        hw_bank.cap += ioread8(hw_bank.cap);
+
+        reg = hw_aread(ABS_HCCPARAMS, HCCPARAMS_LEN) >> ffs_nr(HCCPARAMS_LEN);
+        hw_bank.lpm  = reg;
+        hw_bank.size = hw_bank.cap - hw_bank.abs;
+        hw_bank.size += CAP_LAST;
+        hw_bank.size /= sizeof(u32);
+
+        /* should flush & stop before reset */
+        hw_cwrite(CAP_ENDPTFLUSH, ~0, ~0);
+        hw_cwrite(CAP_USBCMD, USBCMD_RS, 0);
+
+        hw_cwrite(CAP_USBCMD, USBCMD_RST, USBCMD_RST);
+        while (hw_cread(CAP_USBCMD, USBCMD_RST))
+                udelay(10);             /* not RTOS friendly */
+
+        /* USBMODE should be configured step by step */
+        hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_IDLE);
+        hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_DEVICE);
+        hw_cwrite(CAP_USBMODE, USBMODE_SLOM, USBMODE_SLOM);  /* HW >= 2.3 */
+
+        if (hw_cread(CAP_USBMODE, USBMODE_CM) != USBMODE_CM_DEVICE) {
+                pr_err("cannot enter in device mode");
+                pr_err("lpm = %i", hw_bank.lpm);
+                return -ENODEV;
+        }
+
+        reg = hw_aread(ABS_DCCPARAMS, DCCPARAMS_DEN) >> ffs_nr(DCCPARAMS_DEN);
+        if (reg == 0 || reg > ENDPT_MAX)
+                return -ENODEV;
+
+        hw_ep_max = reg;   /* cache hw ENDPT_MAX */
+
+        /* setup lock mode ? */
+
+        /* ENDPTSETUPSTAT is '0' by default */
+
+        /* HCSPARAMS.bf.ppc SHOULD BE zero for device */
+
+        return 0;
+}
+
+/**
+ * hw_device_state: enables/disables interrupts & starts/stops device (execute
+ *                  without interruption)
+ * @dma: 0 => disable, !0 => enable and set dma engine
+ *
+ * This function returns an error code
+ */
+static int hw_device_state(u32 dma)
+{
+        if (dma) {
+                hw_cwrite(CAP_ENDPTLISTADDR, ~0, dma);
+                /* interrupt, error, port change, reset, sleep/suspend */
+                hw_cwrite(CAP_USBINTR, ~0,
+                             USBi_UI|USBi_UEI|USBi_PCI|USBi_URI|USBi_SLI);
+                hw_cwrite(CAP_USBCMD, USBCMD_RS, USBCMD_RS);
+        } else {
+                hw_cwrite(CAP_USBCMD, USBCMD_RS, 0);
+                hw_cwrite(CAP_USBINTR, ~0, 0);
+        }
+        return 0;
+}
+
+/**
+ * hw_ep_flush: flush endpoint fifo (execute without interruption)
+ * @num: endpoint number
+ * @dir: endpoint direction
+ *
+ * This function returns an error code
+ */
+static int hw_ep_flush(int num, int dir)
+{
+        int n = hw_ep_bit(num, dir);
+
+        do {
+                /* flush any pending transfer */
+                hw_cwrite(CAP_ENDPTFLUSH, BIT(n), BIT(n));
+                while (hw_cread(CAP_ENDPTFLUSH, BIT(n)))
+                        cpu_relax();
+        } while (hw_cread(CAP_ENDPTSTAT, BIT(n)));
+
+        return 0;
+}
+
+/**
+ * hw_ep_disable: disables endpoint (execute without interruption)
+ * @num: endpoint number
+ * @dir: endpoint direction
+ *
+ * This function returns an error code
+ */
+static int hw_ep_disable(int num, int dir)
+{
+        hw_ep_flush(num, dir);
+        hw_cwrite(CAP_ENDPTCTRL + num * sizeof(u32),
+                  dir ? ENDPTCTRL_TXE : ENDPTCTRL_RXE, 0);
+        return 0;
+}
+
+/**
+ * hw_ep_enable: enables endpoint (execute without interruption)
+ * @num:  endpoint number
+ * @dir:  endpoint direction
+ * @type: endpoint type
+ *
+ * This function returns an error code
+ */
+static int hw_ep_enable(int num, int dir, int type)
+{
+        u32 mask, data;
+
+        if (dir) {
+                mask  = ENDPTCTRL_TXT;  /* type    */
+                data  = type << ffs_nr(mask);
+
+                mask |= ENDPTCTRL_TXS;  /* unstall */
+                mask |= ENDPTCTRL_TXR;  /* reset data toggle */
+                data |= ENDPTCTRL_TXR;
+                mask |= ENDPTCTRL_TXE;  /* enable  */
+                data |= ENDPTCTRL_TXE;
+        } else {
+                mask  = ENDPTCTRL_RXT;  /* type    */
+                data  = type << ffs_nr(mask);
+
+                mask |= ENDPTCTRL_RXS;  /* unstall */
+                mask |= ENDPTCTRL_RXR;  /* reset data toggle */
+                data |= ENDPTCTRL_RXR;
+                mask |= ENDPTCTRL_RXE;  /* enable  */
+                data |= ENDPTCTRL_RXE;
+        }
+        hw_cwrite(CAP_ENDPTCTRL + num * sizeof(u32), mask, data);
+        return 0;
+}
+
+/**
+ * hw_ep_get_halt: return endpoint halt status
+ * @num: endpoint number
+ * @dir: endpoint direction
+ *
+ * This function returns 1 if endpoint halted
+ */
+static int hw_ep_get_halt(int num, int dir)
+{
+        u32 mask = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
+
+        return hw_cread(CAP_ENDPTCTRL + num * sizeof(u32), mask) ? 1 : 0;
+}
+
+/**
+ * hw_ep_is_primed: test if endpoint is primed (execute without interruption)
+ * @num:   endpoint number
+ * @dir:   endpoint direction
+ *
+ * This function returns true if endpoint primed
+ */
+static int hw_ep_is_primed(int num, int dir)
+{
+        u32 reg = hw_cread(CAP_ENDPTPRIME, ~0) | hw_cread(CAP_ENDPTSTAT, ~0);
+
+        return test_bit(hw_ep_bit(num, dir), (void *)&reg);
+}
+
+/**
+ * hw_test_and_clear_setup_status: test & clear setup status (execute without
+ *                                 interruption)
+ * @n: bit number (endpoint)
+ *
+ * This function returns setup status
+ */
+static int hw_test_and_clear_setup_status(int n)
+{
+        return hw_ctest_and_clear(CAP_ENDPTSETUPSTAT, BIT(n));
+}
+
+/**
+ * hw_ep_prime: primes endpoint (execute without interruption)
+ * @num:     endpoint number
+ * @dir:     endpoint direction
+ * @is_ctrl: true if control endpoint
+ *
+ * This function returns an error code
+ */
+static int hw_ep_prime(int num, int dir, int is_ctrl)
+{
+        int n = hw_ep_bit(num, dir);
+
+        /* the caller should flush first */
+        if (hw_ep_is_primed(num, dir))
+                return -EBUSY;
+
+        if (is_ctrl && dir == RX && hw_cread(CAP_ENDPTSETUPSTAT, BIT(num)))
+                return -EAGAIN;
+
+        hw_cwrite(CAP_ENDPTPRIME, BIT(n), BIT(n));
+
+        while (hw_cread(CAP_ENDPTPRIME, BIT(n)))
+                cpu_relax();
+        if (is_ctrl && dir == RX  && hw_cread(CAP_ENDPTSETUPSTAT, BIT(num)))
+                return -EAGAIN;
+
+        /* status shoult be tested according with manual but it doesn't work */
+        return 0;
+}
+
+/**
+ * hw_ep_set_halt: configures ep halt & resets data toggle after clear (execute
+ *                 without interruption)
+ * @num:   endpoint number
+ * @dir:   endpoint direction
+ * @value: true => stall, false => unstall
+ *
+ * This function returns an error code
+ */
+static int hw_ep_set_halt(int num, int dir, int value)
+{
+        if (value != 0 && value != 1)
+                return -EINVAL;
+
+        do {
+                u32 addr = CAP_ENDPTCTRL + num * sizeof(u32);
+                u32 mask_xs = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
+                u32 mask_xr = dir ? ENDPTCTRL_TXR : ENDPTCTRL_RXR;
+
+                /* data toggle - reserved for EP0 but it's in ESS */
+                hw_cwrite(addr, mask_xs|mask_xr, value ? mask_xs : mask_xr);
+
+        } while (value != hw_ep_get_halt(num, dir));
+
+        return 0;
+}
+
+/**
+ * hw_intr_clear: disables interrupt & clears interrupt status (execute without
+ *                interruption)
+ * @n: interrupt bit
+ *
+ * This function returns an error code
+ */
+static int hw_intr_clear(int n)
+{
+        if (n >= REG_BITS)
+                return -EINVAL;
+
+        hw_cwrite(CAP_USBINTR, BIT(n), 0);
+        hw_cwrite(CAP_USBSTS,  BIT(n), BIT(n));
+        return 0;
+}
+
+/**
+ * hw_intr_force: enables interrupt & forces interrupt status (execute without
+ *                interruption)
+ * @n: interrupt bit
+ *
+ * This function returns an error code
+ */
+static int hw_intr_force(int n)
+{
+        if (n >= REG_BITS)
+                return -EINVAL;
+
+        hw_awrite(ABS_TESTMODE, TESTMODE_FORCE, TESTMODE_FORCE);
+        hw_cwrite(CAP_USBINTR,  BIT(n), BIT(n));
+        hw_cwrite(CAP_USBSTS,   BIT(n), BIT(n));
+        hw_awrite(ABS_TESTMODE, TESTMODE_FORCE, 0);
+        return 0;
+}
+
+/**
+ * hw_is_port_high_speed: test if port is high speed
+ *
+ * This function returns true if high speed port
+ */
+static int hw_port_is_high_speed(void)
+{
+        return hw_bank.lpm ? hw_cread(CAP_DEVLC, DEVLC_PSPD) :
+                hw_cread(CAP_PORTSC, PORTSC_HSP);
+}
+
+/**
+ * hw_port_test_get: reads port test mode value
+ *
+ * This function returns port test mode value
+ */
+static u8 hw_port_test_get(void)
+{
+        return hw_cread(CAP_PORTSC, PORTSC_PTC) >> ffs_nr(PORTSC_PTC);
+}
+
+/**
+ * hw_port_test_set: writes port test mode (execute without interruption)
+ * @mode: new value
+ *
+ * This function returns an error code
+ */
+static int hw_port_test_set(u8 mode)
+{
+        const u8 TEST_MODE_MAX = 7;
+
+        if (mode > TEST_MODE_MAX)
+                return -EINVAL;
+
+        hw_cwrite(CAP_PORTSC, PORTSC_PTC, mode << ffs_nr(PORTSC_PTC));
+        return 0;
+}
+
+/**
+ * hw_read_intr_enable: returns interrupt enable register
+ *
+ * This function returns register data
+ */
+static u32 hw_read_intr_enable(void)
+{
+        return hw_cread(CAP_USBINTR, ~0);
+}
+
+/**
+ * hw_read_intr_status: returns interrupt status register
+ *
+ * This function returns register data
+ */
+static u32 hw_read_intr_status(void)
+{
+        return hw_cread(CAP_USBSTS, ~0);
+}
+
+/**
+ * hw_register_read: reads all device registers (execute without interruption)
+ * @buf:  destination buffer
+ * @size: buffer size
+ *
+ * This function returns number of registers read
+ */
+static size_t hw_register_read(u32 *buf, size_t size)
+{
+        unsigned i;
+
+        if (size > hw_bank.size)
+                size = hw_bank.size;
+
+        for (i = 0; i < size; i++)
+                buf[i] = hw_aread(i * sizeof(u32), ~0);
+
+        return size;
+}
+
+/**
+ * hw_register_write: writes to register
+ * @addr: register address
+ * @data: register value
+ *
+ * This function returns an error code
+ */
+static int hw_register_write(u16 addr, u32 data)
+{
+        /* align */
+        addr /= sizeof(u32);
+
+        if (addr >= hw_bank.size)
+                return -EINVAL;
+
+        /* align */
+        addr *= sizeof(u32);
+
+        hw_awrite(addr, ~0, data);
+        return 0;
+}
+
+/**
+ * hw_test_and_clear_complete: test & clear complete status (execute without
+ *                             interruption)
+ * @n: bit number (endpoint)
+ *
+ * This function returns complete status
+ */
+static int hw_test_and_clear_complete(int n)
+{
+        return hw_ctest_and_clear(CAP_ENDPTCOMPLETE, BIT(n));
+}
+
+/**
+ * hw_test_and_clear_intr_active: test & clear active interrupts (execute
+ *                                without interruption)
+ *
+ * This function returns active interrutps
+ */
+static u32 hw_test_and_clear_intr_active(void)
+{
+        u32 reg = hw_read_intr_status() & hw_read_intr_enable();
+
+        hw_cwrite(CAP_USBSTS, ~0, reg);
+        return reg;
+}
+
+/**
+ * hw_test_and_clear_setup_guard: test & clear setup guard (execute without
+ *                                interruption)
+ *
+ * This function returns guard value
+ */
+static int hw_test_and_clear_setup_guard(void)
+{
+        return hw_ctest_and_write(CAP_USBCMD, USBCMD_SUTW, 0);
+}
+
+/**
+ * hw_test_and_set_setup_guard: test & set setup guard (execute without
+ *                              interruption)
+ *
+ * This function returns guard value
+ */
+static int hw_test_and_set_setup_guard(void)
+{
+        return hw_ctest_and_write(CAP_USBCMD, USBCMD_SUTW, USBCMD_SUTW);
+}
+
+/**
+ * hw_usb_set_address: configures USB address (execute without interruption)
+ * @value: new USB address
+ *
+ * This function returns an error code
+ */
+static int hw_usb_set_address(u8 value)
+{
+        /* advance */
+        hw_cwrite(CAP_DEVICEADDR, DEVICEADDR_USBADR | DEVICEADDR_USBADRA,
+                  value << ffs_nr(DEVICEADDR_USBADR) | DEVICEADDR_USBADRA);
+        return 0;
+}
+
+/**
+ * hw_usb_reset: restart device after a bus reset (execute without
+ *               interruption)
+ *
+ * This function returns an error code
+ */
+static int hw_usb_reset(void)
+{
+        hw_usb_set_address(0);
+
+        /* ESS flushes only at end?!? */
+        hw_cwrite(CAP_ENDPTFLUSH,    ~0, ~0);   /* flush all EPs */
+
+        /* clear setup token semaphores */
+        hw_cwrite(CAP_ENDPTSETUPSTAT, 0,  0);   /* writes its content */
+
+        /* clear complete status */
+        hw_cwrite(CAP_ENDPTCOMPLETE,  0,  0);   /* writes its content */
+
+        /* wait until all bits cleared */
+        while (hw_cread(CAP_ENDPTPRIME, ~0))
+                udelay(10);             /* not RTOS friendly */
+
+        /* reset all endpoints ? */
+
+        /* reset internal status and wait for further instructions
+           no need to verify the port reset status (ESS does it) */
+
+        return 0;
+}
+
+/******************************************************************************
+ * DBG block
+ *****************************************************************************/
+/**
+ * show_device: prints information about device capabilities and status
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_device(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        struct usb_gadget *gadget = &udc->gadget;
+        int n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        n += scnprintf(buf + n, PAGE_SIZE - n, "speed             = %d\n",
+                       gadget->speed);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "is_dualspeed      = %d\n",
+                       gadget->is_dualspeed);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "is_otg            = %d\n",
+                       gadget->is_otg);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "is_a_peripheral   = %d\n",
+                       gadget->is_a_peripheral);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "b_hnp_enable      = %d\n",
+                       gadget->b_hnp_enable);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "a_hnp_support     = %d\n",
+                       gadget->a_hnp_support);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "a_alt_hnp_support = %d\n",
+                       gadget->a_alt_hnp_support);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "name              = %s\n",
+                       (gadget->name ? gadget->name : ""));
+
+        return n;
+}
+static DEVICE_ATTR(device, S_IRUSR, show_device, NULL);
+
+/**
+ * show_driver: prints information about attached gadget (if any)
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_driver(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        struct usb_gadget_driver *driver = udc->driver;
+        int n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        if (driver == NULL)
+                return scnprintf(buf, PAGE_SIZE,
+                                 "There is no gadget attached!\n");
+
+        n += scnprintf(buf + n, PAGE_SIZE - n, "function  = %s\n",
+                       (driver->function ? driver->function : ""));
+        n += scnprintf(buf + n, PAGE_SIZE - n, "max speed = %d\n",
+                       driver->speed);
+
+        return n;
+}
+static DEVICE_ATTR(driver, S_IRUSR, show_driver, NULL);
+
+/* Maximum event message length */
+#define DBG_DATA_MSG   64UL
+
+/* Maximum event messages */
+#define DBG_DATA_MAX   128UL
+
+/* Event buffer descriptor */
+static struct {
+        char     (buf[DBG_DATA_MAX])[DBG_DATA_MSG];   /* buffer */
+        unsigned idx;   /* index */
+        unsigned tty;   /* print to console? */
+        rwlock_t lck;   /* lock */
+} dbg_data = {
+        .idx = 0,
+        .tty = 0,
+        .lck = __RW_LOCK_UNLOCKED(lck)
+};
+
+/**
+ * dbg_dec: decrements debug event index
+ * @idx: buffer index
+ */
+static void dbg_dec(unsigned *idx)
+{
+        *idx = (*idx - 1) & (DBG_DATA_MAX-1);
+}
+
+/**
+ * dbg_inc: increments debug event index
+ * @idx: buffer index
+ */
+static void dbg_inc(unsigned *idx)
+{
+        *idx = (*idx + 1) & (DBG_DATA_MAX-1);
+}
+
+/**
+ * dbg_print:  prints the common part of the event
+ * @addr:   endpoint address
+ * @name:   event name
+ * @status: status
+ * @extra:  extra information
+ */
+static void dbg_print(u8 addr, const char *name, int status, const char *extra)
+{
+        struct timeval tval;
+        unsigned int stamp;
+        unsigned long flags;
+
+        write_lock_irqsave(&dbg_data.lck, flags);
+
+        do_gettimeofday(&tval);
+        stamp = tval.tv_sec & 0xFFFF;   /* 2^32 = 4294967296. Limit to 4096s */
+        stamp = stamp * 1000000 + tval.tv_usec;
+
+        scnprintf(dbg_data.buf[dbg_data.idx], DBG_DATA_MSG,
+                  "%04X\t» %02X %-7.7s %4i «\t%s\n",
+                  stamp, addr, name, status, extra);
+
+        dbg_inc(&dbg_data.idx);
+
+        write_unlock_irqrestore(&dbg_data.lck, flags);
+
+        if (dbg_data.tty != 0)
+                pr_notice("%04X\t» %02X %-7.7s %4i «\t%s\n",
+                          stamp, addr, name, status, extra);
+}
+
+/**
+ * dbg_done: prints a DONE event
+ * @addr:   endpoint address
+ * @td:     transfer descriptor
+ * @status: status
+ */
+static void dbg_done(u8 addr, const u32 token, int status)
+{
+        char msg[DBG_DATA_MSG];
+
+        scnprintf(msg, sizeof(msg), "%d %02X",
+                  (int)(token & TD_TOTAL_BYTES) >> ffs_nr(TD_TOTAL_BYTES),
+                  (int)(token & TD_STATUS)      >> ffs_nr(TD_STATUS));
+        dbg_print(addr, "DONE", status, msg);
+}
+
+/**
+ * dbg_event: prints a generic event
+ * @addr:   endpoint address
+ * @name:   event name
+ * @status: status
+ */
+static void dbg_event(u8 addr, const char *name, int status)
+{
+        if (name != NULL)
+                dbg_print(addr, name, status, "");
+}
+
+/*
+ * dbg_queue: prints a QUEUE event
+ * @addr:   endpoint address
+ * @req:    USB request
+ * @status: status
+ */
+static void dbg_queue(u8 addr, const struct usb_request *req, int status)
+{
+        char msg[DBG_DATA_MSG];
+
+        if (req != NULL) {
+                scnprintf(msg, sizeof(msg),
+                          "%d %d", !req->no_interrupt, req->length);
+                dbg_print(addr, "QUEUE", status, msg);
+        }
+}
+
+/**
+ * dbg_setup: prints a SETUP event
+ * @addr: endpoint address
+ * @req:  setup request
+ */
+static void dbg_setup(u8 addr, const struct usb_ctrlrequest *req)
+{
+        char msg[DBG_DATA_MSG];
+
+        if (req != NULL) {
+                scnprintf(msg, sizeof(msg),
+                          "%02X %02X %04X %04X %d", req->bRequestType,
+                          req->bRequest, le16_to_cpu(req->wValue),
+                          le16_to_cpu(req->wIndex), le16_to_cpu(req->wLength));
+                dbg_print(addr, "SETUP", 0, msg);
+        }
+}
+
+/**
+ * show_events: displays the event buffer
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_events(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        unsigned long flags;
+        unsigned i, j, n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        read_lock_irqsave(&dbg_data.lck, flags);
+
+        i = dbg_data.idx;
+        for (dbg_dec(&i); i != dbg_data.idx; dbg_dec(&i)) {
+                n += strlen(dbg_data.buf[i]);
+                if (n >= PAGE_SIZE) {
+                        n -= strlen(dbg_data.buf[i]);
+                        break;
+                }
+        }
+        for (j = 0, dbg_inc(&i); j < n; dbg_inc(&i))
+                j += scnprintf(buf + j, PAGE_SIZE - j,
+                               "%s", dbg_data.buf[i]);
+
+        read_unlock_irqrestore(&dbg_data.lck, flags);
+
+        return n;
+}
+
+/**
+ * store_events: configure if events are going to be also printed to console
+ *
+ * Check "device.h" for details
+ */
+static ssize_t store_events(struct device *dev, struct device_attribute *attr,
+                            const char *buf, size_t count)
+{
+        unsigned tty;
+
+        dbg_trace("[%s] %p, %d\n", __func__, buf, count);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                goto done;
+        }
+
+        if (sscanf(buf, "%u", &tty) != 1 || tty > 1) {
+                dev_err(dev, "<1|0>: enable|disable console log\n");
+                goto done;
+        }
+
+        dbg_data.tty = tty;
+        dev_info(dev, "tty = %u", dbg_data.tty);
+
+ done:
+        return count;
+}
+static DEVICE_ATTR(events, S_IRUSR | S_IWUSR, show_events, store_events);
+
+/**
+ * show_inters: interrupt status, enable status and historic
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_inters(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        u32 intr;
+        unsigned i, j, n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+
+        n += scnprintf(buf + n, PAGE_SIZE - n,
+                       "status = %08x\n", hw_read_intr_status());
+        n += scnprintf(buf + n, PAGE_SIZE - n,
+                       "enable = %08x\n", hw_read_intr_enable());
+
+        n += scnprintf(buf + n, PAGE_SIZE - n, "*test = %d\n",
+                       isr_statistics.test);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "» ui  = %d\n",
+                       isr_statistics.ui);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "» uei = %d\n",
+                       isr_statistics.uei);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "» pci = %d\n",
+                       isr_statistics.pci);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "» uri = %d\n",
+                       isr_statistics.uri);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "» sli = %d\n",
+                       isr_statistics.sli);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "*none = %d\n",
+                       isr_statistics.none);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "*hndl = %d\n",
+                       isr_statistics.hndl.cnt);
+
+        for (i = isr_statistics.hndl.idx, j = 0; j <= ISR_MASK; j++, i++) {
+                i   &= ISR_MASK;
+                intr = isr_statistics.hndl.buf[i];
+
+                if (USBi_UI  & intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "ui  ");
+                intr &= ~USBi_UI;
+                if (USBi_UEI & intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "uei ");
+                intr &= ~USBi_UEI;
+                if (USBi_PCI & intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "pci ");
+                intr &= ~USBi_PCI;
+                if (USBi_URI & intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "uri ");
+                intr &= ~USBi_URI;
+                if (USBi_SLI & intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "sli ");
+                intr &= ~USBi_SLI;
+                if (intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "??? ");
+                if (isr_statistics.hndl.buf[i])
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
+        }
+
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        return n;
+}
+
+/**
+ * store_inters: enable & force or disable an individual interrutps
+ *                   (to be used for test purposes only)
+ *
+ * Check "device.h" for details
+ */
+static ssize_t store_inters(struct device *dev, struct device_attribute *attr,
+                            const char *buf, size_t count)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        unsigned en, bit;
+
+        dbg_trace("[%s] %p, %d\n", __func__, buf, count);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                goto done;
+        }
+
+        if (sscanf(buf, "%u %u", &en, &bit) != 2 || en > 1) {
+                dev_err(dev, "<1|0> <bit>: enable|disable interrupt");
+                goto done;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        if (en) {
+                if (hw_intr_force(bit))
+                        dev_err(dev, "invalid bit number\n");
+                else
+                        isr_statistics.test++;
+        } else {
+                if (hw_intr_clear(bit))
+                        dev_err(dev, "invalid bit number\n");
+        }
+        spin_unlock_irqrestore(udc->lock, flags);
+
+ done:
+        return count;
+}
+static DEVICE_ATTR(inters, S_IRUSR | S_IWUSR, show_inters, store_inters);
+
+/**
+ * show_port_test: reads port test mode
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_port_test(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        unsigned mode;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        mode = hw_port_test_get();
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        return scnprintf(buf, PAGE_SIZE, "mode = %u\n", mode);
+}
+
+/**
+ * store_port_test: writes port test mode
+ *
+ * Check "device.h" for details
+ */
+static ssize_t store_port_test(struct device *dev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        unsigned mode;
+
+        dbg_trace("[%s] %p, %d\n", __func__, buf, count);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                goto done;
+        }
+
+        if (sscanf(buf, "%u", &mode) != 1) {
+                dev_err(dev, "<mode>: set port test mode");
+                goto done;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        if (hw_port_test_set(mode))
+                dev_err(dev, "invalid mode\n");
+        spin_unlock_irqrestore(udc->lock, flags);
+
+ done:
+        return count;
+}
+static DEVICE_ATTR(port_test, S_IRUSR | S_IWUSR,
+                   show_port_test, store_port_test);
+
+/**
+ * show_qheads: DMA contents of all queue heads
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_qheads(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        unsigned i, j, n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        for (i = 0; i < hw_ep_max; i++) {
+                struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
+                n += scnprintf(buf + n, PAGE_SIZE - n,
+                               "EP=%02i: RX=%08X TX=%08X\n",
+                               i, (u32)mEp->qh[RX].dma, (u32)mEp->qh[TX].dma);
+                for (j = 0; j < (sizeof(struct ci13xxx_qh)/sizeof(u32)); j++) {
+                        n += scnprintf(buf + n, PAGE_SIZE - n,
+                                       " %04X:    %08X    %08X\n", j,
+                                       *((u32 *)mEp->qh[RX].ptr + j),
+                                       *((u32 *)mEp->qh[TX].ptr + j));
+                }
+        }
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        return n;
+}
+static DEVICE_ATTR(qheads, S_IRUSR, show_qheads, NULL);
+
+/**
+ * show_registers: dumps all registers
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_registers(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        u32 dump[512];
+        unsigned i, k, n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        k = hw_register_read(dump, sizeof(dump)/sizeof(u32));
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        for (i = 0; i < k; i++) {
+                n += scnprintf(buf + n, PAGE_SIZE - n,
+                               "reg[0x%04X] = 0x%08X\n",
+                               i * (unsigned)sizeof(u32), dump[i]);
+        }
+
+        return n;
+}
+
+/**
+ * store_registers: writes value to register address
+ *
+ * Check "device.h" for details
+ */
+static ssize_t store_registers(struct device *dev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long addr, data, flags;
+
+        dbg_trace("[%s] %p, %d\n", __func__, buf, count);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                goto done;
+        }
+
+        if (sscanf(buf, "%li %li", &addr, &data) != 2) {
+                dev_err(dev, "<addr> <data>: write data to register address");
+                goto done;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        if (hw_register_write(addr, data))
+                dev_err(dev, "invalid address range\n");
+        spin_unlock_irqrestore(udc->lock, flags);
+
+ done:
+        return count;
+}
+static DEVICE_ATTR(registers, S_IRUSR | S_IWUSR,
+                   show_registers, store_registers);
+
+/**
+ * show_requests: DMA contents of all requests currently queued (all endpts)
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_requests(struct device *dev, struct device_attribute *attr,
+                             char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        struct list_head   *ptr = NULL;
+        struct ci13xxx_req *req = NULL;
+        unsigned i, j, k, n = 0, qSize = sizeof(struct ci13xxx_td)/sizeof(u32);
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        for (i = 0; i < hw_ep_max; i++)
+                for (k = RX; k <= TX; k++)
+                        list_for_each(ptr, &udc->ci13xxx_ep[i].qh[k].queue)
+                        {
+                                req = list_entry(ptr,
+                                                 struct ci13xxx_req, queue);
+
+                                n += scnprintf(buf + n, PAGE_SIZE - n,
+                                               "EP=%02i: TD=%08X %s\n",
+                                               i, (u32)req->dma,
+                                               ((k == RX) ? "RX" : "TX"));
+
+                                for (j = 0; j < qSize; j++)
+                                        n += scnprintf(buf + n, PAGE_SIZE - n,
+                                                       " %04X:    %08X\n", j,
+                                                       *((u32 *)req->ptr + j));
+                        }
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        return n;
+}
+static DEVICE_ATTR(requests, S_IRUSR, show_requests, NULL);
+
+/**
+ * dbg_create_files: initializes the attribute interface
+ * @dev: device
+ *
+ * This function returns an error code
+ */
+__maybe_unused static int dbg_create_files(struct device *dev)
+{
+        int retval = 0;
+
+        if (dev == NULL)
+                return -EINVAL;
+        retval = device_create_file(dev, &dev_attr_device);
+        if (retval)
+                goto done;
+        retval = device_create_file(dev, &dev_attr_driver);
+        if (retval)
+                goto rm_device;
+        retval = device_create_file(dev, &dev_attr_events);
+        if (retval)
+                goto rm_driver;
+        retval = device_create_file(dev, &dev_attr_inters);
+        if (retval)
+                goto rm_events;
+        retval = device_create_file(dev, &dev_attr_port_test);
+        if (retval)
+                goto rm_inters;
+        retval = device_create_file(dev, &dev_attr_qheads);
+        if (retval)
+                goto rm_port_test;
+        retval = device_create_file(dev, &dev_attr_registers);
+        if (retval)
+                goto rm_qheads;
+        retval = device_create_file(dev, &dev_attr_requests);
+        if (retval)
+                goto rm_registers;
+        return 0;
+
+ rm_registers:
+        device_remove_file(dev, &dev_attr_registers);
+ rm_qheads:
+        device_remove_file(dev, &dev_attr_qheads);
+ rm_port_test:
+        device_remove_file(dev, &dev_attr_port_test);
+ rm_inters:
+        device_remove_file(dev, &dev_attr_inters);
+ rm_events:
+        device_remove_file(dev, &dev_attr_events);
+ rm_driver:
+        device_remove_file(dev, &dev_attr_driver);
+ rm_device:
+        device_remove_file(dev, &dev_attr_device);
+ done:
+        return retval;
+}
+
+/**
+ * dbg_remove_files: destroys the attribute interface
+ * @dev: device
+ *
+ * This function returns an error code
+ */
+__maybe_unused static int dbg_remove_files(struct device *dev)
+{
+        if (dev == NULL)
+                return -EINVAL;
+        device_remove_file(dev, &dev_attr_requests);
+        device_remove_file(dev, &dev_attr_registers);
+        device_remove_file(dev, &dev_attr_qheads);
+        device_remove_file(dev, &dev_attr_port_test);
+        device_remove_file(dev, &dev_attr_inters);
+        device_remove_file(dev, &dev_attr_events);
+        device_remove_file(dev, &dev_attr_driver);
+        device_remove_file(dev, &dev_attr_device);
+        return 0;
+}
+
+/******************************************************************************
+ * UTIL block
+ *****************************************************************************/
+/**
+ * _usb_addr: calculates endpoint address from direction & number
+ * @ep:  endpoint
+ */
+static inline u8 _usb_addr(struct ci13xxx_ep *ep)
+{
+        return ((ep->dir == TX) ? USB_ENDPOINT_DIR_MASK : 0) | ep->num;
+}
+
+/**
+ * _hardware_queue: configures a request at hardware level
+ * @gadget: gadget
+ * @mEp:    endpoint
+ *
+ * This function returns an error code
+ */
+static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
+{
+        unsigned i;
+
+        trace("%p, %p", mEp, mReq);
+
+        /* don't queue twice */
+        if (mReq->req.status == -EALREADY)
+                return -EALREADY;
+
+        if (hw_ep_is_primed(mEp->num, mEp->dir))
+                return -EBUSY;
+
+        mReq->req.status = -EALREADY;
+
+        if (mReq->req.length && !mReq->req.dma) {
+                mReq->req.dma = \
+                        dma_map_single(mEp->device, mReq->req.buf,
+                                       mReq->req.length, mEp->dir ?
+                                       DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                if (mReq->req.dma == 0)
+                        return -ENOMEM;
+
+                mReq->map = 1;
+        }
+
+        /*
+         * TD configuration
+         * TODO - handle requests which spawns into several TDs
+         */
+        memset(mReq->ptr, 0, sizeof(*mReq->ptr));
+        mReq->ptr->next    |= TD_TERMINATE;
+        mReq->ptr->token    = mReq->req.length << ffs_nr(TD_TOTAL_BYTES);
+        mReq->ptr->token   &= TD_TOTAL_BYTES;
+        mReq->ptr->token   |= TD_IOC;
+        mReq->ptr->token   |= TD_STATUS_ACTIVE;
+        mReq->ptr->page[0]  = mReq->req.dma;
+        for (i = 1; i < 5; i++)
+                mReq->ptr->page[i] =
+                        (mReq->req.dma + i * PAGE_SIZE) & ~TD_RESERVED_MASK;
+
+        /*
+         *  QH configuration
+         *  At this point it's guaranteed exclusive access to qhead
+         *  (endpt is not primed) so it's no need to use tripwire
+         */
+        mEp->qh[mEp->dir].ptr->td.next   = mReq->dma;    /* TERMINATE = 0 */
+        mEp->qh[mEp->dir].ptr->td.token &= ~TD_STATUS;   /* clear status */
+        if (mReq->req.zero == 0)
+                mEp->qh[mEp->dir].ptr->cap |=  QH_ZLT;
+        else
+                mEp->qh[mEp->dir].ptr->cap &= ~QH_ZLT;
+
+        wmb();   /* synchronize before ep prime */
+
+        return hw_ep_prime(mEp->num, mEp->dir,
+                           mEp->type == USB_ENDPOINT_XFER_CONTROL);
+}
+
+/**
+ * _hardware_dequeue: handles a request at hardware level
+ * @gadget: gadget
+ * @mEp:    endpoint
+ *
+ * This function returns an error code
+ */
+static int _hardware_dequeue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
+{
+        trace("%p, %p", mEp, mReq);
+
+        if (mReq->req.status != -EALREADY)
+                return -EINVAL;
+
+        if (hw_ep_is_primed(mEp->num, mEp->dir))
+                hw_ep_flush(mEp->num, mEp->dir);
+
+        mReq->req.status = 0;
+
+        if (mReq->map) {
+                dma_unmap_single(mEp->device, mReq->req.dma, mReq->req.length,
+                                 mEp->dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                mReq->req.dma = 0;
+                mReq->map     = 0;
+        }
+
+        mReq->req.status = mReq->ptr->token & TD_STATUS;
+        if      ((TD_STATUS_ACTIVE & mReq->req.status) != 0)
+                mReq->req.status = -ECONNRESET;
+        else if ((TD_STATUS_HALTED & mReq->req.status) != 0)
+                mReq->req.status = -1;
+        else if ((TD_STATUS_DT_ERR & mReq->req.status) != 0)
+                mReq->req.status = -1;
+        else if ((TD_STATUS_TR_ERR & mReq->req.status) != 0)
+                mReq->req.status = -1;
+
+        mReq->req.actual   = mReq->ptr->token & TD_TOTAL_BYTES;
+        mReq->req.actual >>= ffs_nr(TD_TOTAL_BYTES);
+        mReq->req.actual   = mReq->req.length - mReq->req.actual;
+        mReq->req.actual   = mReq->req.status ? 0 : mReq->req.actual;
+
+        return mReq->req.actual;
+}
+
+/**
+ * _ep_nuke: dequeues all endpoint requests
+ * @mEp: endpoint
+ *
+ * This function returns an error code
+ * Caller must hold lock
+ */
+static int _ep_nuke(struct ci13xxx_ep *mEp)
+__releases(mEp->lock)
+__acquires(mEp->lock)
+{
+        trace("%p", mEp);
+
+        if (mEp == NULL)
+                return -EINVAL;
+
+        hw_ep_flush(mEp->num, mEp->dir);
+
+        while (!list_empty(&mEp->qh[mEp->dir].queue)) {
+
+                /* pop oldest request */
+                struct ci13xxx_req *mReq = \
+                        list_entry(mEp->qh[mEp->dir].queue.next,
+                                   struct ci13xxx_req, queue);
+                list_del_init(&mReq->queue);
+                mReq->req.status = -ESHUTDOWN;
+
+                if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
+                        spin_unlock(mEp->lock);
+                        mReq->req.complete(&mEp->ep, &mReq->req);
+                        spin_lock(mEp->lock);
+                }
+        }
+        return 0;
+}
+
+/**
+ * _gadget_stop_activity: stops all USB activity, flushes & disables all endpts
+ * @gadget: gadget
+ *
+ * This function returns an error code
+ * Caller must hold lock
+ */
+static int _gadget_stop_activity(struct usb_gadget *gadget)
+__releases(udc->lock)
+__acquires(udc->lock)
+{
+        struct usb_ep *ep;
+        struct ci13xxx    *udc = container_of(gadget, struct ci13xxx, gadget);
+        struct ci13xxx_ep *mEp = container_of(gadget->ep0,
+                                              struct ci13xxx_ep, ep);
+
+        trace("%p", gadget);
+
+        if (gadget == NULL)
+                return -EINVAL;
+
+        spin_unlock(udc->lock);
+
+        /* flush all endpoints */
+        gadget_for_each_ep(ep, gadget) {
+                usb_ep_fifo_flush(ep);
+        }
+        usb_ep_fifo_flush(gadget->ep0);
+
+        udc->driver->disconnect(gadget);
+
+        /* make sure to disable all endpoints */
+        gadget_for_each_ep(ep, gadget) {
+                usb_ep_disable(ep);
+        }
+        usb_ep_disable(gadget->ep0);
+
+        if (mEp->status != NULL) {
+                usb_ep_free_request(gadget->ep0, mEp->status);
+                mEp->status = NULL;
+        }
+
+        spin_lock(udc->lock);
+
+        return 0;
+}
+
+/******************************************************************************
+ * ISR block
+ *****************************************************************************/
+/**
+ * isr_reset_handler: USB reset interrupt handler
+ * @udc: UDC device
+ *
+ * This function resets USB engine after a bus reset occurred
+ */
+static void isr_reset_handler(struct ci13xxx *udc)
+__releases(udc->lock)
+__acquires(udc->lock)
+{
+        struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[0];
+        int retval;
+
+        trace("%p", udc);
+
+        if (udc == NULL) {
+                err("EINVAL");
+                return;
+        }
+
+        dbg_event(0xFF, "BUS RST", 0);
+
+        retval = _gadget_stop_activity(&udc->gadget);
+        if (retval)
+                goto done;
+
+        retval = hw_usb_reset();
+        if (retval)
+                goto done;
+
+        spin_unlock(udc->lock);
+        retval = usb_ep_enable(&mEp->ep, &ctrl_endpt_desc);
+        if (!retval) {
+                mEp->status = usb_ep_alloc_request(&mEp->ep, GFP_KERNEL);
+                if (mEp->status == NULL) {
+                        usb_ep_disable(&mEp->ep);
+                        retval = -ENOMEM;
+                }
+        }
+        spin_lock(udc->lock);
+
+ done:
+        if (retval)
+                err("error: %i", retval);
+}
+
+/**
+ * isr_get_status_complete: get_status request complete function
+ * @ep:  endpoint
+ * @req: request handled
+ *
+ * Caller must release lock
+ */
+static void isr_get_status_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        trace("%p, %p", ep, req);
+
+        if (ep == NULL || req == NULL) {
+                err("EINVAL");
+                return;
+        }
+
+        kfree(req->buf);
+        usb_ep_free_request(ep, req);
+}
+
+/**
+ * isr_get_status_response: get_status request response
+ * @ep:    endpoint
+ * @setup: setup request packet
+ *
+ * This function returns an error code
+ */
+static int isr_get_status_response(struct ci13xxx_ep *mEp,
+                                   struct usb_ctrlrequest *setup)
+__releases(mEp->lock)
+__acquires(mEp->lock)
+{
+        struct usb_request *req = NULL;
+        gfp_t gfp_flags = GFP_ATOMIC;
+        int dir, num, retval;
+
+        trace("%p, %p", mEp, setup);
+
+        if (mEp == NULL || setup == NULL)
+                return -EINVAL;
+
+        spin_unlock(mEp->lock);
+        req = usb_ep_alloc_request(&mEp->ep, gfp_flags);
+        spin_lock(mEp->lock);
+        if (req == NULL)
+                return -ENOMEM;
+
+        req->complete = isr_get_status_complete;
+        req->length   = 2;
+        req->buf      = kzalloc(req->length, gfp_flags);
+        if (req->buf == NULL) {
+                retval = -ENOMEM;
+                goto err_free_req;
+        }
+
+        if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
+                /* TODO: D1 - Remote Wakeup; D0 - Self Powered */
+                retval = 0;
+        } else if ((setup->bRequestType & USB_RECIP_MASK) \
+                   == USB_RECIP_ENDPOINT) {
+                dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ?
+                        TX : RX;
+                num =  le16_to_cpu(setup->wIndex) & USB_ENDPOINT_NUMBER_MASK;
+                *((u16 *)req->buf) = hw_ep_get_halt(num, dir);
+        }
+        /* else do nothing; reserved for future use */
+
+        spin_unlock(mEp->lock);
+        retval = usb_ep_queue(&mEp->ep, req, gfp_flags);
+        spin_lock(mEp->lock);
+        if (retval)
+                goto err_free_buf;
+
+        return 0;
+
+ err_free_buf:
+        kfree(req->buf);
+ err_free_req:
+        spin_unlock(mEp->lock);
+        usb_ep_free_request(&mEp->ep, req);
+        spin_lock(mEp->lock);
+        return retval;
+}
+
+/**
+ * isr_setup_status_phase: queues the status phase of a setup transation
+ * @mEp: endpoint
+ *
+ * This function returns an error code
+ */
+static int isr_setup_status_phase(struct ci13xxx_ep *mEp)
+__releases(mEp->lock)
+__acquires(mEp->lock)
+{
+        int retval;
+
+        trace("%p", mEp);
+
+        /* mEp is always valid & configured */
+
+        if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
+                mEp->dir = (mEp->dir == TX) ? RX : TX;
+
+        mEp->status->no_interrupt = 1;
+
+        spin_unlock(mEp->lock);
+        retval = usb_ep_queue(&mEp->ep, mEp->status, GFP_ATOMIC);
+        spin_lock(mEp->lock);
+
+        return retval;
+}
+
+/**
+ * isr_tr_complete_low: transaction complete low level handler
+ * @mEp: endpoint
+ *
+ * This function returns an error code
+ * Caller must hold lock
+ */
+static int isr_tr_complete_low(struct ci13xxx_ep *mEp)
+__releases(mEp->lock)
+__acquires(mEp->lock)
+{
+        struct ci13xxx_req *mReq;
+        int retval;
+
+        trace("%p", mEp);
+
+        if (list_empty(&mEp->qh[mEp->dir].queue))
+                return -EINVAL;
+
+        /* pop oldest request */
+        mReq = list_entry(mEp->qh[mEp->dir].queue.next,
+                          struct ci13xxx_req, queue);
+        list_del_init(&mReq->queue);
+
+        retval = _hardware_dequeue(mEp, mReq);
+        if (retval < 0) {
+                dbg_event(_usb_addr(mEp), "DONE", retval);
+                goto done;
+        }
+
+        dbg_done(_usb_addr(mEp), mReq->ptr->token, retval);
+
+        if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
+                spin_unlock(mEp->lock);
+                mReq->req.complete(&mEp->ep, &mReq->req);
+                spin_lock(mEp->lock);
+        }
+
+        if (!list_empty(&mEp->qh[mEp->dir].queue)) {
+                mReq = list_entry(mEp->qh[mEp->dir].queue.next,
+                                  struct ci13xxx_req, queue);
+                _hardware_enqueue(mEp, mReq);
+        }
+
+ done:
+        return retval;
+}
+
+/**
+ * isr_tr_complete_handler: transaction complete interrupt handler
+ * @udc: UDC descriptor
+ *
+ * This function handles traffic events
+ */
+static void isr_tr_complete_handler(struct ci13xxx *udc)
+__releases(udc->lock)
+__acquires(udc->lock)
+{
+        unsigned i;
+
+        trace("%p", udc);
+
+        if (udc == NULL) {
+                err("EINVAL");
+                return;
+        }
+
+        for (i = 0; i < hw_ep_max; i++) {
+                struct ci13xxx_ep *mEp  = &udc->ci13xxx_ep[i];
+                int type, num, err = -EINVAL;
+                struct usb_ctrlrequest req;
+
+
+                if (mEp->desc == NULL)
+                        continue;   /* not configured */
+
+                if ((mEp->dir == RX && hw_test_and_clear_complete(i)) ||
+                    (mEp->dir == TX && hw_test_and_clear_complete(i + 16))) {
+                        err = isr_tr_complete_low(mEp);
+                        if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
+                                if (err > 0)   /* needs status phase */
+                                        err = isr_setup_status_phase(mEp);
+                                if (err < 0) {
+                                        dbg_event(_usb_addr(mEp),
+                                                  "ERROR", err);
+                                        spin_unlock(udc->lock);
+                                        if (usb_ep_set_halt(&mEp->ep))
+                                                err("error: ep_set_halt");
+                                        spin_lock(udc->lock);
+                                }
+                        }
+                }
+
+                if (mEp->type != USB_ENDPOINT_XFER_CONTROL ||
+                    !hw_test_and_clear_setup_status(i))
+                        continue;
+
+                if (i != 0) {
+                        warn("ctrl traffic received at endpoint");
+                        continue;
+                }
+
+                /* read_setup_packet */
+                do {
+                        hw_test_and_set_setup_guard();
+                        memcpy(&req, &mEp->qh[RX].ptr->setup, sizeof(req));
+                } while (!hw_test_and_clear_setup_guard());
+
+                type = req.bRequestType;
+
+                mEp->dir = (type & USB_DIR_IN) ? TX : RX;
+
+                dbg_setup(_usb_addr(mEp), &req);
+
+                switch (req.bRequest) {
+                case USB_REQ_CLEAR_FEATURE:
+                        if (type != (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
+                            le16_to_cpu(req.wValue) != USB_ENDPOINT_HALT)
+                                goto delegate;
+                        if (req.wLength != 0)
+                                break;
+                        num  = le16_to_cpu(req.wIndex);
+                        num &= USB_ENDPOINT_NUMBER_MASK;
+                        if (!udc->ci13xxx_ep[num].wedge) {
+                                spin_unlock(udc->lock);
+                                err = usb_ep_clear_halt(
+                                        &udc->ci13xxx_ep[num].ep);
+                                spin_lock(udc->lock);
+                                if (err)
+                                        break;
+                        }
+                        err = isr_setup_status_phase(mEp);
+                        break;
+                case USB_REQ_GET_STATUS:
+                        if (type != (USB_DIR_IN|USB_RECIP_DEVICE)   &&
+                            type != (USB_DIR_IN|USB_RECIP_ENDPOINT) &&
+                            type != (USB_DIR_IN|USB_RECIP_INTERFACE))
+                                goto delegate;
+                        if (le16_to_cpu(req.wLength) != 2 ||
+                            le16_to_cpu(req.wValue)  != 0)
+                                break;
+                        err = isr_get_status_response(mEp, &req);
+                        break;
+                case USB_REQ_SET_ADDRESS:
+                        if (type != (USB_DIR_OUT|USB_RECIP_DEVICE))
+                                goto delegate;
+                        if (le16_to_cpu(req.wLength) != 0 ||
+                            le16_to_cpu(req.wIndex)  != 0)
+                                break;
+                        err = hw_usb_set_address((u8)le16_to_cpu(req.wValue));
+                        if (err)
+                                break;
+                        err = isr_setup_status_phase(mEp);
+                        break;
+                case USB_REQ_SET_FEATURE:
+                        if (type != (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
+                            le16_to_cpu(req.wValue) != USB_ENDPOINT_HALT)
+                                goto delegate;
+                        if (req.wLength != 0)
+                                break;
+                        num  = le16_to_cpu(req.wIndex);
+                        num &= USB_ENDPOINT_NUMBER_MASK;
+
+                        spin_unlock(udc->lock);
+                        err = usb_ep_set_halt(&udc->ci13xxx_ep[num].ep);
+                        spin_lock(udc->lock);
+                        if (err)
+                                break;
+                        err = isr_setup_status_phase(mEp);
+                        break;
+                default:
+delegate:
+                        if (req.wLength == 0)   /* no data phase */
+                                mEp->dir = TX;
+
+                        spin_unlock(udc->lock);
+                        err = udc->driver->setup(&udc->gadget, &req);
+                        spin_lock(udc->lock);
+                        break;
+                }
+
+                if (err < 0) {
+                        dbg_event(_usb_addr(mEp), "ERROR", err);
+
+                        spin_unlock(udc->lock);
+                        if (usb_ep_set_halt(&mEp->ep))
+                                err("error: ep_set_halt");
+                        spin_lock(udc->lock);
+                }
+        }
+}
+
+/******************************************************************************
+ * ENDPT block
+ *****************************************************************************/
+/**
+ * ep_enable: configure endpoint, making it usable
+ *
+ * Check usb_ep_enable() at "usb_gadget.h" for details
+ */
+static int ep_enable(struct usb_ep *ep,
+                     const struct usb_endpoint_descriptor *desc)
+{
+        struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
+        int direction, retval = 0;
+        unsigned long flags;
+
+        trace("%p, %p", ep, desc);
+
+        if (ep == NULL || desc == NULL)
+                return -EINVAL;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        /* only internal SW should enable ctrl endpts */
+
+        mEp->desc = desc;
+
+        if (!list_empty(&mEp->qh[mEp->dir].queue))
+                warn("enabling a non-empty endpoint!");
+
+        mEp->dir  = (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) ? TX : RX;
+        mEp->num  =  desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+        mEp->type =  desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
+
+        mEp->ep.maxpacket = __constant_le16_to_cpu(desc->wMaxPacketSize);
+
+        direction = mEp->dir;
+        do {
+                dbg_event(_usb_addr(mEp), "ENABLE", 0);
+
+                if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
+                        mEp->qh[mEp->dir].ptr->cap |=  QH_IOS;
+                else if (mEp->type == USB_ENDPOINT_XFER_ISOC)
+                        mEp->qh[mEp->dir].ptr->cap &= ~QH_MULT;
+                else
+                        mEp->qh[mEp->dir].ptr->cap &= ~QH_ZLT;
+
+                mEp->qh[mEp->dir].ptr->cap |=
+                        (mEp->ep.maxpacket << ffs_nr(QH_MAX_PKT)) & QH_MAX_PKT;
+                mEp->qh[mEp->dir].ptr->td.next |= TD_TERMINATE;   /* needed? */
+
+                retval |= hw_ep_enable(mEp->num, mEp->dir, mEp->type);
+
+                if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
+                        mEp->dir = (mEp->dir == TX) ? RX : TX;
+
+        } while (mEp->dir != direction);
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+        return retval;
+}
+
+/**
+ * ep_disable: endpoint is no longer usable
+ *
+ * Check usb_ep_disable() at "usb_gadget.h" for details
+ */
+static int ep_disable(struct usb_ep *ep)
+{
+        struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
+        int direction, retval = 0;
+        unsigned long flags;
+
+        trace("%p", ep);
+
+        if (ep == NULL)
+                return -EINVAL;
+        else if (mEp->desc == NULL)
+                return -EBUSY;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        /* only internal SW should disable ctrl endpts */
+
+        direction = mEp->dir;
+        do {
+                dbg_event(_usb_addr(mEp), "DISABLE", 0);
+
+                retval |= _ep_nuke(mEp);
+                retval |= hw_ep_disable(mEp->num, mEp->dir);
+
+                if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
+                        mEp->dir = (mEp->dir == TX) ? RX : TX;
+
+        } while (mEp->dir != direction);
+
+        mEp->desc = NULL;
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+        return retval;
+}
+
+/**
+ * ep_alloc_request: allocate a request object to use with this endpoint
+ *
+ * Check usb_ep_alloc_request() at "usb_gadget.h" for details
+ */
+static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
+{
+        struct ci13xxx_ep  *mEp  = container_of(ep, struct ci13xxx_ep, ep);
+        struct ci13xxx_req *mReq = NULL;
+        unsigned long flags;
+
+        trace("%p, %i", ep, gfp_flags);
+
+        if (ep == NULL) {
+                err("EINVAL");
+                return NULL;
+        }
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        mReq = kzalloc(sizeof(struct ci13xxx_req), gfp_flags);
+        if (mReq != NULL) {
+                INIT_LIST_HEAD(&mReq->queue);
+
+                mReq->ptr = dma_pool_alloc(mEp->td_pool, gfp_flags,
+                                           &mReq->dma);
+                if (mReq->ptr == NULL) {
+                        kfree(mReq);
+                        mReq = NULL;
+                }
+        }
+
+        dbg_event(_usb_addr(mEp), "ALLOC", mReq == NULL);
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+
+        return (mReq == NULL) ? NULL : &mReq->req;
+}
+
+/**
+ * ep_free_request: frees a request object
+ *
+ * Check usb_ep_free_request() at "usb_gadget.h" for details
+ */
+static void ep_free_request(struct usb_ep *ep, struct usb_request *req)
+{
+        struct ci13xxx_ep  *mEp  = container_of(ep,  struct ci13xxx_ep, ep);
+        struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
+        unsigned long flags;
+
+        trace("%p, %p", ep, req);
+
+        if (ep == NULL || req == NULL) {
+                err("EINVAL");
+                return;
+        } else if (!list_empty(&mReq->queue)) {
+                err("EBUSY");
+                return;
+        }
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        if (mReq->ptr)
+                dma_pool_free(mEp->td_pool, mReq->ptr, mReq->dma);
+        kfree(mReq);
+
+        dbg_event(_usb_addr(mEp), "FREE", 0);
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+}
+
+/**
+ * ep_queue: queues (submits) an I/O request to an endpoint
+ *
+ * Check usb_ep_queue()* at usb_gadget.h" for details
+ */
+static int ep_queue(struct usb_ep *ep, struct usb_request *req,
+                    gfp_t __maybe_unused gfp_flags)
+{
+        struct ci13xxx_ep  *mEp  = container_of(ep,  struct ci13xxx_ep, ep);
+        struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
+        int retval = 0;
+        unsigned long flags;
+
+        trace("%p, %p, %X", ep, req, gfp_flags);
+
+        if (ep == NULL || req == NULL || mEp->desc == NULL)
+                return -EINVAL;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        if (mEp->type == USB_ENDPOINT_XFER_CONTROL &&
+            !list_empty(&mEp->qh[mEp->dir].queue)) {
+                _ep_nuke(mEp);
+                retval = -EOVERFLOW;
+                warn("endpoint ctrl %X nuked", _usb_addr(mEp));
+        }
+
+        /* first nuke then test link, e.g. previous status has not sent */
+        if (!list_empty(&mReq->queue)) {
+                retval = -EBUSY;
+                err("request already in queue");
+                goto done;
+        }
+
+        if (req->length > (4 * PAGE_SIZE)) {
+                req->length = (4 * PAGE_SIZE);
+                retval = -EMSGSIZE;
+                warn("request length truncated");
+        }
+
+        dbg_queue(_usb_addr(mEp), req, retval);
+
+        /* push request */
+        mReq->req.status = -EINPROGRESS;
+        mReq->req.actual = 0;
+        list_add_tail(&mReq->queue, &mEp->qh[mEp->dir].queue);
+
+        retval = _hardware_enqueue(mEp, mReq);
+        if (retval == -EALREADY || retval == -EBUSY) {
+                dbg_event(_usb_addr(mEp), "QUEUE", retval);
+                retval = 0;
+        }
+
+ done:
+        spin_unlock_irqrestore(mEp->lock, flags);
+        return retval;
+}
+
+/**
+ * ep_dequeue: dequeues (cancels, unlinks) an I/O request from an endpoint
+ *
+ * Check usb_ep_dequeue() at "usb_gadget.h" for details
+ */
+static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
+{
+        struct ci13xxx_ep  *mEp  = container_of(ep,  struct ci13xxx_ep, ep);
+        struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
+        unsigned long flags;
+
+        trace("%p, %p", ep, req);
+
+        if (ep == NULL || req == NULL || mEp->desc == NULL ||
+            list_empty(&mReq->queue)  || list_empty(&mEp->qh[mEp->dir].queue))
+                return -EINVAL;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        dbg_event(_usb_addr(mEp), "DEQUEUE", 0);
+
+        if (mReq->req.status == -EALREADY)
+                _hardware_dequeue(mEp, mReq);
+
+        /* pop request */
+        list_del_init(&mReq->queue);
+        req->status = -ECONNRESET;
+
+        if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
+                spin_unlock(mEp->lock);
+                mReq->req.complete(&mEp->ep, &mReq->req);
+                spin_lock(mEp->lock);
+        }
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+        return 0;
+}
+
+/**
+ * ep_set_halt: sets the endpoint halt feature
+ *
+ * Check usb_ep_set_halt() at "usb_gadget.h" for details
+ */
+static int ep_set_halt(struct usb_ep *ep, int value)
+{
+        struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
+        int direction, retval = 0;
+        unsigned long flags;
+
+        trace("%p, %i", ep, value);
+
+        if (ep == NULL || mEp->desc == NULL)
+                return -EINVAL;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+#ifndef STALL_IN
+        /* g_file_storage MS compliant but g_zero fails chapter 9 compliance */
+        if (value && mEp->type == USB_ENDPOINT_XFER_BULK && mEp->dir == TX &&
+            !list_empty(&mEp->qh[mEp->dir].queue)) {
+                spin_unlock_irqrestore(mEp->lock, flags);
+                return -EAGAIN;
+        }
+#endif
+
+        direction = mEp->dir;
+        do {
+                dbg_event(_usb_addr(mEp), "HALT", value);
+                retval |= hw_ep_set_halt(mEp->num, mEp->dir, value);
+
+                if (!value)
+                        mEp->wedge = 0;
+
+                if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
+                        mEp->dir = (mEp->dir == TX) ? RX : TX;
+
+        } while (mEp->dir != direction);
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+        return retval;
+}
+
+/**
+ * ep_set_wedge: sets the halt feature and ignores clear requests
+ *
+ * Check usb_ep_set_wedge() at "usb_gadget.h" for details
+ */
+static int ep_set_wedge(struct usb_ep *ep)
+{
+        struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
+        unsigned long flags;
+
+        trace("%p", ep);
+
+        if (ep == NULL || mEp->desc == NULL)
+                return -EINVAL;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        dbg_event(_usb_addr(mEp), "WEDGE", 0);
+        mEp->wedge = 1;
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+
+        return usb_ep_set_halt(ep);
+}
+
+/**
+ * ep_fifo_flush: flushes contents of a fifo
+ *
+ * Check usb_ep_fifo_flush() at "usb_gadget.h" for details
+ */
+static void ep_fifo_flush(struct usb_ep *ep)
+{
+        struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
+        unsigned long flags;
+
+        trace("%p", ep);
+
+        if (ep == NULL) {
+                err("%02X: -EINVAL", _usb_addr(mEp));
+                return;
+        }
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        dbg_event(_usb_addr(mEp), "FFLUSH", 0);
+        hw_ep_flush(mEp->num, mEp->dir);
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+}
+
+/**
+ * Endpoint-specific part of the API to the USB controller hardware
+ * Check "usb_gadget.h" for details
+ */
+static const struct usb_ep_ops usb_ep_ops = {
+        .enable        = ep_enable,
+        .disable       = ep_disable,
+        .alloc_request = ep_alloc_request,
+        .free_request  = ep_free_request,
+        .queue         = ep_queue,
+        .dequeue       = ep_dequeue,
+        .set_halt      = ep_set_halt,
+        .set_wedge     = ep_set_wedge,
+        .fifo_flush    = ep_fifo_flush,
+};
+
+/******************************************************************************
+ * GADGET block
+ *****************************************************************************/
+/**
+ * Device operations part of the API to the USB controller hardware,
+ * which don't involve endpoints (or i/o)
+ * Check  "usb_gadget.h" for details
+ */
+static const struct usb_gadget_ops usb_gadget_ops;
+
+/**
+ * usb_gadget_register_driver: register a gadget driver
+ *
+ * Check usb_gadget_register_driver() at "usb_gadget.h" for details
+ * Interrupts are enabled here
+ */
+int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+{
+        struct ci13xxx *udc = _udc;
+        unsigned long i, k, flags;
+        int retval = -ENOMEM;
+
+        trace("%p", driver);
+
+        if (driver             == NULL ||
+            driver->bind       == NULL ||
+            driver->unbind     == NULL ||
+            driver->setup      == NULL ||
+            driver->disconnect == NULL ||
+            driver->suspend    == NULL ||
+            driver->resume     == NULL)
+                return -EINVAL;
+        else if (udc         == NULL)
+                return -ENODEV;
+        else if (udc->driver != NULL)
+                return -EBUSY;
+
+        /* alloc resources */
+        udc->qh_pool = dma_pool_create("ci13xxx_qh", &udc->gadget.dev,
+                                       sizeof(struct ci13xxx_qh),
+                                       64, PAGE_SIZE);
+        if (udc->qh_pool == NULL)
+                return -ENOMEM;
+
+        udc->td_pool = dma_pool_create("ci13xxx_td", &udc->gadget.dev,
+                                       sizeof(struct ci13xxx_td),
+                                       64, PAGE_SIZE);
+        if (udc->td_pool == NULL) {
+                dma_pool_destroy(udc->qh_pool);
+                udc->qh_pool = NULL;
+                return -ENOMEM;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+
+        info("hw_ep_max = %d", hw_ep_max);
+
+        udc->driver = driver;
+        udc->gadget.ops        = NULL;
+        udc->gadget.dev.driver = NULL;
+
+        retval = 0;
+        for (i = 0; i < hw_ep_max; i++) {
+                struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
+
+                scnprintf(mEp->name, sizeof(mEp->name), "ep%i", (int)i);
+
+                mEp->lock         = udc->lock;
+                mEp->device       = &udc->gadget.dev;
+                mEp->td_pool      = udc->td_pool;
+
+                mEp->ep.name      = mEp->name;
+                mEp->ep.ops       = &usb_ep_ops;
+                mEp->ep.maxpacket = CTRL_PAYLOAD_MAX;
+
+                /* this allocation cannot be random */
+                for (k = RX; k <= TX; k++) {
+                        INIT_LIST_HEAD(&mEp->qh[k].queue);
+                        mEp->qh[k].ptr = dma_pool_alloc(udc->qh_pool,
+                                                        GFP_KERNEL,
+                                                        &mEp->qh[k].dma);
+                        if (mEp->qh[k].ptr == NULL)
+                                retval = -ENOMEM;
+                        else
+                                memset(mEp->qh[k].ptr, 0,
+                                       sizeof(*mEp->qh[k].ptr));
+                }
+                if (i == 0)
+                        udc->gadget.ep0 = &mEp->ep;
+                else
+                        list_add_tail(&mEp->ep.ep_list, &udc->gadget.ep_list);
+        }
+        if (retval)
+                goto done;
+
+        /* bind gadget */
+        driver->driver.bus     = NULL;
+        udc->gadget.ops        = &usb_gadget_ops;
+        udc->gadget.dev.driver = &driver->driver;
+
+        spin_unlock_irqrestore(udc->lock, flags);
+        retval = driver->bind(&udc->gadget);                /* MAY SLEEP */
+        spin_lock_irqsave(udc->lock, flags);
+
+        if (retval) {
+                udc->gadget.ops        = NULL;
+                udc->gadget.dev.driver = NULL;
+                goto done;
+        }
+
+        retval = hw_device_state(udc->ci13xxx_ep[0].qh[RX].dma);
+
+ done:
+        spin_unlock_irqrestore(udc->lock, flags);
+        if (retval)
+                usb_gadget_unregister_driver(driver);
+        return retval;
+}
+EXPORT_SYMBOL(usb_gadget_register_driver);
+
+/**
+ * usb_gadget_unregister_driver: unregister a gadget driver
+ *
+ * Check usb_gadget_unregister_driver() at "usb_gadget.h" for details
+ */
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct ci13xxx *udc = _udc;
+        unsigned long i, k, flags;
+
+        trace("%p", driver);
+
+        if (driver             == NULL ||
+            driver->bind       == NULL ||
+            driver->unbind     == NULL ||
+            driver->setup      == NULL ||
+            driver->disconnect == NULL ||
+            driver->suspend    == NULL ||
+            driver->resume     == NULL ||
+            driver             != udc->driver)
+                return -EINVAL;
+
+        spin_lock_irqsave(udc->lock, flags);
+
+        hw_device_state(0);
+
+        /* unbind gadget */
+        if (udc->gadget.ops != NULL) {
+                _gadget_stop_activity(&udc->gadget);
+
+                spin_unlock_irqrestore(udc->lock, flags);
+                driver->unbind(&udc->gadget);               /* MAY SLEEP */
+                spin_lock_irqsave(udc->lock, flags);
+
+                udc->gadget.ops        = NULL;
+                udc->gadget.dev.driver = NULL;
+        }
+
+        /* free resources */
+        for (i = 0; i < hw_ep_max; i++) {
+                struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
+
+                if (i == 0)
+                        udc->gadget.ep0 = NULL;
+                else if (!list_empty(&mEp->ep.ep_list))
+                        list_del_init(&mEp->ep.ep_list);
+
+                for (k = RX; k <= TX; k++)
+                        if (mEp->qh[k].ptr != NULL)
+                                dma_pool_free(udc->qh_pool,
+                                              mEp->qh[k].ptr, mEp->qh[k].dma);
+        }
+
+        udc->driver = NULL;
+
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        if (udc->td_pool != NULL) {
+                dma_pool_destroy(udc->td_pool);
+                udc->td_pool = NULL;
+        }
+        if (udc->qh_pool != NULL) {
+                dma_pool_destroy(udc->qh_pool);
+                udc->qh_pool = NULL;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+/******************************************************************************
+ * BUS block
+ *****************************************************************************/
+/**
+ * udc_irq: global interrupt handler
+ *
+ * This function returns IRQ_HANDLED if the IRQ has been handled
+ * It locks access to registers
+ */
+static irqreturn_t udc_irq(void)
+{
+        struct ci13xxx *udc = _udc;
+        irqreturn_t retval;
+        u32 intr;
+
+        trace();
+
+        if (udc == NULL) {
+                err("ENODEV");
+                return IRQ_HANDLED;
+        }
+
+        spin_lock(udc->lock);
+        intr = hw_test_and_clear_intr_active();
+        if (intr) {
+                isr_statistics.hndl.buf[isr_statistics.hndl.idx++] = intr;
+                isr_statistics.hndl.idx &= ISR_MASK;
+                isr_statistics.hndl.cnt++;
+
+                /* order defines priority - do NOT change it */
+                if (USBi_URI & intr) {
+                        isr_statistics.uri++;
+                        isr_reset_handler(udc);
+                }
+                if (USBi_PCI & intr) {
+                        isr_statistics.pci++;
+                        udc->gadget.speed = hw_port_is_high_speed() ?
+                                USB_SPEED_HIGH : USB_SPEED_FULL;
+                }
+                if (USBi_UEI & intr)
+                        isr_statistics.uei++;
+                if (USBi_UI  & intr) {
+                        isr_statistics.ui++;
+                        isr_tr_complete_handler(udc);
+                }
+                if (USBi_SLI & intr)
+                        isr_statistics.sli++;
+                retval = IRQ_HANDLED;
+        } else {
+                isr_statistics.none++;
+                retval = IRQ_NONE;
+        }
+        spin_unlock(udc->lock);
+
+        return retval;
+}
+
+/**
+ * udc_release: driver release function
+ * @dev: device
+ *
+ * Currently does nothing
+ */
+static void udc_release(struct device *dev)
+{
+        trace("%p", dev);
+
+        if (dev == NULL)
+                err("EINVAL");
+}
+
+/**
+ * udc_probe: parent probe must call this to initialize UDC
+ * @dev:  parent device
+ * @regs: registers base address
+ * @name: driver name
+ *
+ * This function returns an error code
+ * No interrupts active, the IRQ has not been requested yet
+ * Kernel assumes 32-bit DMA operations by default, no need to dma_set_mask
+ */
+static int udc_probe(struct device *dev, void __iomem *regs, const char *name)
+{
+        struct ci13xxx *udc;
+        int retval = 0;
+
+        trace("%p, %p, %p", dev, regs, name);
+
+        if (dev == NULL || regs == NULL || name == NULL)
+                return -EINVAL;
+
+        udc = kzalloc(sizeof(struct ci13xxx), GFP_KERNEL);
+        if (udc == NULL)
+                return -ENOMEM;
+
+        udc->lock = &udc_lock;
+
+        retval = hw_device_reset(regs);
+        if (retval)
+                goto done;
+
+        udc->gadget.ops          = NULL;
+        udc->gadget.speed        = USB_SPEED_UNKNOWN;
+        udc->gadget.is_dualspeed = 1;
+        udc->gadget.is_otg       = 0;
+        udc->gadget.name         = name;
+
+        INIT_LIST_HEAD(&udc->gadget.ep_list);
+        udc->gadget.ep0 = NULL;
+
+        strcpy(udc->gadget.dev.bus_id, "gadget");
+        udc->gadget.dev.dma_mask = dev->dma_mask;
+        udc->gadget.dev.parent   = dev;
+        udc->gadget.dev.release  = udc_release;
+
+        retval = device_register(&udc->gadget.dev);
+        if (retval)
+                goto done;
+
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
+        retval = dbg_create_files(&udc->gadget.dev);
+#endif
+        if (retval) {
+                device_unregister(&udc->gadget.dev);
+                goto done;
+        }
+
+        _udc = udc;
+        return retval;
+
+ done:
+        err("error = %i", retval);
+        kfree(udc);
+        _udc = NULL;
+        return retval;
+}
+
+/**
+ * udc_remove: parent remove must call this to remove UDC
+ *
+ * No interrupts active, the IRQ has been released
+ */
+static void udc_remove(void)
+{
+        struct ci13xxx *udc = _udc;
+
+        if (udc == NULL) {
+                err("EINVAL");
+                return;
+        }
+
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
+        dbg_remove_files(&udc->gadget.dev);
+#endif
+        device_unregister(&udc->gadget.dev);
+
+        kfree(udc);
+        _udc = NULL;
+}
+
+/******************************************************************************
+ * PCI block
+ *****************************************************************************/
+/**
+ * ci13xxx_pci_irq: interrut handler
+ * @irq:  irq number
+ * @pdev: USB Device Controller interrupt source
+ *
+ * This function returns IRQ_HANDLED if the IRQ has been handled
+ * This is an ISR don't trace, use attribute interface instead
+ */
+static irqreturn_t ci13xxx_pci_irq(int irq, void *pdev)
+{
+        if (irq == 0) {
+                dev_err(&((struct pci_dev *)pdev)->dev, "Invalid IRQ0 usage!");
+                return IRQ_HANDLED;
+        }
+        return udc_irq();
+}
+
+/**
+ * ci13xxx_pci_probe: PCI probe
+ * @pdev: USB device controller being probed
+ * @id:   PCI hotplug ID connecting controller to UDC framework
+ *
+ * This function returns an error code
+ * Allocates basic PCI resources for this USB device controller, and then
+ * invokes the udc_probe() method to start the UDC associated with it
+ */
+static int __devinit ci13xxx_pci_probe(struct pci_dev *pdev,
+                                       const struct pci_device_id *id)
+{
+        void __iomem *regs = NULL;
+        int retval = 0;
+
+        if (id == NULL)
+                return -EINVAL;
+
+        retval = pci_enable_device(pdev);
+        if (retval)
+                goto done;
+
+        if (!pdev->irq) {
+                dev_err(&pdev->dev, "No IRQ, check BIOS/PCI setup!");
+                retval = -ENODEV;
+                goto disable_device;
+        }
+
+        retval = pci_request_regions(pdev, UDC_DRIVER_NAME);
+        if (retval)
+                goto disable_device;
+
+        /* BAR 0 holds all the registers */
+        regs = pci_iomap(pdev, 0, 0);
+        if (!regs) {
+                dev_err(&pdev->dev, "Error mapping memory!");
+                retval = -EFAULT;
+                goto release_regions;
+        }
+        pci_set_drvdata(pdev, (__force void *)regs);
+
+        pci_set_master(pdev);
+        pci_try_set_mwi(pdev);
+
+        retval = udc_probe(&pdev->dev, regs, UDC_DRIVER_NAME);
+        if (retval)
+                goto iounmap;
+
+        /* our device does not have MSI capability */
+
+        retval = request_irq(pdev->irq, ci13xxx_pci_irq, IRQF_SHARED,
+                             UDC_DRIVER_NAME, pdev);
+        if (retval)
+                goto gadget_remove;
+
+        return 0;
+
+ gadget_remove:
+        udc_remove();
+ iounmap:
+        pci_iounmap(pdev, regs);
+ release_regions:
+        pci_release_regions(pdev);
+ disable_device:
+        pci_disable_device(pdev);
+ done:
+        return retval;
+}
+
+/**
+ * ci13xxx_pci_remove: PCI remove
+ * @pdev: USB Device Controller being removed
+ *
+ * Reverses the effect of ci13xxx_pci_probe(),
+ * first invoking the udc_remove() and then releases
+ * all PCI resources allocated for this USB device controller
+ */
+static void __devexit ci13xxx_pci_remove(struct pci_dev *pdev)
+{
+        free_irq(pdev->irq, pdev);
+        udc_remove();
+        pci_iounmap(pdev, (__force void __iomem *)pci_get_drvdata(pdev));
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+}
+
+/**
+ * PCI device table
+ * PCI device structure
+ *
+ * Check "pci.h" for details
+ */
+static DEFINE_PCI_DEVICE_TABLE(ci13xxx_pci_id_table) = {
+        { PCI_DEVICE(0x153F, 0x1004) },
+        { PCI_DEVICE(0x153F, 0x1006) },
+        { 0, 0, 0, 0, 0, 0, 0 /* end: all zeroes */ }
+};
+MODULE_DEVICE_TABLE(pci, ci13xxx_pci_id_table);
+
+static struct pci_driver ci13xxx_pci_driver = {
+        .name         = UDC_DRIVER_NAME,
+        .id_table     = ci13xxx_pci_id_table,
+        .probe        = ci13xxx_pci_probe,
+        .remove       = __devexit_p(ci13xxx_pci_remove),
+};
+
+/**
+ * ci13xxx_pci_init: module init
+ *
+ * Driver load
+ */
+static int __init ci13xxx_pci_init(void)
+{
+        return pci_register_driver(&ci13xxx_pci_driver);
+}
+module_init(ci13xxx_pci_init);
+
+/**
+ * ci13xxx_pci_exit: module exit
+ *
+ * Driver unload
+ */
+static void __exit ci13xxx_pci_exit(void)
+{
+        pci_unregister_driver(&ci13xxx_pci_driver);
+}
+module_exit(ci13xxx_pci_exit);
+
+MODULE_AUTHOR("MIPS - David Lopo <dlopo@chipidea.mips.com>");
+MODULE_DESCRIPTION("MIPS CI13XXX USB Peripheral Controller");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("June 2008");
diff --git a/drivers/usb/gadget/ci13xxx_udc.h b/drivers/usb/gadget/ci13xxx_udc.h
new file mode 100644
index 000000000000..4026e9cede34
--- /dev/null
+++ b/drivers/usb/gadget/ci13xxx_udc.h
@@ -0,0 +1,195 @@
+/*
+ * ci13xxx_udc.h - structures, registers, and macros MIPS USB IP core
+ *
+ * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
+ *
+ * Author: David Lopo
+ *
+ * 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.
+ *
+ * Description: MIPS USB IP core family device controller
+ *              Structures, registers and logging macros
+ */
+
+#ifndef _CI13XXX_h_
+#define _CI13XXX_h_
+
+/******************************************************************************
+ * DEFINE
+ *****************************************************************************/
+#define ENDPT_MAX          (16)
+#define CTRL_PAYLOAD_MAX   (64)
+#define RX        (0)  /* similar to USB_DIR_OUT but can be used as an index */
+#define TX        (1)  /* similar to USB_DIR_IN  but can be used as an index */
+
+/******************************************************************************
+ * STRUCTURES
+ *****************************************************************************/
+/* DMA layout of transfer descriptors */
+struct ci13xxx_td {
+        /* 0 */
+        u32 next;
+#define TD_TERMINATE          BIT(0)
+        /* 1 */
+        u32 token;
+#define TD_STATUS             (0x00FFUL <<  0)
+#define TD_STATUS_TR_ERR      BIT(3)
+#define TD_STATUS_DT_ERR      BIT(5)
+#define TD_STATUS_HALTED      BIT(6)
+#define TD_STATUS_ACTIVE      BIT(7)
+#define TD_MULTO              (0x0003UL << 10)
+#define TD_IOC                BIT(15)
+#define TD_TOTAL_BYTES        (0x7FFFUL << 16)
+        /* 2 */
+        u32 page[5];
+#define TD_CURR_OFFSET        (0x0FFFUL <<  0)
+#define TD_FRAME_NUM          (0x07FFUL <<  0)
+#define TD_RESERVED_MASK      (0x0FFFUL <<  0)
+} __attribute__ ((packed));
+
+/* DMA layout of queue heads */
+struct ci13xxx_qh {
+        /* 0 */
+        u32 cap;
+#define QH_IOS                BIT(15)
+#define QH_MAX_PKT            (0x07FFUL << 16)
+#define QH_ZLT                BIT(29)
+#define QH_MULT               (0x0003UL << 30)
+        /* 1 */
+        u32 curr;
+        /* 2 - 8 */
+        struct ci13xxx_td        td;
+        /* 9 */
+        u32 RESERVED;
+        struct usb_ctrlrequest   setup;
+} __attribute__ ((packed));
+
+/* Extension of usb_request */
+struct ci13xxx_req {
+        struct usb_request   req;
+        unsigned             map;
+        struct list_head     queue;
+        struct ci13xxx_td   *ptr;
+        dma_addr_t           dma;
+};
+
+/* Extension of usb_ep */
+struct ci13xxx_ep {
+        struct usb_ep                          ep;
+        const struct usb_endpoint_descriptor  *desc;
+        u8                                     dir;
+        u8                                     num;
+        u8                                     type;
+        char                                   name[16];
+        struct {
+                struct list_head   queue;
+                struct ci13xxx_qh *ptr;
+                dma_addr_t         dma;
+        }                                      qh[2];
+        struct usb_request                    *status;
+        int                                    wedge;
+
+        /* global resources */
+        spinlock_t                            *lock;
+        struct device                         *device;
+        struct dma_pool                       *td_pool;
+};
+
+/* CI13XXX UDC descriptor & global resources */
+struct ci13xxx {
+        spinlock_t                *lock;      /* ctrl register bank access */
+
+        struct dma_pool           *qh_pool;   /* DMA pool for queue heads */
+        struct dma_pool           *td_pool;   /* DMA pool for transfer descs */
+
+        struct usb_gadget          gadget;     /* USB slave device */
+        struct ci13xxx_ep          ci13xxx_ep[ENDPT_MAX]; /* extended endpts */
+
+        struct usb_gadget_driver  *driver;     /* 3rd party gadget driver */
+};
+
+/******************************************************************************
+ * REGISTERS
+ *****************************************************************************/
+/* register size */
+#define REG_BITS   (32)
+
+/* HCCPARAMS */
+#define HCCPARAMS_LEN         BIT(17)
+
+/* DCCPARAMS */
+#define DCCPARAMS_DEN         (0x1F << 0)
+#define DCCPARAMS_DC          BIT(7)
+
+/* TESTMODE */
+#define TESTMODE_FORCE        BIT(0)
+
+/* USBCMD */
+#define USBCMD_RS             BIT(0)
+#define USBCMD_RST            BIT(1)
+#define USBCMD_SUTW           BIT(13)
+
+/* USBSTS & USBINTR */
+#define USBi_UI               BIT(0)
+#define USBi_UEI              BIT(1)
+#define USBi_PCI              BIT(2)
+#define USBi_URI              BIT(6)
+#define USBi_SLI              BIT(8)
+
+/* DEVICEADDR */
+#define DEVICEADDR_USBADRA    BIT(24)
+#define DEVICEADDR_USBADR     (0x7FUL << 25)
+
+/* PORTSC */
+#define PORTSC_SUSP           BIT(7)
+#define PORTSC_HSP            BIT(9)
+#define PORTSC_PTC            (0x0FUL << 16)
+
+/* DEVLC */
+#define DEVLC_PSPD            (0x03UL << 25)
+#define    DEVLC_PSPD_HS      (0x02UL << 25)
+
+/* USBMODE */
+#define USBMODE_CM            (0x03UL <<  0)
+#define    USBMODE_CM_IDLE    (0x00UL <<  0)
+#define    USBMODE_CM_DEVICE  (0x02UL <<  0)
+#define    USBMODE_CM_HOST    (0x03UL <<  0)
+#define USBMODE_SLOM          BIT(3)
+
+/* ENDPTCTRL */
+#define ENDPTCTRL_RXS         BIT(0)
+#define ENDPTCTRL_RXT         (0x03UL <<  2)
+#define ENDPTCTRL_RXR         BIT(6)         /* reserved for port 0 */
+#define ENDPTCTRL_RXE         BIT(7)
+#define ENDPTCTRL_TXS         BIT(16)
+#define ENDPTCTRL_TXT         (0x03UL << 18)
+#define ENDPTCTRL_TXR         BIT(22)        /* reserved for port 0 */
+#define ENDPTCTRL_TXE         BIT(23)
+
+/******************************************************************************
+ * LOGGING
+ *****************************************************************************/
+#define ci13xxx_printk(level, format, args...) \
+do { \
+        if (_udc == NULL) \
+                printk(level "[%s] " format "\n", __func__, ## args); \
+        else \
+                dev_printk(level, _udc->gadget.dev.parent, \
+                           "[%s] " format "\n", __func__, ## args); \
+} while (0)
+
+#define err(format, args...)    ci13xxx_printk(KERN_ERR, format, ## args)
+#define warn(format, args...)   ci13xxx_printk(KERN_WARNING, format, ## args)
+#define info(format, args...)   ci13xxx_printk(KERN_INFO, format, ## args)
+
+#ifdef TRACE
+#define trace(format, args...)      ci13xxx_printk(KERN_DEBUG, format, ## args)
+#define dbg_trace(format, args...)  dev_dbg(dev, format, ##args)
+#else
+#define trace(format, args...)      do {} while (0)
+#define dbg_trace(format, args...)  do {} while (0)
+#endif
+
+#endif  /* _CI13XXX_h_ */
diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
index 9462e30192d8..a36b1175b18d 100644
--- a/drivers/usb/gadget/epautoconf.c
+++ b/drivers/usb/gadget/epautoconf.c
@@ -161,7 +161,7 @@ ep_matches (
         /* report address */
         desc->bEndpointAddress &= USB_DIR_IN;
         if (isdigit (ep->name [2])) {
-                u8      num = simple_strtol (&ep->name [2], NULL, 10);
+                u8      num = simple_strtoul (&ep->name [2], NULL, 10);
                 desc->bEndpointAddress |= num;
 #ifdef  MANY_ENDPOINTS
         } else if (desc->bEndpointAddress & USB_DIR_IN) {
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 2e71368f45b4..b10fa31cc915 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -1,7 +1,7 @@
 /*
  * file_storage.c -- File-backed USB Storage Gadget, for USB development
  *
- * Copyright (C) 2003-2007 Alan Stern
+ * Copyright (C) 2003-2008 Alan Stern
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,16 +38,17 @@
 
 /*
  * 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.
+ * appearing to the host as a disk drive or as a CD-ROM 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 will indicate that
- * it has removable media if the optional "removable" module parameter is set.
+ * setting the optional "ro" module parameter.  (For CD-ROM emulation,
+ * access is always read-only.)  The gadget will indicate that it has
+ * removable media if the optional "removable" module parameter is set.
  *
  * The gadget supports the Control-Bulk (CB), Control-Bulk-Interrupt (CBI),
  * and Bulk-Only (also known as Bulk-Bulk-Bulk or BBB) transports, selected
@@ -64,7 +65,12 @@
  * 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.
+ * or empty backing filename means the LUN's medium is not loaded.  Ideally
+ * each LUN would be settable independently as a disk drive or a CD-ROM
+ * drive, but currently all LUNs have to be the same type.  The CD-ROM
+ * emulation includes a single data track and no audio tracks; hence there
+ * need be only one backing file per LUN.  Note also that the CD-ROM block
+ * length is set to 512 rather than the more common value 2048.
  *
  * 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
@@ -91,6 +97,8 @@
  *                                      USB device controller (usually true),
  *                                      boolean to permit the driver to halt
  *                                      bulk endpoints
+ *      cdrom                   Default false, boolean for whether to emulate
+ *                                      a CD-ROM drive
  *      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;
@@ -103,15 +111,16 @@
  *                                      PAGE_CACHE_SIZE)
  *
  * If CONFIG_USB_FILE_STORAGE_TEST is not set, only the "file", "ro",
- * "removable", "luns", and "stall" options are available; default values
- * are used for everything else.
+ * "removable", "luns", "stall", and "cdrom" options are available; default
+ * values are used for everything else.
  *
  * The pathnames of the backing files and the ro settings are available in
  * the attribute files "file" and "ro" in the lun<n> subdirectory of the
  * gadget's sysfs directory.  If the "removable" option is set, writing to
  * these files will simulate ejecting/loading the medium (writing an empty
  * line means eject) and adjusting a write-enable tab.  Changes to the ro
- * setting are not allowed when the medium is loaded.
+ * setting are not allowed when the medium is loaded or if CD-ROM emulation
+ * is being used.
  *
  * This gadget driver is heavily based on "Gadget Zero" by David Brownell.
  * The driver's SCSI command interface was based on the "Information
@@ -261,7 +270,7 @@
 
 #define DRIVER_DESC             "File-backed Storage Gadget"
 #define DRIVER_NAME             "g_file_storage"
-#define DRIVER_VERSION          "7 August 2007"
+#define DRIVER_VERSION          "20 November 2008"
 
 static const char longname[] = DRIVER_DESC;
 static const char shortname[] = DRIVER_NAME;
@@ -341,6 +350,7 @@ static struct {
 
         int             removable;
         int             can_stall;
+        int             cdrom;
 
         char            *transport_parm;
         char            *protocol_parm;
@@ -359,6 +369,7 @@ static struct {
         .protocol_parm          = "SCSI",
         .removable              = 0,
         .can_stall              = 1,
+        .cdrom                  = 0,
         .vendor                 = DRIVER_VENDOR_ID,
         .product                = DRIVER_PRODUCT_ID,
         .release                = 0xffff,       // Use controller chip type
@@ -382,6 +393,9 @@ MODULE_PARM_DESC(removable, "true to simulate removable media");
 module_param_named(stall, mod_data.can_stall, bool, S_IRUGO);
 MODULE_PARM_DESC(stall, "false to prevent bulk stalls");
 
+module_param_named(cdrom, mod_data.cdrom, bool, S_IRUGO);
+MODULE_PARM_DESC(cdrom, "true to emulate cdrom instead of disk");
+
 
 /* In the non-TEST version, only the module parameters listed above
  * are available. */
@@ -411,6 +425,10 @@ MODULE_PARM_DESC(buflen, "I/O buffer size");
 
 /*-------------------------------------------------------------------------*/
 
+/* SCSI device types */
+#define TYPE_DISK       0x00
+#define TYPE_CDROM      0x05
+
 /* USB protocol value = the transport method */
 #define USB_PR_CBI      0x00            // Control/Bulk/Interrupt
 #define USB_PR_CB       0x01            // Control/Bulk w/o interrupt
@@ -487,6 +505,8 @@ struct interrupt_data {
 #define SC_READ_12                      0xa8
 #define SC_READ_CAPACITY                0x25
 #define SC_READ_FORMAT_CAPACITIES       0x23
+#define SC_READ_HEADER                  0x44
+#define SC_READ_TOC                     0x43
 #define SC_RELEASE                      0x17
 #define SC_REQUEST_SENSE                0x03
 #define SC_RESERVE                      0x16
@@ -2006,23 +2026,28 @@ 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";
+        static char product_disk_id[] = "File-Stor Gadget";
+        static char product_cdrom_id[] = "File-CD Gadget  ";
 
         if (!fsg->curlun) {             // Unsupported LUNs are okay
                 fsg->bad_lun_okay = 1;
                 memset(buf, 0, 36);
                 buf[0] = 0x7f;          // Unsupported, no device-type
+                buf[4] = 31;            // Additional length
                 return 36;
         }
 
-        memset(buf, 0, 8);      // Non-removable, direct-access device
+        memset(buf, 0, 8);
+        buf[0] = (mod_data.cdrom ? TYPE_CDROM : TYPE_DISK);
         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,
+        sprintf(buf + 8, "%-8s%-16s%04x", vendor_id,
+                        (mod_data.cdrom ? product_cdrom_id :
+                                product_disk_id),
                         mod_data.release);
         return 36;
 }
@@ -2101,6 +2126,75 @@ static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 }
 
 
+static void store_cdrom_address(u8 *dest, int msf, u32 addr)
+{
+        if (msf) {
+                /* Convert to Minutes-Seconds-Frames */
+                addr >>= 2;             /* Convert to 2048-byte frames */
+                addr += 2*75;           /* Lead-in occupies 2 seconds */
+                dest[3] = addr % 75;    /* Frames */
+                addr /= 75;
+                dest[2] = addr % 60;    /* Seconds */
+                addr /= 60;
+                dest[1] = addr;         /* Minutes */
+                dest[0] = 0;            /* Reserved */
+        } else {
+                /* Absolute sector */
+                put_be32(dest, addr);
+        }
+}
+
+static int do_read_header(struct fsg_dev *fsg, struct fsg_buffhd *bh)
+{
+        struct lun      *curlun = fsg->curlun;
+        int             msf = fsg->cmnd[1] & 0x02;
+        u32             lba = get_be32(&fsg->cmnd[2]);
+        u8              *buf = (u8 *) bh->buf;
+
+        if ((fsg->cmnd[1] & ~0x02) != 0) {              /* Mask away MSF */
+                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;
+        }
+
+        memset(buf, 0, 8);
+        buf[0] = 0x01;          /* 2048 bytes of user data, rest is EC */
+        store_cdrom_address(&buf[4], msf, lba);
+        return 8;
+}
+
+
+static int do_read_toc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
+{
+        struct lun      *curlun = fsg->curlun;
+        int             msf = fsg->cmnd[1] & 0x02;
+        int             start_track = fsg->cmnd[6];
+        u8              *buf = (u8 *) bh->buf;
+
+        if ((fsg->cmnd[1] & ~0x02) != 0 ||              /* Mask away MSF */
+                        start_track > 1) {
+                curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                return -EINVAL;
+        }
+
+        memset(buf, 0, 20);
+        buf[1] = (20-2);                /* TOC data length */
+        buf[2] = 1;                     /* First track number */
+        buf[3] = 1;                     /* Last track number */
+        buf[5] = 0x16;                  /* Data track, copying allowed */
+        buf[6] = 0x01;                  /* Only track is number 1 */
+        store_cdrom_address(&buf[8], msf, 0);
+
+        buf[13] = 0x16;                 /* Lead-out track is data */
+        buf[14] = 0xAA;                 /* Lead-out track number */
+        store_cdrom_address(&buf[16], msf, curlun->num_sectors);
+        return 20;
+}
+
+
 static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
         struct lun      *curlun = fsg->curlun;
@@ -2848,6 +2942,26 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_read_capacity(fsg, bh);
                 break;
 
+        case SC_READ_HEADER:
+                if (!mod_data.cdrom)
+                        goto unknown_cmnd;
+                fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]);
+                if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
+                                (3<<7) | (0x1f<<1), 1,
+                                "READ HEADER")) == 0)
+                        reply = do_read_header(fsg, bh);
+                break;
+
+        case SC_READ_TOC:
+                if (!mod_data.cdrom)
+                        goto unknown_cmnd;
+                fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]);
+                if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
+                                (7<<6) | (1<<1), 1,
+                                "READ TOC")) == 0)
+                        reply = do_read_toc(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,
@@ -2933,6 +3047,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                 // Fall through
 
         default:
+ unknown_cmnd:
                 fsg->data_size_from_cmnd = 0;
                 sprintf(unknown, "Unknown x%02x", fsg->cmnd[0]);
                 if ((reply = check_command(fsg, fsg->cmnd_size,
@@ -3498,6 +3613,7 @@ static int open_backing_file(struct lun *curlun, const char *filename)
         struct inode                    *inode = NULL;
         loff_t                          size;
         loff_t                          num_sectors;
+        loff_t                          min_sectors;
 
         /* R/W if we can, R/O if we must */
         ro = curlun->ro;
@@ -3541,8 +3657,19 @@ static int open_backing_file(struct lun *curlun, const char *filename)
                 rc = (int) size;
                 goto out;
         }
-        num_sectors = size >> 9;        // File size in 512-byte sectors
-        if (num_sectors == 0) {
+        num_sectors = size >> 9;        // File size in 512-byte blocks
+        min_sectors = 1;
+        if (mod_data.cdrom) {
+                num_sectors &= ~3;      // Reduce to a multiple of 2048
+                min_sectors = 300*4;    // Smallest track is 300 frames
+                if (num_sectors >= 256*60*75*4) {
+                        num_sectors = (256*60*75 - 1) * 4;
+                        LINFO(curlun, "file too big: %s\n", filename);
+                        LINFO(curlun, "using only first %d blocks\n",
+                                        (int) num_sectors);
+                }
+        }
+        if (num_sectors < min_sectors) {
                 LINFO(curlun, "file too small: %s\n", filename);
                 rc = -ETOOSMALL;
                 goto out;
@@ -3845,9 +3972,12 @@ static int __init fsg_bind(struct usb_gadget *gadget)
                 goto out;
 
         if (mod_data.removable) {       // Enable the store_xxx attributes
-                dev_attr_ro.attr.mode = dev_attr_file.attr.mode = 0644;
-                dev_attr_ro.store = store_ro;
+                dev_attr_file.attr.mode = 0644;
                 dev_attr_file.store = store_file;
+                if (!mod_data.cdrom) {
+                        dev_attr_ro.attr.mode = 0644;
+                        dev_attr_ro.store = store_ro;
+                }
         }
 
         /* Find out how many LUNs there should be */
@@ -3872,6 +4002,8 @@ static int __init fsg_bind(struct usb_gadget *gadget)
         for (i = 0; i < fsg->nluns; ++i) {
                 curlun = &fsg->luns[i];
                 curlun->ro = mod_data.ro[i];
+                if (mod_data.cdrom)
+                        curlun->ro = 1;
                 curlun->dev.release = lun_release;
                 curlun->dev.parent = &gadget->dev;
                 curlun->dev.driver = &fsg_driver.driver;
@@ -4031,9 +4163,9 @@ static int __init fsg_bind(struct usb_gadget *gadget)
                         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",
+        DBG(fsg, "removable=%d, stall=%d, cdrom=%d, buflen=%u\n",
                         mod_data.removable, mod_data.can_stall,
-                        mod_data.buflen);
+                        mod_data.cdrom, mod_data.buflen);
         DBG(fsg, "I/O thread pid: %d\n", task_pid_nr(fsg->thread_task));
 
         set_bit(REGISTERED, &fsg->atomic_bitflags);
@@ -4050,6 +4182,7 @@ out:
         fsg->state = FSG_STATE_TERMINATED;      // The thread is dead
         fsg_unbind(gadget);
         close_all_backing_files(fsg);
+        complete(&fsg->thread_notifier);
         return rc;
 }
 
diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index f40272565098..d6c5bcd40064 100644
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -26,6 +26,7 @@
 #include <linux/ioport.h>
 #include <linux/types.h>
 #include <linux/errno.h>
+#include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/interrupt.h>
@@ -370,6 +371,9 @@ static int qe_ep_bd_init(struct qe_udc *udc, unsigned char pipe_num)
         /* alloc multi-ram for BD rings and set the ep parameters */
         tmp_addr = cpm_muram_alloc(sizeof(struct qe_bd) * (bdring_len +
                                 USB_BDRING_LEN_TX), QE_ALIGNMENT_OF_BD);
+        if (IS_ERR_VALUE(tmp_addr))
+                return -ENOMEM;
+
         out_be16(&epparam->rbase, (u16)tmp_addr);
         out_be16(&epparam->tbase, (u16)(tmp_addr +
                                 (sizeof(struct qe_bd) * bdring_len)));
@@ -689,7 +693,7 @@ en_done2:
 en_done1:
         spin_unlock_irqrestore(&udc->lock, flags);
 en_done:
-        dev_dbg(udc->dev, "failed to initialize %s\n", ep->ep.name);
+        dev_err(udc->dev, "failed to initialize %s\n", ep->ep.name);
         return -ENODEV;
 }
 
@@ -2408,6 +2412,8 @@ static struct qe_udc __devinit *qe_udc_config(struct of_device *ofdev)
         tmp_addr = cpm_muram_alloc((USB_MAX_ENDPOINTS *
                                         sizeof(struct usb_ep_para)),
                                            USB_EP_PARA_ALIGNMENT);
+        if (IS_ERR_VALUE(tmp_addr))
+                goto cleanup;
 
         for (i = 0; i < USB_MAX_ENDPOINTS; i++) {
                 out_be16(&usbpram->epptr[i], (u16)tmp_addr);
@@ -2513,7 +2519,7 @@ static int __devinit qe_udc_probe(struct of_device *ofdev,
         /* Initialize the udc structure including QH member and other member */
         udc_controller = qe_udc_config(ofdev);
         if (!udc_controller) {
-                dev_dbg(&ofdev->dev, "udc_controll is NULL\n");
+                dev_err(&ofdev->dev, "failed to initialize\n");
                 return -ENOMEM;
         }
 
@@ -2568,7 +2574,7 @@ static int __devinit qe_udc_probe(struct of_device *ofdev,
         /* create a buf for ZLP send, need to remain zeroed */
         udc_controller->nullbuf = kzalloc(256, GFP_KERNEL);
         if (udc_controller->nullbuf == NULL) {
-                dev_dbg(udc_controller->dev, "cannot alloc nullbuf\n");
+                dev_err(udc_controller->dev, "cannot alloc nullbuf\n");
                 ret = -ENOMEM;
                 goto err3;
         }
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index 4e3107dd2f34..ec6d439a2aa5 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -110,7 +110,6 @@
 #define gadget_is_at91(g)       0
 #endif
 
-/* status unclear */
 #ifdef CONFIG_USB_GADGET_IMX
 #define gadget_is_imx(g)        !strcmp("imx_udc", (g)->name)
 #else
@@ -158,6 +157,11 @@
 #define gadget_is_fsl_qe(g)     0
 #endif
 
+#ifdef CONFIG_USB_GADGET_CI13XXX
+#define gadget_is_ci13xxx(g)    (!strcmp("ci13xxx_udc", (g)->name))
+#else
+#define gadget_is_ci13xxx(g)    0
+#endif
 
 // CONFIG_USB_GADGET_SX2
 // CONFIG_USB_GADGET_AU1X00
@@ -225,6 +229,8 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x21;
         else if (gadget_is_fsl_qe(gadget))
                 return 0x22;
+        else if (gadget_is_ci13xxx(gadget))
+                return 0x23;
         return -ENOENT;
 }
 
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 60aa04847b18..63419c4d503c 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -1349,7 +1349,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         int                     retval;
 
         if (!driver
-                        || driver->speed != USB_SPEED_FULL
+                        || driver->speed < USB_SPEED_FULL
                         || !driver->bind
                         || !driver->disconnect
                         || !driver->setup)
diff --git a/drivers/usb/gadget/imx_udc.c b/drivers/usb/gadget/imx_udc.c
new file mode 100644
index 000000000000..cde8fdf15d5b
--- /dev/null
+++ b/drivers/usb/gadget/imx_udc.c
@@ -0,0 +1,1516 @@
+/*
+ *      driver/usb/gadget/imx_udc.c
+ *
+ *      Copyright (C) 2005 Mike Lee(eemike@gmail.com)
+ *      Copyright (C) 2008 Darius Augulis <augulis.darius@gmail.com>
+ *
+ *      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.
+ */
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+#include <mach/usb.h>
+#include <mach/hardware.h>
+
+#include "imx_udc.h"
+
+static const char driver_name[] = "imx_udc";
+static const char ep0name[] = "ep0";
+
+void ep0_chg_stat(const char *label, struct imx_udc_struct *imx_usb,
+                                                        enum ep0_state stat);
+
+/*******************************************************************************
+ * IMX UDC hardware related functions
+ *******************************************************************************
+ */
+
+void imx_udc_enable(struct imx_udc_struct *imx_usb)
+{
+        int temp = __raw_readl(imx_usb->base + USB_CTRL);
+        __raw_writel(temp | CTRL_FE_ENA | CTRL_AFE_ENA, imx_usb->base + USB_CTRL);
+        imx_usb->gadget.speed = USB_SPEED_FULL;
+}
+
+void imx_udc_disable(struct imx_udc_struct *imx_usb)
+{
+        int temp = __raw_readl(imx_usb->base + USB_CTRL);
+
+        __raw_writel(temp & ~(CTRL_FE_ENA | CTRL_AFE_ENA),
+                 imx_usb->base + USB_CTRL);
+
+        ep0_chg_stat(__func__, imx_usb, EP0_IDLE);
+        imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
+}
+
+void imx_udc_reset(struct imx_udc_struct *imx_usb)
+{
+        int temp = __raw_readl(imx_usb->base + USB_ENAB);
+
+        /* set RST bit */
+        __raw_writel(temp | ENAB_RST, imx_usb->base + USB_ENAB);
+
+        /* wait RST bit to clear */
+        do {} while (__raw_readl(imx_usb->base + USB_ENAB) & ENAB_RST);
+
+        /* wait CFG bit to assert */
+        do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG));
+
+        /* udc module is now ready */
+}
+
+void imx_udc_config(struct imx_udc_struct *imx_usb)
+{
+        u8 ep_conf[5];
+        u8 i, j, cfg;
+        struct imx_ep_struct *imx_ep;
+
+        /* wait CFG bit to assert */
+        do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG));
+
+        /* Download the endpoint buffer for endpoint 0. */
+        for (j = 0; j < 5; j++) {
+                i = (j == 2 ? imx_usb->imx_ep[0].fifosize : 0x00);
+                __raw_writeb(i, imx_usb->base + USB_DDAT);
+                do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_BSY);
+        }
+
+        /* Download the endpoint buffers for endpoints 1-5.
+         * We specify two configurations, one interface
+         */
+        for (cfg = 1; cfg < 3; cfg++) {
+                for (i = 1; i < IMX_USB_NB_EP; i++) {
+                        imx_ep = &imx_usb->imx_ep[i];
+                        /* EP no | Config no */
+                        ep_conf[0] = (i << 4) | (cfg << 2);
+                        /* Type | Direction */
+                        ep_conf[1] = (imx_ep->bmAttributes << 3) |
+                                        (EP_DIR(imx_ep) << 2);
+                        /* Max packet size */
+                        ep_conf[2] = imx_ep->fifosize;
+                        /* TRXTYP */
+                        ep_conf[3] = 0xC0;
+                        /* FIFO no */
+                        ep_conf[4] = i;
+
+                        D_INI(imx_usb->dev,
+                                "<%s> ep%d_conf[%d]:"
+                                "[%02x-%02x-%02x-%02x-%02x]\n",
+                                __func__, i, cfg,
+                                ep_conf[0], ep_conf[1], ep_conf[2],
+                                ep_conf[3], ep_conf[4]);
+
+                        for (j = 0; j < 5; j++) {
+                                __raw_writeb(ep_conf[j],
+                                        imx_usb->base + USB_DDAT);
+                                do {} while (__raw_readl(imx_usb->base + USB_DADR)
+                                        & DADR_BSY);
+                        }
+                }
+        }
+
+        /* wait CFG bit to clear */
+        do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG);
+}
+
+void imx_udc_init_irq(struct imx_udc_struct *imx_usb)
+{
+        int i;
+
+        /* Mask and clear all irqs */
+        __raw_writel(0xFFFFFFFF, imx_usb->base + USB_MASK);
+        __raw_writel(0xFFFFFFFF, imx_usb->base + USB_INTR);
+        for (i = 0; i < IMX_USB_NB_EP; i++) {
+                __raw_writel(0x1FF, imx_usb->base + USB_EP_MASK(i));
+                __raw_writel(0x1FF, imx_usb->base + USB_EP_INTR(i));
+        }
+
+        /* Enable USB irqs */
+        __raw_writel(INTR_MSOF | INTR_FRAME_MATCH, imx_usb->base + USB_MASK);
+
+        /* Enable EP0 irqs */
+        __raw_writel(0x1FF & ~(EPINTR_DEVREQ | EPINTR_MDEVREQ | EPINTR_EOT
+                | EPINTR_EOF | EPINTR_FIFO_EMPTY | EPINTR_FIFO_FULL),
+                imx_usb->base + USB_EP_MASK(0));
+}
+
+void imx_udc_init_ep(struct imx_udc_struct *imx_usb)
+{
+        int i, max, temp;
+        struct imx_ep_struct *imx_ep;
+        for (i = 0; i < IMX_USB_NB_EP; i++) {
+                imx_ep = &imx_usb->imx_ep[i];
+                switch (imx_ep->fifosize) {
+                case 8:
+                        max = 0;
+                        break;
+                case 16:
+                        max = 1;
+                        break;
+                case 32:
+                        max = 2;
+                        break;
+                case 64:
+                        max = 3;
+                        break;
+                default:
+                        max = 1;
+                        break;
+                }
+                temp = (EP_DIR(imx_ep) << 7) | (max << 5)
+                        | (imx_ep->bmAttributes << 3);
+                __raw_writel(temp, imx_usb->base + USB_EP_STAT(i));
+                __raw_writel(temp | EPSTAT_FLUSH, imx_usb->base + USB_EP_STAT(i));
+                D_INI(imx_usb->dev, "<%s> ep%d_stat %08x\n", __func__, i,
+                        __raw_readl(imx_usb->base + USB_EP_STAT(i)));
+        }
+}
+
+void imx_udc_init_fifo(struct imx_udc_struct *imx_usb)
+{
+        int i, temp;
+        struct imx_ep_struct *imx_ep;
+        for (i = 0; i < IMX_USB_NB_EP; i++) {
+                imx_ep = &imx_usb->imx_ep[i];
+
+                /* Fifo control */
+                temp = EP_DIR(imx_ep) ? 0x0B000000 : 0x0F000000;
+                __raw_writel(temp, imx_usb->base + USB_EP_FCTRL(i));
+                D_INI(imx_usb->dev, "<%s> ep%d_fctrl %08x\n", __func__, i,
+                        __raw_readl(imx_usb->base + USB_EP_FCTRL(i)));
+
+                /* Fifo alarm */
+                temp = (i ? imx_ep->fifosize / 2 : 0);
+                __raw_writel(temp, imx_usb->base + USB_EP_FALRM(i));
+                D_INI(imx_usb->dev, "<%s> ep%d_falrm %08x\n", __func__, i,
+                        __raw_readl(imx_usb->base + USB_EP_FALRM(i)));
+        }
+}
+
+static void imx_udc_init(struct imx_udc_struct *imx_usb)
+{
+        /* Reset UDC */
+        imx_udc_reset(imx_usb);
+
+        /* Download config to enpoint buffer */
+        imx_udc_config(imx_usb);
+
+        /* Setup interrups */
+        imx_udc_init_irq(imx_usb);
+
+        /* Setup endpoints */
+        imx_udc_init_ep(imx_usb);
+
+        /* Setup fifos */
+        imx_udc_init_fifo(imx_usb);
+}
+
+void imx_ep_irq_enable(struct imx_ep_struct *imx_ep)
+{
+
+        int i = EP_NO(imx_ep);
+
+        __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i));
+        __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i));
+        __raw_writel(0x1FF & ~(EPINTR_EOT | EPINTR_EOF),
+                imx_ep->imx_usb->base + USB_EP_MASK(i));
+}
+
+void imx_ep_irq_disable(struct imx_ep_struct *imx_ep)
+{
+
+        int i = EP_NO(imx_ep);
+
+        __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i));
+        __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i));
+}
+
+int imx_ep_empty(struct imx_ep_struct *imx_ep)
+{
+        struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
+
+        return __raw_readl(imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)))
+                        & FSTAT_EMPTY;
+}
+
+unsigned imx_fifo_bcount(struct imx_ep_struct *imx_ep)
+{
+        struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
+
+        return (__raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)))
+                        & EPSTAT_BCOUNT) >> 16;
+}
+
+void imx_flush(struct imx_ep_struct *imx_ep)
+{
+        struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
+
+        int temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+        __raw_writel(temp | EPSTAT_FLUSH,
+                imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+}
+
+void imx_ep_stall(struct imx_ep_struct *imx_ep)
+{
+        struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
+        int temp, i;
+
+        D_ERR(imx_usb->dev, "<%s> Forced stall on %s\n", __func__, imx_ep->ep.name);
+
+        imx_flush(imx_ep);
+
+        /* Special care for ep0 */
+        if (EP_NO(imx_ep)) {
+                temp = __raw_readl(imx_usb->base + USB_CTRL);
+                __raw_writel(temp | CTRL_CMDOVER | CTRL_CMDERROR, imx_usb->base + USB_CTRL);
+                do { } while (__raw_readl(imx_usb->base + USB_CTRL) & CTRL_CMDOVER);
+                temp = __raw_readl(imx_usb->base + USB_CTRL);
+                __raw_writel(temp & ~CTRL_CMDERROR, imx_usb->base + USB_CTRL);
+        }
+        else {
+                temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+                __raw_writel(temp | EPSTAT_STALL,
+                        imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+
+                for (i = 0; i < 100; i ++) {
+                        temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+                        if (!temp & EPSTAT_STALL)
+                                break;
+                        udelay(20);
+                }
+                if (i == 50)
+                        D_ERR(imx_usb->dev, "<%s> Non finished stall on %s\n",
+                                __func__, imx_ep->ep.name);
+        }
+}
+
+static int imx_udc_get_frame(struct usb_gadget *_gadget)
+{
+        struct imx_udc_struct *imx_usb = container_of(_gadget,
+                        struct imx_udc_struct, gadget);
+
+        return __raw_readl(imx_usb->base + USB_FRAME) & 0x7FF;
+}
+
+static int imx_udc_wakeup(struct usb_gadget *_gadget)
+{
+        return 0;
+}
+
+/*******************************************************************************
+ * USB request control functions
+ *******************************************************************************
+ */
+
+static void ep_add_request(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        if (unlikely(!req))
+                return;
+
+        req->in_use = 1;
+        list_add_tail(&req->queue, &imx_ep->queue);
+}
+
+static void ep_del_request(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        if (unlikely(!req))
+                return;
+
+        list_del_init(&req->queue);
+        req->in_use = 0;
+}
+
+static void done(struct imx_ep_struct *imx_ep, struct imx_request *req, int status)
+{
+        ep_del_request(imx_ep, req);
+
+        if (likely(req->req.status == -EINPROGRESS))
+                req->req.status = status;
+        else
+                status = req->req.status;
+
+        if (status && status != -ESHUTDOWN)
+                D_ERR(imx_ep->imx_usb->dev,
+                        "<%s> complete %s req %p stat %d len %u/%u\n", __func__,
+                        imx_ep->ep.name, &req->req, status,
+                        req->req.actual, req->req.length);
+
+        req->req.complete(&imx_ep->ep, &req->req);
+}
+
+static void nuke(struct imx_ep_struct *imx_ep, int status)
+{
+        struct imx_request *req;
+
+        while (!list_empty(&imx_ep->queue)) {
+                req = list_entry(imx_ep->queue.next, struct imx_request, queue);
+                done(imx_ep, req, status);
+        }
+}
+
+/*******************************************************************************
+ * Data tansfer over USB functions
+ *******************************************************************************
+ */
+static int read_packet(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        u8      *buf;
+        int     bytes_ep, bufferspace, count, i;
+
+        bytes_ep = imx_fifo_bcount(imx_ep);
+        bufferspace = req->req.length - req->req.actual;
+
+        buf = req->req.buf + req->req.actual;
+        prefetchw(buf);
+
+        if (unlikely(imx_ep_empty(imx_ep)))
+                count = 0;      /* zlp */
+        else
+                count = min(bytes_ep, bufferspace);
+
+        for (i = count; i > 0; i--)
+                *buf++ = __raw_readb(imx_ep->imx_usb->base
+                                                + USB_EP_FDAT0(EP_NO(imx_ep)));
+        req->req.actual += count;
+
+        return count;
+}
+
+static int write_packet(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        u8      *buf;
+        int     length, count, temp;
+
+        buf = req->req.buf + req->req.actual;
+        prefetch(buf);
+
+        length = min(req->req.length - req->req.actual, (u32)imx_ep->fifosize);
+
+        if (imx_fifo_bcount(imx_ep) + length > imx_ep->fifosize) {
+                D_TRX(imx_ep->imx_usb->dev, "<%s> packet overfill %s fifo\n",
+                        __func__, imx_ep->ep.name);
+                return -1;
+        }
+
+        req->req.actual += length;
+        count = length;
+
+        if (!count && req->req.zero) {  /* zlp */
+                temp = __raw_readl(imx_ep->imx_usb->base
+                        + USB_EP_STAT(EP_NO(imx_ep)));
+                __raw_writel(temp | EPSTAT_ZLPS, imx_ep->imx_usb->base
+                        + USB_EP_STAT(EP_NO(imx_ep)));
+                D_TRX(imx_ep->imx_usb->dev, "<%s> zero packet\n", __func__);
+                return 0;
+        }
+
+        while (count--) {
+                if (count == 0) {       /* last byte */
+                        temp = __raw_readl(imx_ep->imx_usb->base
+                                + USB_EP_FCTRL(EP_NO(imx_ep)));
+                        __raw_writel(temp | FCTRL_WFR, imx_ep->imx_usb->base
+                                + USB_EP_FCTRL(EP_NO(imx_ep)));
+                }
+                __raw_writeb(*buf++,
+                        imx_ep->imx_usb->base + USB_EP_FDAT0(EP_NO(imx_ep)));
+        }
+
+        return length;
+}
+
+static int read_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        int     bytes = 0,
+                count,
+                completed = 0;
+
+        while (__raw_readl(imx_ep->imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)))
+                & FSTAT_FR) {
+                        count = read_packet(imx_ep, req);
+                        bytes += count;
+
+                        completed = (count != imx_ep->fifosize);
+                        if (completed || req->req.actual == req->req.length) {
+                                completed = 1;
+                                break;
+                        }
+        }
+
+        if (completed || !req->req.length) {
+                done(imx_ep, req, 0);
+                D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
+                        __func__, imx_ep->ep.name, req,
+                        completed ? "completed" : "not completed");
+                if (!EP_NO(imx_ep))
+                        ep0_chg_stat(__func__, imx_ep->imx_usb, EP0_IDLE);
+        }
+
+        D_TRX(imx_ep->imx_usb->dev, "<%s> bytes read: %d\n", __func__, bytes);
+
+        return completed;
+}
+
+static int write_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        int     bytes = 0,
+                count,
+                completed = 0;
+
+        while (!completed) {
+                count = write_packet(imx_ep, req);
+                if (count < 0)
+                        break; /* busy */
+                bytes += count;
+
+                /* last packet "must be" short (or a zlp) */
+                completed = (count != imx_ep->fifosize);
+
+                if (unlikely(completed)) {
+                        done(imx_ep, req, 0);
+                        D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
+                                __func__, imx_ep->ep.name, req,
+                                completed ? "completed" : "not completed");
+                        if (!EP_NO(imx_ep))
+                                ep0_chg_stat(__func__, imx_ep->imx_usb, EP0_IDLE);
+                }
+        }
+
+        D_TRX(imx_ep->imx_usb->dev, "<%s> bytes sent: %d\n", __func__, bytes);
+
+        return completed;
+}
+
+/*******************************************************************************
+ * Endpoint handlers
+ *******************************************************************************
+ */
+static int handle_ep(struct imx_ep_struct *imx_ep)
+{
+        struct imx_request *req;
+        int completed = 0;
+
+        do {
+                if (!list_empty(&imx_ep->queue))
+                        req = list_entry(imx_ep->queue.next,
+                                struct imx_request, queue);
+                else {
+                        D_REQ(imx_ep->imx_usb->dev, "<%s> no request on %s\n",
+                                __func__, imx_ep->ep.name);
+                        return 0;
+                }
+
+                if (EP_DIR(imx_ep))     /* to host */
+                        completed = write_fifo(imx_ep, req);
+                else                    /* to device */
+                        completed = read_fifo(imx_ep, req);
+
+                dump_ep_stat(__func__, imx_ep);
+
+        } while (completed);
+
+        return 0;
+}
+
+static int handle_ep0(struct imx_ep_struct *imx_ep)
+{
+        struct imx_request *req = NULL;
+        int ret = 0;
+
+        if (!list_empty(&imx_ep->queue))
+                req = list_entry(imx_ep->queue.next, struct imx_request, queue);
+
+        if (req) {
+                switch (imx_ep->imx_usb->ep0state) {
+
+                case EP0_IN_DATA_PHASE:                 /* GET_DESCRIPTOR */
+                        write_fifo(imx_ep, req);
+                        break;
+                case EP0_OUT_DATA_PHASE:                /* SET_DESCRIPTOR */
+                        read_fifo(imx_ep, req);
+                        break;
+                default:
+                        D_EP0(imx_ep->imx_usb->dev,
+                                "<%s> ep0 i/o, odd state %d\n",
+                                __func__, imx_ep->imx_usb->ep0state);
+                        ep_del_request(imx_ep, req);
+                        ret = -EL2HLT;
+                        break;
+                }
+        }
+
+        return ret;
+}
+
+static void handle_ep0_devreq(struct imx_udc_struct *imx_usb)
+{
+        struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
+        union {
+                struct usb_ctrlrequest  r;
+                u8                      raw[8];
+                u32                     word[2];
+        } u;
+        int temp, i;
+
+        nuke(imx_ep, -EPROTO);
+
+        /* read SETUP packet */
+        for (i = 0; i < 2; i++) {
+                if (imx_ep_empty(imx_ep)) {
+                        D_ERR(imx_usb->dev,
+                                "<%s> no setup packet received\n", __func__);
+                        goto stall;
+                }
+                u.word[i] = __raw_readl(imx_usb->base + USB_EP_FDAT(EP_NO(imx_ep)));
+        }
+
+        temp = imx_ep_empty(imx_ep);
+        while (!imx_ep_empty(imx_ep)) {
+                i = __raw_readl(imx_usb->base + USB_EP_FDAT(EP_NO(imx_ep)));
+                D_ERR(imx_usb->dev,
+                        "<%s> wrong to have extra bytes for setup : 0x%08x\n",
+                        __func__, i);
+        }
+        if (!temp)
+                goto stall;
+
+        le16_to_cpus(&u.r.wValue);
+        le16_to_cpus(&u.r.wIndex);
+        le16_to_cpus(&u.r.wLength);
+
+        D_REQ(imx_usb->dev, "<%s> SETUP %02x.%02x v%04x i%04x l%04x\n",
+                __func__, u.r.bRequestType, u.r.bRequest,
+                u.r.wValue, u.r.wIndex, u.r.wLength);
+
+        if (imx_usb->set_config) {
+                /* NACK the host by using CMDOVER */
+                temp = __raw_readl(imx_usb->base + USB_CTRL);
+                __raw_writel(temp | CTRL_CMDOVER, imx_usb->base + USB_CTRL);
+
+                D_ERR(imx_usb->dev,
+                        "<%s> set config req is pending, NACK the host\n",
+                        __func__);
+                return;
+        }
+
+        if (u.r.bRequestType & USB_DIR_IN)
+                ep0_chg_stat(__func__, imx_usb, EP0_IN_DATA_PHASE);
+        else
+                ep0_chg_stat(__func__, imx_usb, EP0_OUT_DATA_PHASE);
+
+        i = imx_usb->driver->setup(&imx_usb->gadget, &u.r);
+        if (i < 0) {
+                D_ERR(imx_usb->dev, "<%s> device setup error %d\n",
+                        __func__, i);
+                goto stall;
+        }
+
+        return;
+stall:
+        D_ERR(imx_usb->dev, "<%s> protocol STALL\n", __func__);
+        imx_ep_stall(imx_ep);
+        ep0_chg_stat(__func__, imx_usb, EP0_STALL);
+        return;
+}
+
+/*******************************************************************************
+ * USB gadget callback functions
+ *******************************************************************************
+ */
+
+static int imx_ep_enable(struct usb_ep *usb_ep,
+                                const struct usb_endpoint_descriptor *desc)
+{
+        struct imx_ep_struct *imx_ep = container_of(usb_ep,
+                                                struct imx_ep_struct, ep);
+        struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
+        unsigned long flags;
+
+        if (!usb_ep
+                || !desc
+                || !EP_NO(imx_ep)
+                || desc->bDescriptorType != USB_DT_ENDPOINT
+                || imx_ep->bEndpointAddress != desc->bEndpointAddress) {
+                        D_ERR(imx_usb->dev,
+                                "<%s> bad ep or descriptor\n", __func__);
+                        return -EINVAL;
+        }
+
+        if (imx_ep->bmAttributes != desc->bmAttributes) {
+                D_ERR(imx_usb->dev,
+                        "<%s> %s type mismatch\n", __func__, usb_ep->name);
+                return -EINVAL;
+        }
+
+        if (imx_ep->fifosize < le16_to_cpu(desc->wMaxPacketSize)) {
+                D_ERR(imx_usb->dev,
+                        "<%s> bad %s maxpacket\n", __func__, usb_ep->name);
+                return -ERANGE;
+        }
+
+        if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
+                D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
+                return -ESHUTDOWN;
+        }
+
+        local_irq_save(flags);
+
+        imx_ep->stopped = 0;
+        imx_flush(imx_ep);
+        imx_ep_irq_enable(imx_ep);
+
+        local_irq_restore(flags);
+
+        D_EPX(imx_usb->dev, "<%s> ENABLED %s\n", __func__, usb_ep->name);
+        return 0;
+}
+
+static int imx_ep_disable(struct usb_ep *usb_ep)
+{
+        struct imx_ep_struct *imx_ep = container_of(usb_ep,
+                                                struct imx_ep_struct, ep);
+        unsigned long flags;
+
+        if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
+                D_ERR(imx_ep->imx_usb->dev, "<%s> %s can not be disabled\n",
+                        __func__, usb_ep ? imx_ep->ep.name : NULL);
+                return -EINVAL;
+        }
+
+        local_irq_save(flags);
+
+        imx_ep->stopped = 1;
+        nuke(imx_ep, -ESHUTDOWN);
+        imx_flush(imx_ep);
+        imx_ep_irq_disable(imx_ep);
+
+        local_irq_restore(flags);
+
+        D_EPX(imx_ep->imx_usb->dev,
+                "<%s> DISABLED %s\n", __func__, usb_ep->name);
+        return 0;
+}
+
+static struct usb_request *imx_ep_alloc_request
+                                        (struct usb_ep *usb_ep, gfp_t gfp_flags)
+{
+        struct imx_request *req;
+
+        req = kzalloc(sizeof *req, gfp_flags);
+        if (!req || !usb_ep)
+                return 0;
+
+        INIT_LIST_HEAD(&req->queue);
+        req->in_use = 0;
+
+        return &req->req;
+}
+
+static void imx_ep_free_request
+                        (struct usb_ep *usb_ep, struct usb_request *usb_req)
+{
+        struct imx_request *req;
+
+        req = container_of(usb_req, struct imx_request, req);
+        WARN_ON(!list_empty(&req->queue));
+        kfree(req);
+}
+
+static int imx_ep_queue
+        (struct usb_ep *usb_ep, struct usb_request *usb_req, gfp_t gfp_flags)
+{
+        struct imx_ep_struct    *imx_ep;
+        struct imx_udc_struct   *imx_usb;
+        struct imx_request      *req;
+        unsigned long           flags;
+        int                     ret = 0;
+
+        imx_ep = container_of(usb_ep, struct imx_ep_struct, ep);
+        imx_usb = imx_ep->imx_usb;
+        req = container_of(usb_req, struct imx_request, req);
+
+        /*
+          Special care on IMX udc.
+          Ignore enqueue when after set configuration from the
+          host. This assume all gadget drivers reply set
+          configuration with the next ep0 req enqueue.
+        */
+        if (imx_usb->set_config && !EP_NO(imx_ep)) {
+                imx_usb->set_config = 0;
+                D_EPX(imx_usb->dev,
+                        "<%s> gadget reply set config\n", __func__);
+                return 0;
+        }
+
+        if (unlikely(!usb_req || !req || !usb_req->complete || !usb_req->buf)) {
+                D_ERR(imx_usb->dev, "<%s> bad params\n", __func__);
+                return -EINVAL;
+        }
+
+        if (unlikely(!usb_ep || !imx_ep)) {
+                D_ERR(imx_usb->dev, "<%s> bad ep\n", __func__);
+                return -EINVAL;
+        }
+
+        if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
+                D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
+                return -ESHUTDOWN;
+        }
+
+        local_irq_save(flags);
+
+        /* Debug */
+        D_REQ(imx_usb->dev, "<%s> ep%d %s request for [%d] bytes\n",
+                __func__, EP_NO(imx_ep),
+                ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state == EP0_IN_DATA_PHASE)
+                || (EP_NO(imx_ep) && EP_DIR(imx_ep))) ? "IN" : "OUT", usb_req->length);
+        dump_req(__func__, imx_ep, usb_req);
+
+        if (imx_ep->stopped) {
+                usb_req->status = -ESHUTDOWN;
+                ret = -ESHUTDOWN;
+                goto out;
+        }
+
+        if (req->in_use) {
+                D_ERR(imx_usb->dev,
+                        "<%s> refusing to queue req %p (already queued)\n",
+                        __func__, req);
+                goto out;
+        }
+
+        usb_req->status = -EINPROGRESS;
+        usb_req->actual = 0;
+
+        ep_add_request(imx_ep, req);
+
+        if (!EP_NO(imx_ep))
+                ret = handle_ep0(imx_ep);
+        else
+                ret = handle_ep(imx_ep);
+out:
+        local_irq_restore(flags);
+        return ret;
+}
+
+static int imx_ep_dequeue(struct usb_ep *usb_ep, struct usb_request *usb_req)
+{
+
+        struct imx_ep_struct *imx_ep = container_of
+                                        (usb_ep, struct imx_ep_struct, ep);
+        struct imx_request *req;
+        unsigned long flags;
+
+        if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
+                D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
+                return -EINVAL;
+        }
+
+        local_irq_save(flags);
+
+        /* make sure it's actually queued on this endpoint */
+        list_for_each_entry(req, &imx_ep->queue, queue) {
+                if (&req->req == usb_req)
+                        break;
+        }
+        if (&req->req != usb_req) {
+                local_irq_restore(flags);
+                return -EINVAL;
+        }
+
+        done(imx_ep, req, -ECONNRESET);
+
+        local_irq_restore(flags);
+        return 0;
+}
+
+static int imx_ep_set_halt(struct usb_ep *usb_ep, int value)
+{
+        struct imx_ep_struct *imx_ep = container_of
+                                        (usb_ep, struct imx_ep_struct, ep);
+        unsigned long flags;
+
+        if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
+                D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
+                return -EINVAL;
+        }
+
+        local_irq_save(flags);
+
+        if ((imx_ep->bEndpointAddress & USB_DIR_IN)
+                && !list_empty(&imx_ep->queue)) {
+                        local_irq_restore(flags);
+                        return -EAGAIN;
+        }
+
+        imx_ep_stall(imx_ep);
+
+        local_irq_restore(flags);
+
+        D_EPX(imx_ep->imx_usb->dev, "<%s> %s halt\n", __func__, usb_ep->name);
+        return 0;
+}
+
+static int imx_ep_fifo_status(struct usb_ep *usb_ep)
+{
+        struct imx_ep_struct *imx_ep = container_of
+                                        (usb_ep, struct imx_ep_struct, ep);
+
+        if (!usb_ep) {
+                D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
+                return -ENODEV;
+        }
+
+        if (imx_ep->imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
+                return 0;
+        else
+                return imx_fifo_bcount(imx_ep);
+}
+
+static void imx_ep_fifo_flush(struct usb_ep *usb_ep)
+{
+        struct imx_ep_struct *imx_ep = container_of
+                                        (usb_ep, struct imx_ep_struct, ep);
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
+                D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
+                local_irq_restore(flags);
+                return;
+        }
+
+        /* toggle and halt bits stay unchanged */
+        imx_flush(imx_ep);
+
+        local_irq_restore(flags);
+}
+
+static struct usb_ep_ops imx_ep_ops = {
+        .enable         = imx_ep_enable,
+        .disable        = imx_ep_disable,
+
+        .alloc_request  = imx_ep_alloc_request,
+        .free_request   = imx_ep_free_request,
+
+        .queue          = imx_ep_queue,
+        .dequeue        = imx_ep_dequeue,
+
+        .set_halt       = imx_ep_set_halt,
+        .fifo_status    = imx_ep_fifo_status,
+        .fifo_flush     = imx_ep_fifo_flush,
+};
+
+/*******************************************************************************
+ * USB endpoint control functions
+ *******************************************************************************
+ */
+
+void ep0_chg_stat(const char *label,
+                        struct imx_udc_struct *imx_usb, enum ep0_state stat)
+{
+        D_EP0(imx_usb->dev, "<%s> from %15s to %15s\n",
+                label, state_name[imx_usb->ep0state], state_name[stat]);
+
+        if (imx_usb->ep0state == stat)
+                return;
+
+        imx_usb->ep0state = stat;
+}
+
+static void usb_init_data(struct imx_udc_struct *imx_usb)
+{
+        struct imx_ep_struct *imx_ep;
+        u8 i;
+
+        /* device/ep0 records init */
+        INIT_LIST_HEAD(&imx_usb->gadget.ep_list);
+        INIT_LIST_HEAD(&imx_usb->gadget.ep0->ep_list);
+        ep0_chg_stat(__func__, imx_usb, EP0_IDLE);
+
+        /* basic endpoint records init */
+        for (i = 0; i < IMX_USB_NB_EP; i++) {
+                imx_ep = &imx_usb->imx_ep[i];
+
+                if (i) {
+                        list_add_tail(&imx_ep->ep.ep_list,
+                                &imx_usb->gadget.ep_list);
+                        imx_ep->stopped = 1;
+                } else
+                        imx_ep->stopped = 0;
+
+                INIT_LIST_HEAD(&imx_ep->queue);
+        }
+}
+
+static void udc_stop_activity(struct imx_udc_struct *imx_usb,
+                                        struct usb_gadget_driver *driver)
+{
+        struct imx_ep_struct *imx_ep;
+        int i;
+
+        if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
+                driver = NULL;
+
+        /* prevent new request submissions, kill any outstanding requests  */
+        for (i = 1; i < IMX_USB_NB_EP; i++) {
+                imx_ep = &imx_usb->imx_ep[i];
+                imx_flush(imx_ep);
+                imx_ep->stopped = 1;
+                imx_ep_irq_disable(imx_ep);
+                nuke(imx_ep, -ESHUTDOWN);
+        }
+
+        imx_usb->cfg = 0;
+        imx_usb->intf = 0;
+        imx_usb->alt = 0;
+
+        if (driver)
+                driver->disconnect(&imx_usb->gadget);
+}
+
+/*******************************************************************************
+ * Interrupt handlers
+ *******************************************************************************
+ */
+
+static irqreturn_t imx_udc_irq(int irq, void *dev)
+{
+        struct imx_udc_struct *imx_usb = dev;
+        struct usb_ctrlrequest u;
+        int temp, cfg, intf, alt;
+        int intr = __raw_readl(imx_usb->base + USB_INTR);
+
+        if (intr & (INTR_WAKEUP | INTR_SUSPEND | INTR_RESUME | INTR_RESET_START
+                        | INTR_RESET_STOP | INTR_CFG_CHG)) {
+                                dump_intr(__func__, intr, imx_usb->dev);
+                                dump_usb_stat(__func__, imx_usb);
+        }
+
+        if (!imx_usb->driver) {
+                /*imx_udc_disable(imx_usb);*/
+                goto end_irq;
+        }
+
+        if (intr & INTR_WAKEUP) {
+                if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN
+                        && imx_usb->driver && imx_usb->driver->resume)
+                                imx_usb->driver->resume(&imx_usb->gadget);
+                imx_usb->set_config = 0;
+                imx_usb->gadget.speed = USB_SPEED_FULL;
+        }
+
+        if (intr & INTR_SUSPEND) {
+                if (imx_usb->gadget.speed != USB_SPEED_UNKNOWN
+                        && imx_usb->driver && imx_usb->driver->suspend)
+                                imx_usb->driver->suspend(&imx_usb->gadget);
+                imx_usb->set_config = 0;
+                imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
+        }
+
+        if (intr & INTR_RESET_START) {
+                __raw_writel(intr, imx_usb->base + USB_INTR);
+                udc_stop_activity(imx_usb, imx_usb->driver);
+                imx_usb->set_config = 0;
+                imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
+        }
+
+        if (intr & INTR_RESET_STOP)
+                imx_usb->gadget.speed = USB_SPEED_FULL;
+
+        if (intr & INTR_CFG_CHG) {
+                __raw_writel(INTR_CFG_CHG, imx_usb->base + USB_INTR);
+                temp = __raw_readl(imx_usb->base + USB_STAT);
+                cfg  = (temp & STAT_CFG) >> 5;
+                intf = (temp & STAT_INTF) >> 3;
+                alt  =  temp & STAT_ALTSET;
+
+                D_REQ(imx_usb->dev,
+                        "<%s> orig config C=%d, I=%d, A=%d / "
+                        "req config C=%d, I=%d, A=%d\n",
+                        __func__, imx_usb->cfg, imx_usb->intf, imx_usb->alt,
+                        cfg, intf, alt);
+
+                if (cfg != 1 && cfg != 2)
+                        goto end_irq;
+
+                imx_usb->set_config = 0;
+
+                /* Config setup */
+                if (imx_usb->cfg != cfg) {
+                        D_REQ(imx_usb->dev, "<%s> Change config start\n",__func__);
+                        u.bRequest = USB_REQ_SET_CONFIGURATION;
+                        u.bRequestType = USB_DIR_OUT |
+                                        USB_TYPE_STANDARD |
+                                        USB_RECIP_DEVICE;
+                        u.wValue = cfg;
+                        u.wIndex = 0;
+                        u.wLength = 0;
+                        imx_usb->cfg = cfg;
+                        imx_usb->set_config = 1;
+                        imx_usb->driver->setup(&imx_usb->gadget, &u);
+                        imx_usb->set_config = 0;
+                        D_REQ(imx_usb->dev, "<%s> Change config done\n",__func__);
+
+                }
+                if (imx_usb->intf != intf || imx_usb->alt != alt) {
+                        D_REQ(imx_usb->dev, "<%s> Change interface start\n",__func__);
+                        u.bRequest = USB_REQ_SET_INTERFACE;
+                        u.bRequestType = USB_DIR_OUT |
+                                          USB_TYPE_STANDARD |
+                                          USB_RECIP_INTERFACE;
+                        u.wValue = alt;
+                        u.wIndex = intf;
+                        u.wLength = 0;
+                        imx_usb->intf = intf;
+                        imx_usb->alt = alt;
+                        imx_usb->set_config = 1;
+                        imx_usb->driver->setup(&imx_usb->gadget, &u);
+                        imx_usb->set_config = 0;
+                        D_REQ(imx_usb->dev, "<%s> Change interface done\n",__func__);
+                }
+        }
+
+        if (intr & INTR_SOF) {
+                if (imx_usb->ep0state == EP0_IDLE) {
+                        temp = __raw_readl(imx_usb->base + USB_CTRL);
+                        __raw_writel(temp | CTRL_CMDOVER, imx_usb->base + USB_CTRL);
+                }
+        }
+
+end_irq:
+        __raw_writel(intr, imx_usb->base + USB_INTR);
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev)
+{
+        struct imx_udc_struct *imx_usb = dev;
+        int intr = __raw_readl(imx_usb->base + USB_EP_INTR(0));
+
+        dump_ep_intr(__func__, 0, intr, imx_usb->dev);
+
+        if (!imx_usb->driver) {
+                __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
+                return IRQ_HANDLED;
+        }
+
+        /* DEVREQ IRQ has highest priority */
+        if (intr & (EPINTR_DEVREQ | EPINTR_MDEVREQ))
+                handle_ep0_devreq(imx_usb);
+        /* Seem i.MX is missing EOF interrupt sometimes.
+         * Therefore we monitor both EOF and FIFO_EMPTY interrups
+         * when transmiting, and both EOF and FIFO_FULL when
+         * receiving data.
+         */
+        else if (intr & (EPINTR_EOF | EPINTR_FIFO_EMPTY | EPINTR_FIFO_FULL))
+                handle_ep0(&imx_usb->imx_ep[0]);
+
+        __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t imx_udc_bulk_irq(int irq, void *dev)
+{
+        struct imx_udc_struct *imx_usb = dev;
+        struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - USBD_INT0];
+        int intr = __raw_readl(imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
+
+        dump_ep_intr(__func__, irq - USBD_INT0, intr, imx_usb->dev);
+
+        if (!imx_usb->driver) {
+                __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
+                return IRQ_HANDLED;
+        }
+
+        handle_ep(imx_ep);
+
+        __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
+
+        return IRQ_HANDLED;
+}
+
+irq_handler_t intr_handler(int i)
+{
+        switch (i) {
+        case 0:
+                return imx_udc_ctrl_irq;
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+                return imx_udc_bulk_irq;
+        default:
+                return imx_udc_irq;
+        }
+}
+
+/*******************************************************************************
+ * Static defined IMX UDC structure
+ *******************************************************************************
+ */
+
+static const struct usb_gadget_ops imx_udc_ops = {
+        .get_frame       = imx_udc_get_frame,
+        .wakeup          = imx_udc_wakeup,
+};
+
+static struct imx_udc_struct controller = {
+        .gadget = {
+                .ops            = &imx_udc_ops,
+                .ep0            = &controller.imx_ep[0].ep,
+                .name           = driver_name,
+                .dev = {
+                         .bus_id        = "gadget",
+                 },
+        },
+
+        .imx_ep[0] = {
+                .ep = {
+                        .name           = ep0name,
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 32,
+                },
+                .imx_usb                = &controller,
+                .fifosize               = 32,
+                .bEndpointAddress       = 0,
+                .bmAttributes           = USB_ENDPOINT_XFER_CONTROL,
+         },
+        .imx_ep[1] = {
+                .ep = {
+                        .name           = "ep1in-bulk",
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 64,
+                },
+                .imx_usb                = &controller,
+                .fifosize               = 64,
+                .bEndpointAddress       = USB_DIR_IN | 1,
+                .bmAttributes           = USB_ENDPOINT_XFER_BULK,
+         },
+        .imx_ep[2] = {
+                .ep = {
+                        .name           = "ep2out-bulk",
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 64,
+                },
+                .imx_usb                = &controller,
+                .fifosize               = 64,
+                .bEndpointAddress       = USB_DIR_OUT | 2,
+                .bmAttributes           = USB_ENDPOINT_XFER_BULK,
+         },
+        .imx_ep[3] = {
+                .ep = {
+                        .name           = "ep3out-bulk",
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 32,
+                },
+                .imx_usb                = &controller,
+                .fifosize               = 32,
+                .bEndpointAddress       = USB_DIR_OUT | 3,
+                .bmAttributes           = USB_ENDPOINT_XFER_BULK,
+         },
+        .imx_ep[4] = {
+                .ep = {
+                        .name           = "ep4in-int",
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 32,
+                 },
+                .imx_usb                = &controller,
+                .fifosize               = 32,
+                .bEndpointAddress       = USB_DIR_IN | 4,
+                .bmAttributes           = USB_ENDPOINT_XFER_INT,
+         },
+        .imx_ep[5] = {
+                .ep = {
+                        .name           = "ep5out-int",
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 32,
+                },
+                .imx_usb                = &controller,
+                .fifosize               = 32,
+                .bEndpointAddress       = USB_DIR_OUT | 5,
+                .bmAttributes           = USB_ENDPOINT_XFER_INT,
+         },
+};
+
+/*******************************************************************************
+ * USB gadged driver functions
+ *******************************************************************************
+ */
+int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+{
+        struct imx_udc_struct *imx_usb = &controller;
+        int retval;
+
+        if (!driver
+                || driver->speed < USB_SPEED_FULL
+                || !driver->bind
+                || !driver->disconnect
+                || !driver->setup)
+                        return -EINVAL;
+        if (!imx_usb)
+                return -ENODEV;
+        if (imx_usb->driver)
+                return -EBUSY;
+
+        /* first hook up the driver ... */
+        imx_usb->driver = driver;
+        imx_usb->gadget.dev.driver = &driver->driver;
+
+        retval = device_add(&imx_usb->gadget.dev);
+        if (retval)
+                goto fail;
+        retval = driver->bind(&imx_usb->gadget);
+        if (retval) {
+                D_ERR(imx_usb->dev, "<%s> bind to driver %s --> error %d\n",
+                        __func__, driver->driver.name, retval);
+                device_del(&imx_usb->gadget.dev);
+
+                goto fail;
+        }
+
+        D_INI(imx_usb->dev, "<%s> registered gadget driver '%s'\n",
+                __func__, driver->driver.name);
+
+        imx_udc_enable(imx_usb);
+
+        return 0;
+fail:
+        imx_usb->driver = NULL;
+        imx_usb->gadget.dev.driver = NULL;
+        return retval;
+}
+EXPORT_SYMBOL(usb_gadget_register_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct imx_udc_struct *imx_usb = &controller;
+
+        if (!imx_usb)
+                return -ENODEV;
+        if (!driver || driver != imx_usb->driver || !driver->unbind)
+                return -EINVAL;
+
+        udc_stop_activity(imx_usb, driver);
+        imx_udc_disable(imx_usb);
+
+        driver->unbind(&imx_usb->gadget);
+        imx_usb->gadget.dev.driver = NULL;
+        imx_usb->driver = NULL;
+
+        device_del(&imx_usb->gadget.dev);
+
+        D_INI(imx_usb->dev, "<%s> unregistered gadget driver '%s'\n",
+                __func__, driver->driver.name);
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+/*******************************************************************************
+ * Module functions
+ *******************************************************************************
+ */
+
+static int __init imx_udc_probe(struct platform_device *pdev)
+{
+        struct imx_udc_struct *imx_usb = &controller;
+        struct resource *res;
+        struct imxusb_platform_data *pdata;
+        struct clk *clk;
+        void __iomem *base;
+        int ret = 0;
+        int i, res_size;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "can't get device resources\n");
+                return -ENODEV;
+        }
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "driver needs platform data\n");
+                return -ENODEV;
+        }
+
+        res_size = res->end - res->start + 1;
+        if (!request_mem_region(res->start, res_size, res->name)) {
+                dev_err(&pdev->dev, "can't allocate %d bytes at %d address\n",
+                        res_size, res->start);
+                return -ENOMEM;
+        }
+
+        if (pdata->init) {
+                ret = pdata->init(&pdev->dev);
+                if (ret)
+                        goto fail0;
+        }
+
+        base = ioremap(res->start, res_size);
+        if (!base) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                ret = -EIO;
+                goto fail1;
+        }
+
+        clk = clk_get(NULL, "usbd_clk");
+        if (IS_ERR(clk)) {
+                ret = PTR_ERR(clk);
+                dev_err(&pdev->dev, "can't get USB clock\n");
+                goto fail2;
+        }
+        clk_enable(clk);
+
+        if (clk_get_rate(clk) != 48000000) {
+                D_INI(&pdev->dev,
+                        "Bad USB clock (%d Hz), changing to 48000000 Hz\n",
+                        (int)clk_get_rate(clk));
+                if (clk_set_rate(clk, 48000000)) {
+                        dev_err(&pdev->dev,
+                                "Unable to set correct USB clock (48MHz)\n");
+                        ret = -EIO;
+                        goto fail3;
+                }
+        }
+
+        for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
+                imx_usb->usbd_int[i] = platform_get_irq(pdev, i);
+                if (imx_usb->usbd_int[i] < 0) {
+                        dev_err(&pdev->dev, "can't get irq number\n");
+                        ret = -ENODEV;
+                        goto fail3;
+                }
+        }
+
+        for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
+                ret = request_irq(imx_usb->usbd_int[i], intr_handler(i),
+                                     IRQF_DISABLED, driver_name, imx_usb);
+                if (ret) {
+                        dev_err(&pdev->dev, "can't get irq %i, err %d\n",
+                                imx_usb->usbd_int[i], ret);
+                        for (--i; i >= 0; i--)
+                                free_irq(imx_usb->usbd_int[i], imx_usb);
+                        goto fail3;
+                }
+        }
+
+        imx_usb->res = res;
+        imx_usb->base = base;
+        imx_usb->clk = clk;
+        imx_usb->dev = &pdev->dev;
+
+        device_initialize(&imx_usb->gadget.dev);
+
+        imx_usb->gadget.dev.parent = &pdev->dev;
+        imx_usb->gadget.dev.dma_mask = pdev->dev.dma_mask;
+
+        platform_set_drvdata(pdev, imx_usb);
+
+        usb_init_data(imx_usb);
+        imx_udc_init(imx_usb);
+
+        return 0;
+
+fail3:
+        clk_put(clk);
+        clk_disable(clk);
+fail2:
+        iounmap(base);
+fail1:
+        if (pdata->exit)
+                pdata->exit(&pdev->dev);
+fail0:
+        release_mem_region(res->start, res_size);
+        return ret;
+}
+
+static int __exit imx_udc_remove(struct platform_device *pdev)
+{
+        struct imx_udc_struct *imx_usb = platform_get_drvdata(pdev);
+        struct imxusb_platform_data *pdata = pdev->dev.platform_data;
+        int i;
+
+        imx_udc_disable(imx_usb);
+
+        for (i = 0; i < IMX_USB_NB_EP + 1; i++)
+                free_irq(imx_usb->usbd_int[i], imx_usb);
+
+        clk_put(imx_usb->clk);
+        clk_disable(imx_usb->clk);
+        iounmap(imx_usb->base);
+
+        release_mem_region(imx_usb->res->start,
+                imx_usb->res->end - imx_usb->res->start + 1);
+
+        if (pdata->exit)
+                pdata->exit(&pdev->dev);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+/*----------------------------------------------------------------------------*/
+
+#ifdef  CONFIG_PM
+#define imx_udc_suspend NULL
+#define imx_udc_resume  NULL
+#else
+#define imx_udc_suspend NULL
+#define imx_udc_resume  NULL
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+static struct platform_driver udc_driver = {
+        .driver         = {
+                .name   = driver_name,
+                .owner  = THIS_MODULE,
+        },
+        .remove         = __exit_p(imx_udc_remove),
+        .suspend        = imx_udc_suspend,
+        .resume         = imx_udc_resume,
+};
+
+static int __init udc_init(void)
+{
+        return platform_driver_probe(&udc_driver, imx_udc_probe);
+}
+module_init(udc_init);
+
+static void __exit udc_exit(void)
+{
+        platform_driver_unregister(&udc_driver);
+}
+module_exit(udc_exit);
+
+MODULE_DESCRIPTION("IMX USB Device Controller driver");
+MODULE_AUTHOR("Darius Augulis <augulis.darius@gmail.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:imx_udc");
diff --git a/drivers/usb/gadget/imx_udc.h b/drivers/usb/gadget/imx_udc.h
new file mode 100644
index 000000000000..850076937d8d
--- /dev/null
+++ b/drivers/usb/gadget/imx_udc.h
@@ -0,0 +1,344 @@
+/*
+ *      Copyright (C) 2005 Mike Lee(eemike@gmail.com)
+ *
+ *      This udc driver is now under testing and code is based on pxa2xx_udc.h
+ *      Please use it with your own risk!
+ *
+ *      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.
+ */
+
+#ifndef __LINUX_USB_GADGET_IMX_H
+#define __LINUX_USB_GADGET_IMX_H
+
+#include <linux/types.h>
+
+/* Helper macros */
+#define EP_NO(ep)       ((ep->bEndpointAddress) & ~USB_DIR_IN) /* IN:1, OUT:0 */
+#define EP_DIR(ep)      ((ep->bEndpointAddress) & USB_DIR_IN ? 1 : 0)
+#define irq_to_ep(irq)  (((irq) >= USBD_INT0) || ((irq) <= USBD_INT6) ? ((irq) - USBD_INT0) : (USBD_INT6)) /*should not happen*/
+#define ep_to_irq(ep)   (EP_NO((ep)) + USBD_INT0)
+#define IMX_USB_NB_EP   6
+
+/* Driver structures */
+struct imx_request {
+        struct usb_request                      req;
+        struct list_head                        queue;
+        unsigned int                            in_use;
+};
+
+enum ep0_state {
+        EP0_IDLE,
+        EP0_IN_DATA_PHASE,
+        EP0_OUT_DATA_PHASE,
+        EP0_CONFIG,
+        EP0_STALL,
+};
+
+struct imx_ep_struct {
+        struct usb_ep                           ep;
+        struct imx_udc_struct                   *imx_usb;
+        struct list_head                        queue;
+        unsigned char                           stopped;
+        unsigned char                           fifosize;
+        unsigned char                           bEndpointAddress;
+        unsigned char                           bmAttributes;
+};
+
+struct imx_udc_struct {
+        struct usb_gadget                       gadget;
+        struct usb_gadget_driver                *driver;
+        struct device                           *dev;
+        struct imx_ep_struct                    imx_ep[IMX_USB_NB_EP];
+        struct clk                              *clk;
+        enum ep0_state                          ep0state;
+        struct resource                         *res;
+        void __iomem                            *base;
+        unsigned char                           set_config;
+        int                                     cfg,
+                                                intf,
+                                                alt,
+                                                usbd_int[7];
+};
+
+/* USB registers */
+#define  USB_FRAME              (0x00)  /* USB frame */
+#define  USB_SPEC               (0x04)  /* USB Spec */
+#define  USB_STAT               (0x08)  /* USB Status */
+#define  USB_CTRL               (0x0C)  /* USB Control */
+#define  USB_DADR               (0x10)  /* USB Desc RAM addr */
+#define  USB_DDAT               (0x14)  /* USB Desc RAM/EP buffer data */
+#define  USB_INTR               (0x18)  /* USB interrupt */
+#define  USB_MASK               (0x1C)  /* USB Mask */
+#define  USB_ENAB               (0x24)  /* USB Enable */
+#define  USB_EP_STAT(x)         (0x30 + (x*0x30)) /* USB status/control */
+#define  USB_EP_INTR(x)         (0x34 + (x*0x30)) /* USB interrupt */
+#define  USB_EP_MASK(x)         (0x38 + (x*0x30)) /* USB mask */
+#define  USB_EP_FDAT(x)         (0x3C + (x*0x30)) /* USB FIFO data */
+#define  USB_EP_FDAT0(x)        (0x3C + (x*0x30)) /* USB FIFO data */
+#define  USB_EP_FDAT1(x)        (0x3D + (x*0x30)) /* USB FIFO data */
+#define  USB_EP_FDAT2(x)        (0x3E + (x*0x30)) /* USB FIFO data */
+#define  USB_EP_FDAT3(x)        (0x3F + (x*0x30)) /* USB FIFO data */
+#define  USB_EP_FSTAT(x)        (0x40 + (x*0x30)) /* USB FIFO status */
+#define  USB_EP_FCTRL(x)        (0x44 + (x*0x30)) /* USB FIFO control */
+#define  USB_EP_LRFP(x)         (0x48 + (x*0x30)) /* USB last read frame pointer */
+#define  USB_EP_LWFP(x)         (0x4C + (x*0x30)) /* USB last write frame pointer */
+#define  USB_EP_FALRM(x)        (0x50 + (x*0x30)) /* USB FIFO alarm */
+#define  USB_EP_FRDP(x)         (0x54 + (x*0x30)) /* USB FIFO read pointer */
+#define  USB_EP_FWRP(x)         (0x58 + (x*0x30)) /* USB FIFO write pointer */
+/* USB Control Register Bit Fields.*/
+#define CTRL_CMDOVER            (1<<6)  /* UDC status */
+#define CTRL_CMDERROR           (1<<5)  /* UDC status */
+#define CTRL_FE_ENA             (1<<3)  /* Enable Font End logic */
+#define CTRL_UDC_RST            (1<<2)  /* UDC reset */
+#define CTRL_AFE_ENA            (1<<1)  /* Analog Font end enable */
+#define CTRL_RESUME             (1<<0)  /* UDC resume */
+/* USB Status Register Bit Fields.*/
+#define STAT_RST                (1<<8)
+#define STAT_SUSP               (1<<7)
+#define STAT_CFG                (3<<5)
+#define STAT_INTF               (3<<3)
+#define STAT_ALTSET             (7<<0)
+/* USB Interrupt Status/Mask Registers Bit fields */
+#define INTR_WAKEUP             (1<<31) /* Wake up Interrupt */
+#define INTR_MSOF               (1<<7)  /* Missed Start of Frame */
+#define INTR_SOF                (1<<6)  /* Start of Frame */
+#define INTR_RESET_STOP         (1<<5)  /* Reset Signaling stop */
+#define INTR_RESET_START        (1<<4)  /* Reset Signaling start */
+#define INTR_RESUME             (1<<3)  /* Suspend to resume */
+#define INTR_SUSPEND            (1<<2)  /* Active to suspend */
+#define INTR_FRAME_MATCH        (1<<1)  /* Frame matched */
+#define INTR_CFG_CHG            (1<<0)  /* Configuration change occurred */
+/* USB Enable Register Bit Fields.*/
+#define ENAB_RST                (1<<31) /* Reset USB modules */
+#define ENAB_ENAB               (1<<30) /* Enable USB modules*/
+#define ENAB_SUSPEND            (1<<29) /* Suspend USB modules */
+#define ENAB_ENDIAN             (1<<28) /* Endian of USB modules */
+#define ENAB_PWRMD              (1<<0)  /* Power mode of USB modules */
+/* USB Descriptor Ram Address Register bit fields */
+#define DADR_CFG                (1<<31) /* Configuration */
+#define DADR_BSY                (1<<30) /* Busy status */
+#define DADR_DADR               (0x1FF) /* Descriptor Ram Address */
+/* USB Descriptor RAM/Endpoint Buffer Data Register bit fields */
+#define DDAT_DDAT               (0xFF)  /* Descriptor Endpoint Buffer */
+/* USB Endpoint Status Register bit fields */
+#define EPSTAT_BCOUNT           (0x7F<<16)      /* Endpoint FIFO byte count */
+#define EPSTAT_SIP              (1<<8)  /* Endpoint setup in progress */
+#define EPSTAT_DIR              (1<<7)  /* Endpoint transfer direction */
+#define EPSTAT_MAX              (3<<5)  /* Endpoint Max packet size */
+#define EPSTAT_TYP              (3<<3)  /* Endpoint type */
+#define EPSTAT_ZLPS             (1<<2)  /* Send zero length packet */
+#define EPSTAT_FLUSH            (1<<1)  /* Endpoint FIFO Flush */
+#define EPSTAT_STALL            (1<<0)  /* Force stall */
+/* USB Endpoint FIFO Status Register bit fields */
+#define FSTAT_FRAME_STAT        (0xF<<24)       /* Frame status bit [0-3] */
+#define FSTAT_ERR               (1<<22) /* FIFO error */
+#define FSTAT_UF                (1<<21) /* FIFO underflow */
+#define FSTAT_OF                (1<<20) /* FIFO overflow */
+#define FSTAT_FR                (1<<19) /* FIFO frame ready */
+#define FSTAT_FULL              (1<<18) /* FIFO full */
+#define FSTAT_ALRM              (1<<17) /* FIFO alarm */
+#define FSTAT_EMPTY             (1<<16) /* FIFO empty */
+/* USB Endpoint FIFO Control Register bit fields */
+#define FCTRL_WFR               (1<<29) /* Write frame end */
+/* USB Endpoint Interrupt Status Regsiter bit fields */
+#define EPINTR_FIFO_FULL        (1<<8)  /* fifo full */
+#define EPINTR_FIFO_EMPTY       (1<<7)  /* fifo empty */
+#define EPINTR_FIFO_ERROR       (1<<6)  /* fifo error */
+#define EPINTR_FIFO_HIGH        (1<<5)  /* fifo high */
+#define EPINTR_FIFO_LOW         (1<<4)  /* fifo low */
+#define EPINTR_MDEVREQ          (1<<3)  /* multi Device request */
+#define EPINTR_EOT              (1<<2)  /* fifo end of transfer */
+#define EPINTR_DEVREQ           (1<<1)  /* Device request */
+#define EPINTR_EOF              (1<<0)  /* fifo end of frame */
+
+/* Debug macros */
+#ifdef DEBUG
+
+/* #define DEBUG_REQ */
+/* #define DEBUG_TRX */
+/* #define DEBUG_INIT */
+/* #define DEBUG_EP0 */
+/* #define DEBUG_EPX */
+/* #define DEBUG_IRQ */
+/* #define DEBUG_EPIRQ */
+/* #define DEBUG_DUMP */
+#define DEBUG_ERR
+
+#ifdef DEBUG_REQ
+        #define D_REQ(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_REQ(dev, args...)     do {} while (0)
+#endif /* DEBUG_REQ */
+
+#ifdef DEBUG_TRX
+        #define D_TRX(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_TRX(dev, args...)     do {} while (0)
+#endif /* DEBUG_TRX */
+
+#ifdef DEBUG_INIT
+        #define D_INI(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_INI(dev, args...)     do {} while (0)
+#endif /* DEBUG_INIT */
+
+#ifdef DEBUG_EP0
+        static const char *state_name[] = {
+                "EP0_IDLE",
+                "EP0_IN_DATA_PHASE",
+                "EP0_OUT_DATA_PHASE",
+                "EP0_CONFIG",
+                "EP0_STALL"
+        };
+        #define D_EP0(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_EP0(dev, args...)     do {} while (0)
+#endif /* DEBUG_EP0 */
+
+#ifdef DEBUG_EPX
+        #define D_EPX(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_EPX(dev, args...)     do {} while (0)
+#endif /* DEBUG_EP0 */
+
+#ifdef DEBUG_IRQ
+        static void dump_intr(const char *label, int irqreg, struct device *dev)
+        {
+                dev_dbg(dev, "<%s> USB_INTR=[%s%s%s%s%s%s%s%s%s]\n", label,
+                        (irqreg & INTR_WAKEUP) ? " wake" : "",
+                        (irqreg & INTR_MSOF) ? " msof" : "",
+                        (irqreg & INTR_SOF) ? " sof" : "",
+                        (irqreg & INTR_RESUME) ? " resume" : "",
+                        (irqreg & INTR_SUSPEND) ? " suspend" : "",
+                        (irqreg & INTR_RESET_STOP) ? " noreset" : "",
+                        (irqreg & INTR_RESET_START) ? " reset" : "",
+                        (irqreg & INTR_FRAME_MATCH) ? " fmatch" : "",
+                        (irqreg & INTR_CFG_CHG) ? " config" : "");
+        }
+#else
+        #define dump_intr(x, y, z)              do {} while (0)
+#endif /* DEBUG_IRQ */
+
+#ifdef DEBUG_EPIRQ
+        static void dump_ep_intr(const char *label, int nr, int irqreg, struct device *dev)
+        {
+                dev_dbg(dev, "<%s> EP%d_INTR=[%s%s%s%s%s%s%s%s%s]\n", label, nr,
+                        (irqreg & EPINTR_FIFO_FULL) ? " full" : "",
+                        (irqreg & EPINTR_FIFO_EMPTY) ? " fempty" : "",
+                        (irqreg & EPINTR_FIFO_ERROR) ? " ferr" : "",
+                        (irqreg & EPINTR_FIFO_HIGH) ? " fhigh" : "",
+                        (irqreg & EPINTR_FIFO_LOW) ? " flow" : "",
+                        (irqreg & EPINTR_MDEVREQ) ? " mreq" : "",
+                        (irqreg & EPINTR_EOF) ? " eof" : "",
+                        (irqreg & EPINTR_DEVREQ) ? " devreq" : "",
+                        (irqreg & EPINTR_EOT) ? " eot" : "");
+        }
+#else
+        #define dump_ep_intr(x, y, z, i)        do {} while (0)
+#endif /* DEBUG_IRQ */
+
+#ifdef DEBUG_DUMP
+        static void dump_usb_stat(const char *label, struct imx_udc_struct *imx_usb)
+        {
+                int temp = __raw_readl(imx_usb->base + USB_STAT);
+
+                dev_dbg(imx_usb->dev,
+                        "<%s> USB_STAT=[%s%s CFG=%d, INTF=%d, ALTR=%d]\n", label,
+                        (temp & STAT_RST) ? " reset" : "",
+                        (temp & STAT_SUSP) ? " suspend" : "",
+                        (temp & STAT_CFG) >> 5,
+                        (temp & STAT_INTF) >> 3,
+                        (temp & STAT_ALTSET));
+        }
+
+        static void dump_ep_stat(const char *label, struct imx_ep_struct *imx_ep)
+        {
+                int temp = __raw_readl(imx_ep->imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
+
+                dev_dbg(imx_ep->imx_usb->dev,
+                        "<%s> EP%d_INTR=[%s%s%s%s%s%s%s%s%s]\n", label, EP_NO(imx_ep),
+                        (temp & EPINTR_FIFO_FULL) ? " full" : "",
+                        (temp & EPINTR_FIFO_EMPTY) ? " fempty" : "",
+                        (temp & EPINTR_FIFO_ERROR) ? " ferr" : "",
+                        (temp & EPINTR_FIFO_HIGH) ? " fhigh" : "",
+                        (temp & EPINTR_FIFO_LOW) ? " flow" : "",
+                        (temp & EPINTR_MDEVREQ) ? " mreq" : "",
+                        (temp & EPINTR_EOF) ? " eof" : "",
+                        (temp & EPINTR_DEVREQ) ? " devreq" : "",
+                        (temp & EPINTR_EOT) ? " eot" : "");
+
+                temp = __raw_readl(imx_ep->imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+
+                dev_dbg(imx_ep->imx_usb->dev,
+                        "<%s> EP%d_STAT=[%s%s bcount=%d]\n", label, EP_NO(imx_ep),
+                        (temp & EPSTAT_SIP) ? " sip" : "",
+                        (temp & EPSTAT_STALL) ? " stall" : "",
+                        (temp & EPSTAT_BCOUNT) >> 16);
+
+                temp = __raw_readl(imx_ep->imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)));
+
+                dev_dbg(imx_ep->imx_usb->dev,
+                        "<%s> EP%d_FSTAT=[%s%s%s%s%s%s%s]\n", label, EP_NO(imx_ep),
+                        (temp & FSTAT_ERR) ? " ferr" : "",
+                        (temp & FSTAT_UF) ? " funder" : "",
+                        (temp & FSTAT_OF) ? " fover" : "",
+                        (temp & FSTAT_FR) ? " fready" : "",
+                        (temp & FSTAT_FULL) ? " ffull" : "",
+                        (temp & FSTAT_ALRM) ? " falarm" : "",
+                        (temp & FSTAT_EMPTY) ? " fempty" : "");
+        }
+
+        static void dump_req(const char *label, struct imx_ep_struct *imx_ep, struct usb_request *req)
+        {
+                int i;
+
+                if (!req || !req->buf) {
+                        dev_dbg(imx_ep->imx_usb->dev, "<%s> req or req buf is free\n", label);
+                        return;
+                }
+
+                if ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state == EP0_IN_DATA_PHASE)
+                        || (EP_NO(imx_ep) && EP_DIR(imx_ep))) {
+
+                        dev_dbg(imx_ep->imx_usb->dev, "<%s> request dump <", label);
+                        for (i = 0; i < req->length; i++)
+                                printk("%02x-", *((u8 *)req->buf + i));
+                        printk(">\n");
+                }
+        }
+
+#else
+        #define dump_ep_stat(x, y)              do {} while (0)
+        #define dump_usb_stat(x, y)             do {} while (0)
+        #define dump_req(x, y, z)               do {} while (0)
+#endif /* DEBUG_DUMP */
+
+#ifdef DEBUG_ERR
+        #define D_ERR(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_ERR(dev, args...)     do {} while (0)
+#endif
+
+#else
+        #define D_REQ(dev, args...)             do {} while (0)
+        #define D_TRX(dev, args...)             do {} while (0)
+        #define D_INI(dev, args...)             do {} while (0)
+        #define D_EP0(dev, args...)             do {} while (0)
+        #define D_EPX(dev, args...)             do {} while (0)
+        #define dump_ep_intr(x, y, z, i)        do {} while (0)
+        #define dump_intr(x, y, z)              do {} while (0)
+        #define dump_ep_stat(x, y)              do {} while (0)
+        #define dump_usb_stat(x, y)             do {} while (0)
+        #define dump_req(x, y, z)               do {} while (0)
+        #define D_ERR(dev, args...)             do {} while (0)
+#endif /* DEBUG */
+
+#endif /* __LINUX_USB_GADGET_IMX_H */
diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
index 3a8879ec2061..43dcf9e1af6b 100644
--- a/drivers/usb/gadget/m66592-udc.c
+++ b/drivers/usb/gadget/m66592-udc.c
@@ -1546,8 +1546,6 @@ static void nop_completion(struct usb_ep *ep, struct usb_request *r)
 {
 }
 
-#define resource_len(r) (((r)->end - (r)->start) + 1)
-
 static int __init m66592_probe(struct platform_device *pdev)
 {
         struct resource *res;
@@ -1560,11 +1558,10 @@ static int __init m66592_probe(struct platform_device *pdev)
         int ret = 0;
         int i;
 
-        res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
-                        (char *)udc_name);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
                 ret = -ENODEV;
-                pr_err("platform_get_resource_byname error.\n");
+                pr_err("platform_get_resource error.\n");
                 goto clean_up;
         }
 
@@ -1575,7 +1572,7 @@ static int __init m66592_probe(struct platform_device *pdev)
                 goto clean_up;
         }
 
-        reg = ioremap(res->start, resource_len(res));
+        reg = ioremap(res->start, resource_size(res));
         if (reg == NULL) {
                 ret = -ENOMEM;
                 pr_err("ioremap error.\n");
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index 8ae70de2c37d..12c6d83b218c 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -669,7 +669,7 @@ fill_dma_desc (struct net2280_ep *ep, struct net2280_request *req, int valid)
 
         /* 2280 may be polling VALID_BIT through ep->dma->dmadesc */
         wmb ();
-        td->dmacount = cpu_to_le32p (&dmacount);
+        td->dmacount = cpu_to_le32(dmacount);
 }
 
 static const u32 dmactl_default =
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index 34e9e393f929..57d9641c6bf8 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -3006,7 +3006,7 @@ cleanup1:
 
 cleanup0:
         if (xceiv)
-                put_device(xceiv->dev);
+                otg_put_transceiver(xceiv);
 
         if (cpu_is_omap16xx() || cpu_is_omap24xx()) {
                 clk_disable(hhc_clk);
@@ -3034,7 +3034,7 @@ static int __exit omap_udc_remove(struct platform_device *pdev)
 
         pullup_disable(udc);
         if (udc->transceiver) {
-                put_device(udc->transceiver->dev);
+                otg_put_transceiver(udc->transceiver);
                 udc->transceiver = NULL;
         }
         omap_writew(0, UDC_SYSCON1);
diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
index 697a0ca349bf..9b36205c5759 100644
--- a/drivers/usb/gadget/pxa25x_udc.c
+++ b/drivers/usb/gadget/pxa25x_udc.c
@@ -2198,7 +2198,7 @@ static int __init pxa25x_udc_probe(struct platform_device *pdev)
         udc_disable(dev);
         udc_reinit(dev);
 
-        dev->vbus = is_vbus_present();
+        dev->vbus = !!is_vbus_present();
 
         /* irq setup after old hardware state is cleaned up */
         retval = request_irq(irq, pxa25x_udc_irq,
diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
index 65110d02a206..990f40f988d4 100644
--- a/drivers/usb/gadget/pxa27x_udc.c
+++ b/drivers/usb/gadget/pxa27x_udc.c
@@ -430,7 +430,6 @@ static void pio_irq_enable(struct pxa_ep *ep)
 /**
  * pio_irq_disable - Disables irq generation for one endpoint
  * @ep: udc endpoint
- * @index: endpoint number
  */
 static void pio_irq_disable(struct pxa_ep *ep)
 {
@@ -586,7 +585,6 @@ static void inc_ep_stats_reqs(struct pxa_ep *ep, int is_in)
  * inc_ep_stats_bytes - Update ep stats counts
  * @ep: physical endpoint
  * @count: bytes transfered on endpoint
- * @req: usb request
  * @is_in: ep direction (USB_DIR_IN or 0)
  */
 static void inc_ep_stats_bytes(struct pxa_ep *ep, int count, int is_in)
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index c7e255636803..9a2b8920532d 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -36,6 +36,7 @@
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/gpio.h>
 
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
@@ -51,7 +52,6 @@
 #include <mach/irqs.h>
 
 #include <mach/hardware.h>
-#include <mach/regs-gpio.h>
 
 #include <plat/regs-udc.h>
 #include <plat/udc.h>
@@ -1510,11 +1510,7 @@ static irqreturn_t s3c2410_udc_vbus_irq(int irq, void *_dev)
 
         dprintk(DEBUG_NORMAL, "%s()\n", __func__);
 
-        /* some cpus cannot read from an line configured to IRQ! */
-        s3c2410_gpio_cfgpin(udc_info->vbus_pin, S3C2410_GPIO_INPUT);
-        value = s3c2410_gpio_getpin(udc_info->vbus_pin);
-        s3c2410_gpio_cfgpin(udc_info->vbus_pin, S3C2410_GPIO_SFN2);
-
+        value = gpio_get_value(udc_info->vbus_pin) ? 1 : 0;
         if (udc_info->vbus_pin_inverted)
                 value = !value;
 
@@ -1802,7 +1798,7 @@ static int s3c2410_udc_probe(struct platform_device *pdev)
         struct s3c2410_udc *udc = &memory;
         struct device *dev = &pdev->dev;
         int retval;
-        unsigned int irq;
+        int irq;
 
         dev_dbg(dev, "%s()\n", __func__);
 
@@ -1861,7 +1857,7 @@ static int s3c2410_udc_probe(struct platform_device *pdev)
 
         /* irq setup after old hardware state is cleaned up */
         retval = request_irq(IRQ_USBD, s3c2410_udc_irq,
-                        IRQF_DISABLED, gadget_name, udc);
+                             IRQF_DISABLED, gadget_name, udc);
 
         if (retval != 0) {
                 dev_err(dev, "cannot get irq %i, err %d\n", IRQ_USBD, retval);
@@ -1872,17 +1868,28 @@ static int s3c2410_udc_probe(struct platform_device *pdev)
         dev_dbg(dev, "got irq %i\n", IRQ_USBD);
 
         if (udc_info && udc_info->vbus_pin > 0) {
-                irq = s3c2410_gpio_getirq(udc_info->vbus_pin);
+                retval = gpio_request(udc_info->vbus_pin, "udc vbus");
+                if (retval < 0) {
+                        dev_err(dev, "cannot claim vbus pin\n");
+                        goto err_int;
+                }
+
+                irq = gpio_to_irq(udc_info->vbus_pin);
+                if (irq < 0) {
+                        dev_err(dev, "no irq for gpio vbus pin\n");
+                        goto err_gpio_claim;
+                }
+
                 retval = request_irq(irq, s3c2410_udc_vbus_irq,
                                      IRQF_DISABLED | IRQF_TRIGGER_RISING
                                      | IRQF_TRIGGER_FALLING | IRQF_SHARED,
                                      gadget_name, udc);
 
                 if (retval != 0) {
-                        dev_err(dev, "can't get vbus irq %i, err %d\n",
+                        dev_err(dev, "can't get vbus irq %d, err %d\n",
                                 irq, retval);
                         retval = -EBUSY;
-                        goto err_int;
+                        goto err_gpio_claim;
                 }
 
                 dev_dbg(dev, "got irq %i\n", irq);
@@ -1902,6 +1909,9 @@ static int s3c2410_udc_probe(struct platform_device *pdev)
 
         return 0;
 
+err_gpio_claim:
+        if (udc_info && udc_info->vbus_pin > 0)
+                gpio_free(udc_info->vbus_pin);
 err_int:
         free_irq(IRQ_USBD, udc);
 err_map:
@@ -1927,7 +1937,7 @@ static int s3c2410_udc_remove(struct platform_device *pdev)
         debugfs_remove(udc->regs_info);
 
         if (udc_info && udc_info->vbus_pin > 0) {
-                irq = s3c2410_gpio_getirq(udc_info->vbus_pin);
+                irq = gpio_to_irq(udc_info->vbus_pin);
                 free_irq(irq, udc);
         }