Merge branch 'master' into for-next

Merge with latest Linus' tree, as I have incoming patches
that fix code that is newer than current HEAD of for-next.

Conflicts:
	drivers/net/ethernet/realtek/r8169.c

56 files changed, 2795 insertions, 715 deletions

diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index b5972e0f949e..2633f7595116 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -137,7 +137,7 @@ choice
 
 config USB_AT91
         tristate "Atmel AT91 USB Device Port"
-        depends on ARCH_AT91 && !ARCH_AT91SAM9RL && !ARCH_AT91CAP9 && !ARCH_AT91SAM9G45
+        depends on ARCH_AT91
         help
            Many Atmel AT91 processors (such as the AT91RM2000) have a
            full speed USB Device Port with support for five configurable
@@ -150,7 +150,7 @@ config USB_AT91
 config USB_ATMEL_USBA
         tristate "Atmel USBA"
         select USB_GADGET_DUALSPEED
-        depends on AVR32 || ARCH_AT91CAP9 || ARCH_AT91SAM9RL || ARCH_AT91SAM9G45
+        depends on AVR32 || ARCH_AT91SAM9RL || ARCH_AT91SAM9G45
         help
           USBA is the integrated high-speed USB Device controller on
           the AT32AP700x, some AT91SAM9 and AT91CAP9 processors from Atmel.
@@ -284,7 +284,7 @@ config USB_IMX
 
 config USB_S3C2410
         tristate "S3C2410 USB Device Controller"
-        depends on ARCH_S3C2410
+        depends on ARCH_S3C24XX
         help
           Samsung's S3C2410 is an ARM-4 processor with an integrated
           full speed USB 1.1 device controller.  It has 4 configurable
@@ -299,7 +299,7 @@ config USB_S3C2410_DEBUG
 
 config USB_S3C_HSUDC
         tristate "S3C2416, S3C2443 and S3C2450 USB Device Controller"
-        depends on ARCH_S3C2410
+        depends on ARCH_S3C24XX
         select USB_GADGET_DUALSPEED
         help
           Samsung's S3C2416, S3C2443 and S3C2450 is an ARM9 based SoC
@@ -599,16 +599,29 @@ config USB_AUDIO
         depends on SND
         select SND_PCM
         help
-          Gadget Audio is compatible with USB Audio Class specification 1.0.
-          It will include at least one AudioControl interface, zero or more
-          AudioStream interface and zero or more MIDIStream interface.
-
-          Gadget Audio will use on-board ALSA (CONFIG_SND) audio card to
-          playback or capture audio stream.
+          This Gadget Audio driver is compatible with USB Audio Class
+          specification 2.0. It implements 1 AudioControl interface,
+          1 AudioStreaming Interface each for USB-OUT and USB-IN.
+          Number of channels, sample rate and sample size can be
+          specified as module parameters.
+          This driver doesn't expect any real Audio codec to be present
+          on the device - the audio streams are simply sinked to and
+          sourced from a virtual ALSA sound card created. The user-space
+          application may choose to do whatever it wants with the data
+          received from the USB Host and choose to provide whatever it
+          wants as audio data to the USB Host.
 
           Say "y" to link the driver statically, or "m" to build a
           dynamically linked module called "g_audio".
 
+config GADGET_UAC1
+        bool "UAC 1.0 (Legacy)"
+        depends on USB_AUDIO
+        help
+          If you instead want older UAC Spec-1.0 driver that also has audio
+          paths hardwired to the Audio codec chip on-board and doesn't work
+          without one.
+
 config USB_ETH
         tristate "Ethernet Gadget (with CDC Ethernet support)"
         depends on NET
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index c16ff55a74e8..77779271f487 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -29,7 +29,7 @@
 
 /* Driver strings */
 #define UDC_MOD_DESCRIPTION             "AMD 5536 UDC - USB Device Controller"
-#define UDC_DRIVER_VERSION_STRING       "01.00.0206 - $Revision: #3 $"
+#define UDC_DRIVER_VERSION_STRING       "01.00.0206"
 
 /* system */
 #include <linux/module.h>
@@ -54,7 +54,6 @@
 #include <linux/prefetch.h>
 
 #include <asm/byteorder.h>
-#include <asm/system.h>
 #include <asm/unaligned.h>
 
 /* gadget stack */
@@ -140,7 +139,7 @@ static DECLARE_TASKLET(disconnect_tasklet, udc_tasklet_disconnect,
 
 /* endpoint names used for print */
 static const char ep0_string[] = "ep0in";
-static const char *ep_string[] = {
+static const char *const ep_string[] = {
         ep0_string,
         "ep1in-int", "ep2in-bulk", "ep3in-bulk", "ep4in-bulk", "ep5in-bulk",
         "ep6in-bulk", "ep7in-bulk", "ep8in-bulk", "ep9in-bulk", "ep10in-bulk",
@@ -204,9 +203,8 @@ static void print_regs(struct udc *dev)
                 DBG(dev, "DMA mode       = BF (buffer fill mode)\n");
                 dev_info(&dev->pdev->dev, "DMA mode (%s)\n", "BF");
         }
-        if (!use_dma) {
+        if (!use_dma)
                 dev_info(&dev->pdev->dev, "FIFO mode\n");
-        }
         DBG(dev, "-------------------------------------------------------\n");
 }
 
@@ -445,6 +443,7 @@ static void ep_init(struct udc_regs __iomem *regs, struct udc_ep *ep)
 
         VDBG(ep->dev, "ep-%d reset\n", ep->num);
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         ep->ep.ops = &udc_ep_ops;
         INIT_LIST_HEAD(&ep->queue);
 
@@ -569,9 +568,8 @@ udc_free_request(struct usb_ep *usbep, struct usb_request *usbreq)
                 VDBG(ep->dev, "req->td_data=%p\n", req->td_data);
 
                 /* free dma chain if created */
-                if (req->chain_len > 1) {
+                if (req->chain_len > 1)
                         udc_free_dma_chain(ep->dev, req);
-                }
 
                 pci_pool_free(ep->dev->data_requests, req->td_data,
                                                         req->td_phys);
@@ -639,9 +637,8 @@ udc_txfifo_write(struct udc_ep *ep, struct usb_request *req)
                 bytes = remaining;
 
         /* dwords first */
-        for (i = 0; i < bytes / UDC_DWORD_BYTES; i++) {
+        for (i = 0; i < bytes / UDC_DWORD_BYTES; i++)
                 writel(*(buf + i), ep->txfifo);
-        }
 
         /* remaining bytes must be written by byte access */
         for (j = 0; j < bytes % UDC_DWORD_BYTES; j++) {
@@ -660,9 +657,8 @@ static int udc_rxfifo_read_dwords(struct udc *dev, u32 *buf, int dwords)
 
         VDBG(dev, "udc_read_dwords(): %d dwords\n", dwords);
 
-        for (i = 0; i < dwords; i++) {
+        for (i = 0; i < dwords; i++)
                 *(buf + i) = readl(dev->rxfifo);
-        }
         return 0;
 }
 
@@ -675,9 +671,8 @@ static int udc_rxfifo_read_bytes(struct udc *dev, u8 *buf, int bytes)
         VDBG(dev, "udc_read_bytes(): %d bytes\n", bytes);
 
         /* dwords first */
-        for (i = 0; i < bytes / UDC_DWORD_BYTES; i++) {
+        for (i = 0; i < bytes / UDC_DWORD_BYTES; i++)
                 *((u32 *)(buf + (i<<2))) = readl(dev->rxfifo);
-        }
 
         /* remaining bytes must be read by byte access */
         if (bytes % UDC_DWORD_BYTES) {
@@ -831,20 +826,8 @@ __acquires(ep->dev->lock)
 
         dev = ep->dev;
         /* unmap DMA */
-        if (req->dma_mapping) {
-                if (ep->in)
-                        pci_unmap_single(dev->pdev,
-                                        req->req.dma,
-                                        req->req.length,
-                                        PCI_DMA_TODEVICE);
-                else
-                        pci_unmap_single(dev->pdev,
-                                        req->req.dma,
-                                        req->req.length,
-                                        PCI_DMA_FROMDEVICE);
-                req->dma_mapping = 0;
-                req->req.dma = DMA_DONT_USE;
-        }
+        if (ep->dma)
+                usb_gadget_unmap_request(&dev->gadget, &req->req, ep->in);
 
         halted = ep->halted;
         ep->halted = 1;
@@ -897,9 +880,8 @@ static struct udc_data_dma *udc_get_last_dma_desc(struct udc_request *req)
         struct udc_data_dma     *td;
 
         td = req->td_data;
-        while (td && !(td->status & AMD_BIT(UDC_DMA_IN_STS_L))) {
+        while (td && !(td->status & AMD_BIT(UDC_DMA_IN_STS_L)))
                 td = phys_to_virt(td->next);
-        }
 
         return td;
 
@@ -949,21 +931,18 @@ static int udc_create_dma_chain(
         dma_addr = DMA_DONT_USE;
 
         /* unset L bit in first desc for OUT */
-        if (!ep->in) {
+        if (!ep->in)
                 req->td_data->status &= AMD_CLEAR_BIT(UDC_DMA_IN_STS_L);
-        }
 
         /* alloc only new desc's if not already available */
         len = req->req.length / ep->ep.maxpacket;
-        if (req->req.length % ep->ep.maxpacket) {
+        if (req->req.length % ep->ep.maxpacket)
                 len++;
-        }
 
         if (len > req->chain_len) {
                 /* shorter chain already allocated before */
-                if (req->chain_len > 1) {
+                if (req->chain_len > 1)
                         udc_free_dma_chain(ep->dev, req);
-                }
                 req->chain_len = len;
                 create_new_chain = 1;
         }
@@ -1006,11 +985,12 @@ static int udc_create_dma_chain(
 
                 /* link td and assign tx bytes */
                 if (i == buf_len) {
-                        if (create_new_chain) {
+                        if (create_new_chain)
                                 req->td_data->next = dma_addr;
-                        } else {
-                                /* req->td_data->next = virt_to_phys(td); */
-                        }
+                        /*
+                        else
+                                req->td_data->next = virt_to_phys(td);
+                        */
                         /* write tx bytes */
                         if (ep->in) {
                                 /* first desc */
@@ -1024,11 +1004,12 @@ static int udc_create_dma_chain(
                                                         UDC_DMA_IN_STS_TXBYTES);
                         }
                 } else {
-                        if (create_new_chain) {
+                        if (create_new_chain)
                                 last->next = dma_addr;
-                        } else {
-                                /* last->next = virt_to_phys(td); */
-                        }
+                        /*
+                        else
+                                last->next = virt_to_phys(td);
+                        */
                         if (ep->in) {
                                 /* write tx bytes */
                                 td->status = AMD_ADDBITS(td->status,
@@ -1095,20 +1076,11 @@ udc_queue(struct usb_ep *usbep, struct usb_request *usbreq, gfp_t gfp)
                 return -ESHUTDOWN;
 
         /* map dma (usually done before) */
-        if (ep->dma && usbreq->length != 0
-                        && (usbreq->dma == DMA_DONT_USE || usbreq->dma == 0)) {
+        if (ep->dma) {
                 VDBG(dev, "DMA map req %p\n", req);
-                if (ep->in)
-                        usbreq->dma = pci_map_single(dev->pdev,
-                                                usbreq->buf,
-                                                usbreq->length,
-                                                PCI_DMA_TODEVICE);
-                else
-                        usbreq->dma = pci_map_single(dev->pdev,
-                                                usbreq->buf,
-                                                usbreq->length,
-                                                PCI_DMA_FROMDEVICE);
-                req->dma_mapping = 1;
+                retval = usb_gadget_map_request(&udc->gadget, usbreq, ep->in);
+                if (retval)
+                        return retval;
         }
 
         VDBG(dev, "%s queue req %p, len %d req->td_data=%p buf %p\n",
@@ -1479,11 +1451,10 @@ static int startup_registers(struct udc *dev)
 
         /* program speed */
         tmp = readl(&dev->regs->cfg);
-        if (use_fullspeed) {
+        if (use_fullspeed)
                 tmp = AMD_ADDBITS(tmp, UDC_DEVCFG_SPD_FS, UDC_DEVCFG_SPD);
-        } else {
+        else
                 tmp = AMD_ADDBITS(tmp, UDC_DEVCFG_SPD_HS, UDC_DEVCFG_SPD);
-        }
         writel(tmp, &dev->regs->cfg);
 
         return 0;
@@ -1504,9 +1475,8 @@ static void udc_basic_init(struct udc *dev)
                 mod_timer(&udc_timer, jiffies - 1);
         }
         /* stop poll stall timer */
-        if (timer_pending(&udc_pollstall_timer)) {
+        if (timer_pending(&udc_pollstall_timer))
                 mod_timer(&udc_pollstall_timer, jiffies - 1);
-        }
         /* disable DMA */
         tmp = readl(&dev->regs->ctl);
         tmp &= AMD_UNMASK_BIT(UDC_DEVCTL_RDE);
@@ -1540,11 +1510,10 @@ static void udc_setup_endpoints(struct udc *dev)
         /* read enum speed */
         tmp = readl(&dev->regs->sts);
         tmp = AMD_GETBITS(tmp, UDC_DEVSTS_ENUM_SPEED);
-        if (tmp == UDC_DEVSTS_ENUM_SPEED_HIGH) {
+        if (tmp == UDC_DEVSTS_ENUM_SPEED_HIGH)
                 dev->gadget.speed = USB_SPEED_HIGH;
-        } else if (tmp == UDC_DEVSTS_ENUM_SPEED_FULL) {
+        else if (tmp == UDC_DEVSTS_ENUM_SPEED_FULL)
                 dev->gadget.speed = USB_SPEED_FULL;
-        }
 
         /* set basic ep parameters */
         for (tmp = 0; tmp < UDC_EP_NUM; tmp++) {
@@ -1570,9 +1539,8 @@ static void udc_setup_endpoints(struct udc *dev)
                  * disabling ep interrupts when ENUM interrupt occurs but ep is
                  * not enabled by gadget driver
                  */
-                if (!ep->desc) {
+                if (!ep->desc)
                         ep_init(dev->regs, ep);
-                }
 
                 if (use_dma) {
                         /*
@@ -1670,9 +1638,8 @@ static void udc_tasklet_disconnect(unsigned long par)
                 spin_lock(&dev->lock);
 
                 /* empty queues */
-                for (tmp = 0; tmp < UDC_EP_NUM; tmp++) {
+                for (tmp = 0; tmp < UDC_EP_NUM; tmp++)
                         empty_req_queue(&dev->ep[tmp]);
-                }
 
         }
 
@@ -1746,9 +1713,8 @@ static void udc_timer_function(unsigned long v)
                          * open the fifo
                          */
                         udc_timer.expires = jiffies + HZ/UDC_RDE_TIMER_DIV;
-                        if (!stop_timer) {
+                        if (!stop_timer)
                                 add_timer(&udc_timer);
-                        }
                 } else {
                         /*
                          * fifo contains data now, setup timer for opening
@@ -1760,9 +1726,8 @@ static void udc_timer_function(unsigned long v)
                         set_rde++;
                         /* debug: lhadmot_timer_start = 221070 */
                         udc_timer.expires = jiffies + HZ*UDC_RDE_TIMER_SECONDS;
-                        if (!stop_timer) {
+                        if (!stop_timer)
                                 add_timer(&udc_timer);
-                        }
                 }
 
         } else
@@ -1907,19 +1872,17 @@ static void activate_control_endpoints(struct udc *dev)
                         mod_timer(&udc_timer, jiffies - 1);
                 }
                 /* stop pollstall timer */
-                if (timer_pending(&udc_pollstall_timer)) {
+                if (timer_pending(&udc_pollstall_timer))
                         mod_timer(&udc_pollstall_timer, jiffies - 1);
-                }
                 /* enable DMA */
                 tmp = readl(&dev->regs->ctl);
                 tmp |= AMD_BIT(UDC_DEVCTL_MODE)
                                 | AMD_BIT(UDC_DEVCTL_RDE)
                                 | AMD_BIT(UDC_DEVCTL_TDE);
-                if (use_dma_bufferfill_mode) {
+                if (use_dma_bufferfill_mode)
                         tmp |= AMD_BIT(UDC_DEVCTL_BF);
-                } else if (use_dma_ppb_du) {
+                else if (use_dma_ppb_du)
                         tmp |= AMD_BIT(UDC_DEVCTL_DU);
-                }
                 writel(tmp, &dev->regs->ctl);
         }
 
@@ -2104,9 +2067,8 @@ static void udc_ep0_set_rde(struct udc *dev)
                                 udc_timer.expires =
                                         jiffies + HZ/UDC_RDE_TIMER_DIV;
                                 set_rde = 1;
-                                if (!stop_timer) {
+                                if (!stop_timer)
                                         add_timer(&udc_timer);
-                                }
                         }
                 }
         }
@@ -2131,7 +2093,7 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int ep_ix)
         if (use_dma) {
                 /* BNA event ? */
                 if (tmp & AMD_BIT(UDC_EPSTS_BNA)) {
-                        DBG(dev, "BNA ep%dout occurred - DESPTR = %x \n",
+                        DBG(dev, "BNA ep%dout occurred - DESPTR = %x\n",
                                         ep->num, readl(&ep->regs->desptr));
                         /* clear BNA */
                         writel(tmp | AMD_BIT(UDC_EPSTS_BNA), &ep->regs->sts);
@@ -2294,9 +2256,8 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int ep_ix)
                                                 jiffies
                                                 + HZ*UDC_RDE_TIMER_SECONDS;
                                         set_rde = 1;
-                                        if (!stop_timer) {
+                                        if (!stop_timer)
                                                 add_timer(&udc_timer);
-                                        }
                                 }
                                 if (ep->num != UDC_EP0OUT_IX)
                                         dev->data_ep_queued = 0;
@@ -2318,9 +2279,8 @@ static irqreturn_t udc_data_out_isr(struct udc *dev, int ep_ix)
         /* check pending CNAKS */
         if (cnak_pending) {
                 /* CNAk processing when rxfifo empty only */
-                if (readl(&dev->regs->sts) & AMD_BIT(UDC_DEVSTS_RXFIFO_EMPTY)) {
+                if (readl(&dev->regs->sts) & AMD_BIT(UDC_DEVSTS_RXFIFO_EMPTY))
                         udc_process_cnak_queue(dev);
-                }
         }
 
         /* clear OUT bits in ep status */
@@ -2348,7 +2308,7 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int ep_ix)
                 /* BNA ? */
                 if (epsts & AMD_BIT(UDC_EPSTS_BNA)) {
                         dev_err(&dev->pdev->dev,
-                                "BNA ep%din occurred - DESPTR = %08lx \n",
+                                "BNA ep%din occurred - DESPTR = %08lx\n",
                                 ep->num,
                                 (unsigned long) readl(&ep->regs->desptr));
 
@@ -2361,7 +2321,7 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int ep_ix)
         /* HE event ? */
         if (epsts & AMD_BIT(UDC_EPSTS_HE)) {
                 dev_err(&dev->pdev->dev,
-                        "HE ep%dn occurred - DESPTR = %08lx \n",
+                        "HE ep%dn occurred - DESPTR = %08lx\n",
                         ep->num, (unsigned long) readl(&ep->regs->desptr));
 
                 /* clear HE */
@@ -2427,9 +2387,9 @@ static irqreturn_t udc_data_in_isr(struct udc *dev, int ep_ix)
                                 /* write fifo */
                                 udc_txfifo_write(ep, &req->req);
                                 len = req->req.length - req->req.actual;
-                                                if (len > ep->ep.maxpacket)
-                                                        len = ep->ep.maxpacket;
-                                                req->req.actual += len;
+                                if (len > ep->ep.maxpacket)
+                                        len = ep->ep.maxpacket;
+                                req->req.actual += len;
                                 if (req->req.actual == req->req.length
                                         || (len != ep->ep.maxpacket)) {
                                         /* complete req */
@@ -2581,9 +2541,8 @@ __acquires(dev->lock)
                         if (!timer_pending(&udc_timer)) {
                                 udc_timer.expires = jiffies +
                                                         HZ/UDC_RDE_TIMER_DIV;
-                                if (!stop_timer) {
+                                if (!stop_timer)
                                         add_timer(&udc_timer);
-                                }
                         }
                 }
 
@@ -2697,9 +2656,8 @@ __acquires(dev->lock)
         /* check pending CNAKS */
         if (cnak_pending) {
                 /* CNAk processing when rxfifo empty only */
-                if (readl(&dev->regs->sts) & AMD_BIT(UDC_DEVSTS_RXFIFO_EMPTY)) {
+                if (readl(&dev->regs->sts) & AMD_BIT(UDC_DEVSTS_RXFIFO_EMPTY))
                         udc_process_cnak_queue(dev);
-                }
         }
 
 finished:
@@ -2723,7 +2681,7 @@ static irqreturn_t udc_control_in_isr(struct udc *dev)
         tmp = readl(&dev->ep[UDC_EP0IN_IX].regs->sts);
         /* DMA completion */
         if (tmp & AMD_BIT(UDC_EPSTS_TDC)) {
-                VDBG(dev, "isr: TDC clear \n");
+                VDBG(dev, "isr: TDC clear\n");
                 ret_val = IRQ_HANDLED;
 
                 /* clear TDC bit */
@@ -3426,7 +3384,7 @@ static int udc_remote_wakeup(struct udc *dev)
 }
 
 /* PCI device parameters */
-static const struct pci_device_id pci_id[] = {
+static DEFINE_PCI_DEVICE_TABLE(pci_id) = {
         {
                 PCI_DEVICE(PCI_VENDOR_ID_AMD, 0x2096),
                 .class =        (PCI_CLASS_SERIAL_USB << 8) | 0xfe,
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 143a7256b598..0c935d7c65bd 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -29,18 +29,19 @@
 #include <linux/clk.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
-#include <linux/prefetch.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
 
 #include <asm/byteorder.h>
 #include <mach/hardware.h>
 #include <asm/io.h>
 #include <asm/irq.h>
-#include <asm/system.h>
 #include <asm/gpio.h>
 
 #include <mach/board.h>
 #include <mach/cpu.h>
 #include <mach/at91sam9261_matrix.h>
+#include <mach/at91_matrix.h>
 
 #include "at91_udc.h"
 
@@ -558,6 +559,7 @@ static int at91_ep_disable (struct usb_ep * _ep)
 
         /* restore the endpoint's pristine config */
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         ep->ep.maxpacket = ep->maxpacket;
 
         /* reset fifos and endpoint */
@@ -910,9 +912,9 @@ static void pullup(struct at91_udc *udc, int is_on)
                 } else if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()) {
                         u32     usbpucr;
 
-                        usbpucr = at91_sys_read(AT91_MATRIX_USBPUCR);
+                        usbpucr = at91_matrix_read(AT91_MATRIX_USBPUCR);
                         usbpucr |= AT91_MATRIX_USBPUCR_PUON;
-                        at91_sys_write(AT91_MATRIX_USBPUCR, usbpucr);
+                        at91_matrix_write(AT91_MATRIX_USBPUCR, usbpucr);
                 }
         } else {
                 stop_activity(udc);
@@ -928,9 +930,9 @@ static void pullup(struct at91_udc *udc, int is_on)
                 } else if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()) {
                         u32     usbpucr;
 
-                        usbpucr = at91_sys_read(AT91_MATRIX_USBPUCR);
+                        usbpucr = at91_matrix_read(AT91_MATRIX_USBPUCR);
                         usbpucr &= ~AT91_MATRIX_USBPUCR_PUON;
-                        at91_sys_write(AT91_MATRIX_USBPUCR, usbpucr);
+                        at91_matrix_write(AT91_MATRIX_USBPUCR, usbpucr);
                 }
                 clk_off(udc);
         }
@@ -1706,7 +1708,27 @@ static void at91udc_shutdown(struct platform_device *dev)
         spin_unlock_irqrestore(&udc->lock, flags);
 }
 
-static int __init at91udc_probe(struct platform_device *pdev)
+static void __devinit at91udc_of_init(struct at91_udc *udc,
+                                     struct device_node *np)
+{
+        struct at91_udc_data *board = &udc->board;
+        u32 val;
+        enum of_gpio_flags flags;
+
+        if (of_property_read_u32(np, "atmel,vbus-polled", &val) == 0)
+                board->vbus_polled = 1;
+
+        board->vbus_pin = of_get_named_gpio_flags(np, "atmel,vbus-gpio", 0,
+                                                  &flags);
+        board->vbus_active_low = (flags & OF_GPIO_ACTIVE_LOW) ? 1 : 0;
+
+        board->pullup_pin = of_get_named_gpio_flags(np, "atmel,pullup-gpio", 0,
+                                                  &flags);
+
+        board->pullup_active_low = (flags & OF_GPIO_ACTIVE_LOW) ? 1 : 0;
+}
+
+static int __devinit at91udc_probe(struct platform_device *pdev)
 {
         struct device   *dev = &pdev->dev;
         struct at91_udc *udc;
@@ -1741,7 +1763,11 @@ static int __init at91udc_probe(struct platform_device *pdev)
         /* init software state */
         udc = &controller;
         udc->gadget.dev.parent = dev;
-        udc->board = *(struct at91_udc_data *) dev->platform_data;
+        if (pdev->dev.of_node)
+                at91udc_of_init(udc, pdev->dev.of_node);
+        else
+                memcpy(&udc->board, dev->platform_data,
+                       sizeof(struct at91_udc_data));
         udc->pdev = pdev;
         udc->enabled = 0;
         spin_lock_init(&udc->lock);
@@ -1970,6 +1996,15 @@ static int at91udc_resume(struct platform_device *pdev)
 #define at91udc_resume  NULL
 #endif
 
+#if defined(CONFIG_OF)
+static const struct of_device_id at91_udc_dt_ids[] = {
+        { .compatible = "atmel,at91rm9200-udc" },
+        { /* sentinel */ }
+};
+
+MODULE_DEVICE_TABLE(of, at91_udc_dt_ids);
+#endif
+
 static struct platform_driver at91_udc_driver = {
         .remove         = __exit_p(at91udc_remove),
         .shutdown       = at91udc_shutdown,
@@ -1978,6 +2013,7 @@ static struct platform_driver at91_udc_driver = {
         .driver         = {
                 .name   = (char *) driver_name,
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(at91_udc_dt_ids),
         },
 };
 
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index e2fb6d583bd9..9f98508966d1 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -332,12 +332,12 @@ static int vbus_is_present(struct usba_udc *udc)
 
 static void toggle_bias(int is_on)
 {
-        unsigned int uckr = at91_sys_read(AT91_CKGR_UCKR);
+        unsigned int uckr = at91_pmc_read(AT91_CKGR_UCKR);
 
         if (is_on)
-                at91_sys_write(AT91_CKGR_UCKR, uckr | AT91_PMC_BIASEN);
+                at91_pmc_write(AT91_CKGR_UCKR, uckr | AT91_PMC_BIASEN);
         else
-                at91_sys_write(AT91_CKGR_UCKR, uckr & ~(AT91_PMC_BIASEN));
+                at91_pmc_write(AT91_CKGR_UCKR, uckr & ~(AT91_PMC_BIASEN));
 }
 
 #else
@@ -659,6 +659,7 @@ static int usba_ep_disable(struct usb_ep *_ep)
                 return -EINVAL;
         }
         ep->desc = NULL;
+        ep->ep.desc = NULL;
 
         list_splice_init(&ep->queue, &req_list);
         if (ep->can_dma) {
diff --git a/drivers/usb/gadget/audio.c b/drivers/usb/gadget/audio.c
index 9d89ae4765a9..98899244860e 100644
--- a/drivers/usb/gadget/audio.c
+++ b/drivers/usb/gadget/audio.c
@@ -14,10 +14,8 @@
 #include <linux/kernel.h>
 #include <linux/utsname.h>
 
-#include "u_audio.h"
-
 #define DRIVER_DESC             "Linux USB Audio Gadget"
-#define DRIVER_VERSION          "Dec 18, 2008"
+#define DRIVER_VERSION          "Feb 2, 2012"
 
 /*-------------------------------------------------------------------------*/
 
@@ -33,8 +31,36 @@
 #include "config.c"
 #include "epautoconf.c"
 
-#include "u_audio.c"
-#include "f_audio.c"
+/* string IDs are assigned dynamically */
+
+#define STRING_MANUFACTURER_IDX         0
+#define STRING_PRODUCT_IDX              1
+
+static char manufacturer[50];
+
+static struct usb_string strings_dev[] = {
+        [STRING_MANUFACTURER_IDX].s = manufacturer,
+        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings stringtab_dev = {
+        .language = 0x0409,     /* en-us */
+        .strings = strings_dev,
+};
+
+static struct usb_gadget_strings *audio_strings[] = {
+        &stringtab_dev,
+        NULL,
+};
+
+#ifdef CONFIG_GADGET_UAC1
+#include "u_uac1.h"
+#include "u_uac1.c"
+#include "f_uac1.c"
+#else
+#include "f_uac2.c"
+#endif
 
 /*-------------------------------------------------------------------------*/
 
@@ -54,9 +80,15 @@ static struct usb_device_descriptor device_desc = {
 
         .bcdUSB =               __constant_cpu_to_le16(0x200),
 
+#ifdef CONFIG_GADGET_UAC1
         .bDeviceClass =         USB_CLASS_PER_INTERFACE,
         .bDeviceSubClass =      0,
         .bDeviceProtocol =      0,
+#else
+        .bDeviceClass =         USB_CLASS_MISC,
+        .bDeviceSubClass =      0x02,
+        .bDeviceProtocol =      0x01,
+#endif
         /* .bMaxPacketSize0 = f(hardware) */
 
         /* Vendor and product id defaults change according to what configs
@@ -108,6 +140,9 @@ static struct usb_configuration audio_config_driver = {
         .bConfigurationValue    = 1,
         /* .iConfiguration = DYNAMIC */
         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
+#ifndef CONFIG_GADGET_UAC1
+        .unbind                 = uac2_unbind_config,
+#endif
 };
 
 /*-------------------------------------------------------------------------*/
@@ -157,7 +192,9 @@ fail:
 
 static int __exit audio_unbind(struct usb_composite_dev *cdev)
 {
+#ifdef CONFIG_GADGET_UAC1
         gaudio_cleanup();
+#endif
         return 0;
 }
 
diff --git a/drivers/usb/gadget/ci13xxx_msm.c b/drivers/usb/gadget/ci13xxx_msm.c
index 1fc612914c52..d07e44c05e9b 100644
--- a/drivers/usb/gadget/ci13xxx_msm.c
+++ b/drivers/usb/gadget/ci13xxx_msm.c
@@ -37,10 +37,10 @@ static void ci13xxx_msm_notify_event(struct ci13xxx *udc, unsigned event)
                  * Put the transceiver in non-driving mode. Otherwise host
                  * may not detect soft-disconnection.
                  */
-                val = otg_io_read(udc->transceiver, ULPI_FUNC_CTRL);
+                val = usb_phy_io_read(udc->transceiver, ULPI_FUNC_CTRL);
                 val &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
                 val |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
-                otg_io_write(udc->transceiver, val, ULPI_FUNC_CTRL);
+                usb_phy_io_write(udc->transceiver, val, ULPI_FUNC_CTRL);
                 break;
         default:
                 dev_dbg(dev, "unknown ci13xxx_udc event\n");
diff --git a/drivers/usb/gadget/ci13xxx_udc.c b/drivers/usb/gadget/ci13xxx_udc.c
index 27e313718422..243ef1adf969 100644
--- a/drivers/usb/gadget/ci13xxx_udc.c
+++ b/drivers/usb/gadget/ci13xxx_udc.c
@@ -2181,6 +2181,7 @@ static int ep_disable(struct usb_ep *ep)
         } while (mEp->dir != direction);
 
         mEp->desc = NULL;
+        mEp->ep.desc = NULL;
 
         spin_unlock_irqrestore(mEp->lock, flags);
         return retval;
@@ -2537,7 +2538,7 @@ static int ci13xxx_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
         struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget);
 
         if (udc->transceiver)
-                return otg_set_power(udc->transceiver, mA);
+                return usb_phy_set_power(udc->transceiver, mA);
         return -ENOTSUPP;
 }
 
@@ -2900,7 +2901,7 @@ static int udc_probe(struct ci13xxx_udc_driver *driver, struct device *dev,
         if (retval < 0)
                 goto free_udc;
 
-        udc->transceiver = otg_get_transceiver();
+        udc->transceiver = usb_get_transceiver();
 
         if (udc->udc_driver->flags & CI13XXX_REQUIRE_TRANSCEIVER) {
                 if (udc->transceiver == NULL) {
@@ -2928,7 +2929,8 @@ static int udc_probe(struct ci13xxx_udc_driver *driver, struct device *dev,
                 goto unreg_device;
 
         if (udc->transceiver) {
-                retval = otg_set_peripheral(udc->transceiver, &udc->gadget);
+                retval = otg_set_peripheral(udc->transceiver->otg,
+                                                &udc->gadget);
                 if (retval)
                         goto remove_dbg;
         }
@@ -2945,8 +2947,8 @@ static int udc_probe(struct ci13xxx_udc_driver *driver, struct device *dev,
 
 remove_trans:
         if (udc->transceiver) {
-                otg_set_peripheral(udc->transceiver, &udc->gadget);
-                otg_put_transceiver(udc->transceiver);
+                otg_set_peripheral(udc->transceiver->otg, &udc->gadget);
+                usb_put_transceiver(udc->transceiver);
         }
 
         err("error = %i", retval);
@@ -2958,7 +2960,7 @@ unreg_device:
         device_unregister(&udc->gadget.dev);
 put_transceiver:
         if (udc->transceiver)
-                otg_put_transceiver(udc->transceiver);
+                usb_put_transceiver(udc->transceiver);
 free_udc:
         kfree(udc);
         _udc = NULL;
@@ -2981,8 +2983,8 @@ static void udc_remove(void)
         usb_del_gadget_udc(&udc->gadget);
 
         if (udc->transceiver) {
-                otg_set_peripheral(udc->transceiver, &udc->gadget);
-                otg_put_transceiver(udc->transceiver);
+                otg_set_peripheral(udc->transceiver->otg, &udc->gadget);
+                usb_put_transceiver(udc->transceiver);
         }
 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
         dbg_remove_files(&udc->gadget.dev);
diff --git a/drivers/usb/gadget/ci13xxx_udc.h b/drivers/usb/gadget/ci13xxx_udc.h
index f4871e1fac59..0d31af56c989 100644
--- a/drivers/usb/gadget/ci13xxx_udc.h
+++ b/drivers/usb/gadget/ci13xxx_udc.h
@@ -136,7 +136,7 @@ struct ci13xxx {
         struct usb_gadget_driver  *driver;     /* 3rd party gadget driver */
         struct ci13xxx_udc_driver *udc_driver; /* device controller driver */
         int                        vbus_active; /* is VBUS active */
-        struct otg_transceiver    *transceiver; /* Transceiver struct */
+        struct usb_phy            *transceiver; /* Transceiver struct */
 };
 
 /******************************************************************************
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index db815c2da7ed..a6dfd2164166 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -39,27 +39,26 @@
 #include <linux/usb.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/hcd.h>
+#include <linux/scatterlist.h>
 
 #include <asm/byteorder.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <asm/irq.h>
-#include <asm/system.h>
 #include <asm/unaligned.h>
 
-
 #define DRIVER_DESC     "USB Host+Gadget Emulator"
 #define DRIVER_VERSION  "02 May 2005"
 
 #define POWER_BUDGET    500     /* in mA; use 8 for low-power port testing */
 
-static const char       driver_name [] = "dummy_hcd";
-static const char       driver_desc [] = "USB Host+Gadget Emulator";
+static const char       driver_name[] = "dummy_hcd";
+static const char       driver_desc[] = "USB Host+Gadget Emulator";
 
-static const char       gadget_name [] = "dummy_udc";
+static const char       gadget_name[] = "dummy_udc";
 
-MODULE_DESCRIPTION (DRIVER_DESC);
-MODULE_AUTHOR ("David Brownell");
-MODULE_LICENSE ("GPL");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("David Brownell");
+MODULE_LICENSE("GPL");
 
 struct dummy_hcd_module_parameters {
         bool is_super_speed;
@@ -83,10 +82,11 @@ struct dummy_ep {
         struct usb_gadget               *gadget;
         const struct usb_endpoint_descriptor *desc;
         struct usb_ep                   ep;
-        unsigned                        halted : 1;
-        unsigned                        wedged : 1;
-        unsigned                        already_seen : 1;
-        unsigned                        setup_stage : 1;
+        unsigned                        halted:1;
+        unsigned                        wedged:1;
+        unsigned                        already_seen:1;
+        unsigned                        setup_stage:1;
+        unsigned                        stream_en:1;
 };
 
 struct dummy_request {
@@ -94,15 +94,15 @@ struct dummy_request {
         struct usb_request              req;
 };
 
-static inline struct dummy_ep *usb_ep_to_dummy_ep (struct usb_ep *_ep)
+static inline struct dummy_ep *usb_ep_to_dummy_ep(struct usb_ep *_ep)
 {
-        return container_of (_ep, struct dummy_ep, ep);
+        return container_of(_ep, struct dummy_ep, ep);
 }
 
 static inline struct dummy_request *usb_request_to_dummy_request
                 (struct usb_request *_req)
 {
-        return container_of (_req, struct dummy_request, req);
+        return container_of(_req, struct dummy_request, req);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -121,9 +121,9 @@ static inline struct dummy_request *usb_request_to_dummy_request
  * configurations, illegal or unsupported packet lengths, and so on.
  */
 
-static const char ep0name [] = "ep0";
+static const char ep0name[] = "ep0";
 
-static const char *const ep_name [] = {
+static const char *const ep_name[] = {
         ep0name,                                /* everyone has ep0 */
 
         /* act like a net2280: high speed, six configurable endpoints */
@@ -147,6 +147,8 @@ static const char *const ep_name [] = {
 struct urbp {
         struct urb              *urb;
         struct list_head        urbp_list;
+        struct sg_mapping_iter  miter;
+        u32                     miter_started;
 };
 
 
@@ -166,6 +168,8 @@ struct dummy_hcd {
 
         struct usb_device               *udev;
         struct list_head                urbp_list;
+        u32                             stream_en_ep;
+        u8                              num_stream[30 / 2];
 
         unsigned                        active:1;
         unsigned                        old_active:1;
@@ -178,12 +182,12 @@ struct dummy {
         /*
          * SLAVE/GADGET side support
          */
-        struct dummy_ep                 ep [DUMMY_ENDPOINTS];
+        struct dummy_ep                 ep[DUMMY_ENDPOINTS];
         int                             address;
         struct usb_gadget               gadget;
         struct usb_gadget_driver        *driver;
         struct dummy_request            fifo_req;
-        u8                              fifo_buf [FIFO_SIZE];
+        u8                              fifo_buf[FIFO_SIZE];
         u16                             devstatus;
         unsigned                        udc_suspended:1;
         unsigned                        pullup:1;
@@ -210,14 +214,14 @@ static inline struct device *dummy_dev(struct dummy_hcd *dum)
         return dummy_hcd_to_hcd(dum)->self.controller;
 }
 
-static inline struct device *udc_dev (struct dummy *dum)
+static inline struct device *udc_dev(struct dummy *dum)
 {
         return dum->gadget.dev.parent;
 }
 
-static inline struct dummy *ep_to_dummy (struct dummy_ep *ep)
+static inline struct dummy *ep_to_dummy(struct dummy_ep *ep)
 {
-        return container_of (ep->gadget, struct dummy, gadget);
+        return container_of(ep->gadget, struct dummy, gadget);
 }
 
 static inline struct dummy_hcd *gadget_to_dummy_hcd(struct usb_gadget *gadget)
@@ -229,9 +233,9 @@ static inline struct dummy_hcd *gadget_to_dummy_hcd(struct usb_gadget *gadget)
                 return dum->hs_hcd;
 }
 
-static inline struct dummy *gadget_dev_to_dummy (struct device *dev)
+static inline struct dummy *gadget_dev_to_dummy(struct device *dev)
 {
-        return container_of (dev, struct dummy, gadget.dev);
+        return container_of(dev, struct dummy, gadget.dev);
 }
 
 static struct dummy                     the_controller;
@@ -241,24 +245,23 @@ static struct dummy			the_controller;
 /* SLAVE/GADGET SIDE UTILITY ROUTINES */
 
 /* called with spinlock held */
-static void nuke (struct dummy *dum, struct dummy_ep *ep)
+static void nuke(struct dummy *dum, struct dummy_ep *ep)
 {
-        while (!list_empty (&ep->queue)) {
+        while (!list_empty(&ep->queue)) {
                 struct dummy_request    *req;
 
-                req = list_entry (ep->queue.next, struct dummy_request, queue);
-                list_del_init (&req->queue);
+                req = list_entry(ep->queue.next, struct dummy_request, queue);
+                list_del_init(&req->queue);
                 req->req.status = -ESHUTDOWN;
 
-                spin_unlock (&dum->lock);
-                req->req.complete (&ep->ep, &req->req);
-                spin_lock (&dum->lock);
+                spin_unlock(&dum->lock);
+                req->req.complete(&ep->ep, &req->req);
+                spin_lock(&dum->lock);
         }
 }
 
 /* caller must hold lock */
-static void
-stop_activity (struct dummy *dum)
+static void stop_activity(struct dummy *dum)
 {
         struct dummy_ep *ep;
 
@@ -268,8 +271,8 @@ stop_activity (struct dummy *dum)
         /* The timer is left running so that outstanding URBs can fail */
 
         /* nuke any pending requests first, so driver i/o is quiesced */
-        list_for_each_entry (ep, &dum->gadget.ep_list, ep.ep_list)
-                nuke (dum, ep);
+        list_for_each_entry(ep, &dum->gadget.ep_list, ep.ep_list)
+                nuke(dum, ep);
 
         /* driver now does any non-usb quiescing necessary */
 }
@@ -404,8 +407,8 @@ static void set_link_state(struct dummy_hcd *dum_hcd)
 #define is_enabled(dum) \
         (dum->port_status & USB_PORT_STAT_ENABLE)
 
-static int
-dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
+static int dummy_enable(struct usb_ep *_ep,
+                const struct usb_endpoint_descriptor *desc)
 {
         struct dummy            *dum;
         struct dummy_hcd        *dum_hcd;
@@ -413,11 +416,11 @@ dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
         unsigned                max;
         int                     retval;
 
-        ep = usb_ep_to_dummy_ep (_ep);
+        ep = usb_ep_to_dummy_ep(_ep);
         if (!_ep || !desc || ep->desc || _ep->name == ep0name
                         || desc->bDescriptorType != USB_DT_ENDPOINT)
                 return -EINVAL;
-        dum = ep_to_dummy (ep);
+        dum = ep_to_dummy(ep);
         if (!dum->driver)
                 return -ESHUTDOWN;
 
@@ -441,10 +444,10 @@ dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
          * especially for "ep9out" style fixed function ones.)
          */
         retval = -EINVAL;
-        switch (desc->bmAttributes & 0x03) {
+        switch (usb_endpoint_type(desc)) {
         case USB_ENDPOINT_XFER_BULK:
-                if (strstr (ep->ep.name, "-iso")
-                                || strstr (ep->ep.name, "-int")) {
+                if (strstr(ep->ep.name, "-iso")
+                                || strstr(ep->ep.name, "-int")) {
                         goto done;
                 }
                 switch (dum->gadget.speed) {
@@ -466,7 +469,7 @@ dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
                 }
                 break;
         case USB_ENDPOINT_XFER_INT:
-                if (strstr (ep->ep.name, "-iso")) /* bulk is ok */
+                if (strstr(ep->ep.name, "-iso")) /* bulk is ok */
                         goto done;
                 /* real hardware might not handle all packet sizes */
                 switch (dum->gadget.speed) {
@@ -486,8 +489,8 @@ dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
                 }
                 break;
         case USB_ENDPOINT_XFER_ISOC:
-                if (strstr (ep->ep.name, "-bulk")
-                                || strstr (ep->ep.name, "-int"))
+                if (strstr(ep->ep.name, "-bulk")
+                                || strstr(ep->ep.name, "-int"))
                         goto done;
                 /* real hardware might not handle all packet sizes */
                 switch (dum->gadget.speed) {
@@ -510,14 +513,22 @@ dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
         }
 
         _ep->maxpacket = max;
+        if (usb_ss_max_streams(_ep->comp_desc)) {
+                if (!usb_endpoint_xfer_bulk(desc)) {
+                        dev_err(udc_dev(dum), "Can't enable stream support on "
+                                        "non-bulk ep %s\n", _ep->name);
+                        return -EINVAL;
+                }
+                ep->stream_en = 1;
+        }
         ep->desc = desc;
 
-        dev_dbg (udc_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d\n",
+        dev_dbg(udc_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d stream %s\n",
                 _ep->name,
                 desc->bEndpointAddress & 0x0f,
                 (desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
                 ({ char *val;
-                 switch (desc->bmAttributes & 0x03) {
+                 switch (usb_endpoint_type(desc)) {
                  case USB_ENDPOINT_XFER_BULK:
                          val = "bulk";
                          break;
@@ -531,7 +542,7 @@ dummy_enable (struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
                          val = "ctrl";
                          break;
                  }; val; }),
-                max);
+                max, ep->stream_en ? "enabled" : "disabled");
 
         /* at this point real hardware should be NAKing transfers
          * to that endpoint, until a buffer is queued to it.
@@ -542,67 +553,67 @@ done:
         return retval;
 }
 
-static int dummy_disable (struct usb_ep *_ep)
+static int dummy_disable(struct usb_ep *_ep)
 {
         struct dummy_ep         *ep;
         struct dummy            *dum;
         unsigned long           flags;
         int                     retval;
 
-        ep = usb_ep_to_dummy_ep (_ep);
+        ep = usb_ep_to_dummy_ep(_ep);
         if (!_ep || !ep->desc || _ep->name == ep0name)
                 return -EINVAL;
-        dum = ep_to_dummy (ep);
+        dum = ep_to_dummy(ep);
 
-        spin_lock_irqsave (&dum->lock, flags);
+        spin_lock_irqsave(&dum->lock, flags);
         ep->desc = NULL;
+        ep->stream_en = 0;
         retval = 0;
-        nuke (dum, ep);
-        spin_unlock_irqrestore (&dum->lock, flags);
+        nuke(dum, ep);
+        spin_unlock_irqrestore(&dum->lock, flags);
 
-        dev_dbg (udc_dev(dum), "disabled %s\n", _ep->name);
+        dev_dbg(udc_dev(dum), "disabled %s\n", _ep->name);
         return retval;
 }
 
-static struct usb_request *
-dummy_alloc_request (struct usb_ep *_ep, gfp_t mem_flags)
+static struct usb_request *dummy_alloc_request(struct usb_ep *_ep,
+                gfp_t mem_flags)
 {
         struct dummy_ep         *ep;
         struct dummy_request    *req;
 
         if (!_ep)
                 return NULL;
-        ep = usb_ep_to_dummy_ep (_ep);
+        ep = usb_ep_to_dummy_ep(_ep);
 
         req = kzalloc(sizeof(*req), mem_flags);
         if (!req)
                 return NULL;
-        INIT_LIST_HEAD (&req->queue);
+        INIT_LIST_HEAD(&req->queue);
         return &req->req;
 }
 
-static void
-dummy_free_request (struct usb_ep *_ep, struct usb_request *_req)
+static void dummy_free_request(struct usb_ep *_ep, struct usb_request *_req)
 {
         struct dummy_ep         *ep;
         struct dummy_request    *req;
 
-        ep = usb_ep_to_dummy_ep (_ep);
-        if (!ep || !_req || (!ep->desc && _ep->name != ep0name))
+        if (!_ep || !_req)
+                return;
+        ep = usb_ep_to_dummy_ep(_ep);
+        if (!ep->desc && _ep->name != ep0name)
                 return;
 
-        req = usb_request_to_dummy_request (_req);
-        WARN_ON (!list_empty (&req->queue));
-        kfree (req);
+        req = usb_request_to_dummy_request(_req);
+        WARN_ON(!list_empty(&req->queue));
+        kfree(req);
 }
 
-static void
-fifo_complete (struct usb_ep *ep, struct usb_request *req)
+static void fifo_complete(struct usb_ep *ep, struct usb_request *req)
 {
 }
 
-static int
-dummy_queue (struct usb_ep *_ep, struct usb_request *_req,
+static int dummy_queue(struct usb_ep *_ep, struct usb_request *_req,
                 gfp_t mem_flags)
 {
         struct dummy_ep         *ep;
@@ -611,49 +622,48 @@ dummy_queue (struct usb_ep *_ep, struct usb_request *_req,
         struct dummy_hcd        *dum_hcd;
         unsigned long           flags;
 
-        req = usb_request_to_dummy_request (_req);
-        if (!_req || !list_empty (&req->queue) || !_req->complete)
+        req = usb_request_to_dummy_request(_req);
+        if (!_req || !list_empty(&req->queue) || !_req->complete)
                 return -EINVAL;
 
-        ep = usb_ep_to_dummy_ep (_ep);
+        ep = usb_ep_to_dummy_ep(_ep);
         if (!_ep || (!ep->desc && _ep->name != ep0name))
                 return -EINVAL;
 
-        dum = ep_to_dummy (ep);
+        dum = ep_to_dummy(ep);
         dum_hcd = gadget_to_dummy_hcd(&dum->gadget);
         if (!dum->driver || !is_enabled(dum_hcd))
                 return -ESHUTDOWN;
 
 #if 0
-        dev_dbg (udc_dev(dum), "ep %p queue req %p to %s, len %d buf %p\n",
+        dev_dbg(udc_dev(dum), "ep %p queue req %p to %s, len %d buf %p\n",
                         ep, _req, _ep->name, _req->length, _req->buf);
 #endif
-
         _req->status = -EINPROGRESS;
         _req->actual = 0;
-        spin_lock_irqsave (&dum->lock, flags);
+        spin_lock_irqsave(&dum->lock, flags);
 
         /* implement an emulated single-request FIFO */
         if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
-                        list_empty (&dum->fifo_req.queue) &&
-                        list_empty (&ep->queue) &&
+                        list_empty(&dum->fifo_req.queue) &&
+                        list_empty(&ep->queue) &&
                         _req->length <= FIFO_SIZE) {
                 req = &dum->fifo_req;
                 req->req = *_req;
                 req->req.buf = dum->fifo_buf;
-                memcpy (dum->fifo_buf, _req->buf, _req->length);
+                memcpy(dum->fifo_buf, _req->buf, _req->length);
                 req->req.context = dum;
                 req->req.complete = fifo_complete;
 
                 list_add_tail(&req->queue, &ep->queue);
-                spin_unlock (&dum->lock);
+                spin_unlock(&dum->lock);
                 _req->actual = _req->length;
                 _req->status = 0;
-                _req->complete (_ep, _req);
-                spin_lock (&dum->lock);
+                _req->complete(_ep, _req);
+                spin_lock(&dum->lock);
         }  else
                 list_add_tail(&req->queue, &ep->queue);
-        spin_unlock_irqrestore (&dum->lock, flags);
+        spin_unlock_irqrestore(&dum->lock, flags);
 
         /* real hardware would likely enable transfers here, in case
          * it'd been left NAKing.
@@ -661,7 +671,7 @@ dummy_queue (struct usb_ep *_ep, struct usb_request *_req,
         return 0;
 }
 
-static int dummy_dequeue (struct usb_ep *_ep, struct usb_request *_req)
+static int dummy_dequeue(struct usb_ep *_ep, struct usb_request *_req)
 {
         struct dummy_ep         *ep;
         struct dummy            *dum;
@@ -671,31 +681,31 @@ static int dummy_dequeue (struct usb_ep *_ep, struct usb_request *_req)
 
         if (!_ep || !_req)
                 return retval;
-        ep = usb_ep_to_dummy_ep (_ep);
-        dum = ep_to_dummy (ep);
+        ep = usb_ep_to_dummy_ep(_ep);
+        dum = ep_to_dummy(ep);
 
         if (!dum->driver)
                 return -ESHUTDOWN;
 
-        local_irq_save (flags);
-        spin_lock (&dum->lock);
-        list_for_each_entry (req, &ep->queue, queue) {
+        local_irq_save(flags);
+        spin_lock(&dum->lock);
+        list_for_each_entry(req, &ep->queue, queue) {
                 if (&req->req == _req) {
-                        list_del_init (&req->queue);
+                        list_del_init(&req->queue);
                         _req->status = -ECONNRESET;
                         retval = 0;
                         break;
                 }
         }
-        spin_unlock (&dum->lock);
+        spin_unlock(&dum->lock);
 
         if (retval == 0) {
-                dev_dbg (udc_dev(dum),
+                dev_dbg(udc_dev(dum),
                                 "dequeued req %p from %s, len %d buf %p\n",
                                 req, _ep->name, _req->length, _req->buf);
-                _req->complete (_ep, _req);
+                _req->complete(_ep, _req);
         }
-        local_irq_restore (flags);
+        local_irq_restore(flags);
         return retval;
 }
 
@@ -707,14 +717,14 @@ dummy_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged)
 
         if (!_ep)
                 return -EINVAL;
-        ep = usb_ep_to_dummy_ep (_ep);
-        dum = ep_to_dummy (ep);
+        ep = usb_ep_to_dummy_ep(_ep);
+        dum = ep_to_dummy(ep);
         if (!dum->driver)
                 return -ESHUTDOWN;
         if (!value)
                 ep->halted = ep->wedged = 0;
         else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
-                        !list_empty (&ep->queue))
+                        !list_empty(&ep->queue))
                 return -EAGAIN;
         else {
                 ep->halted = 1;
@@ -755,15 +765,15 @@ static const struct usb_ep_ops dummy_ep_ops = {
 /*-------------------------------------------------------------------------*/
 
 /* there are both host and device side versions of this call ... */
-static int dummy_g_get_frame (struct usb_gadget *_gadget)
+static int dummy_g_get_frame(struct usb_gadget *_gadget)
 {
         struct timeval  tv;
 
-        do_gettimeofday (&tv);
+        do_gettimeofday(&tv);
         return tv.tv_usec / 1000;
 }
 
-static int dummy_wakeup (struct usb_gadget *_gadget)
+static int dummy_wakeup(struct usb_gadget *_gadget)
 {
         struct dummy_hcd *dum_hcd;
 
@@ -786,11 +796,11 @@ static int dummy_wakeup (struct usb_gadget *_gadget)
         return 0;
 }
 
-static int dummy_set_selfpowered (struct usb_gadget *_gadget, int value)
+static int dummy_set_selfpowered(struct usb_gadget *_gadget, int value)
 {
         struct dummy    *dum;
 
-        dum = (gadget_to_dummy_hcd(_gadget))->dum;
+        dum = gadget_to_dummy_hcd(_gadget)->dum;
         if (value)
                 dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
         else
@@ -798,22 +808,15 @@ static int dummy_set_selfpowered (struct usb_gadget *_gadget, int value)
         return 0;
 }
 
-static void dummy_udc_udpate_ep0(struct dummy *dum)
+static void dummy_udc_update_ep0(struct dummy *dum)
 {
-        u32 i;
-
-        if (dum->gadget.speed == USB_SPEED_SUPER) {
-                for (i = 0; i < DUMMY_ENDPOINTS; i++)
-                        dum->ep[i].ep.max_streams = 0x10;
+        if (dum->gadget.speed == USB_SPEED_SUPER)
                 dum->ep[0].ep.maxpacket = 9;
-        } else {
-                for (i = 0; i < DUMMY_ENDPOINTS; i++)
-                        dum->ep[i].ep.max_streams = 0;
+        else
                 dum->ep[0].ep.maxpacket = 64;
-        }
 }
 
-static int dummy_pullup (struct usb_gadget *_gadget, int value)
+static int dummy_pullup(struct usb_gadget *_gadget, int value)
 {
         struct dummy_hcd *dum_hcd;
         struct dummy    *dum;
@@ -829,7 +832,7 @@ static int dummy_pullup (struct usb_gadget *_gadget, int value)
                                         dum->driver->max_speed);
                 else
                         dum->gadget.speed = USB_SPEED_FULL;
-                dummy_udc_udpate_ep0(dum);
+                dummy_udc_update_ep0(dum);
 
                 if (dum->gadget.speed < dum->driver->max_speed)
                         dev_dbg(udc_dev(dum), "This device can perform faster"
@@ -838,10 +841,10 @@ static int dummy_pullup (struct usb_gadget *_gadget, int value)
         }
         dum_hcd = gadget_to_dummy_hcd(_gadget);
 
-        spin_lock_irqsave (&dum->lock, flags);
+        spin_lock_irqsave(&dum->lock, flags);
         dum->pullup = (value != 0);
         set_link_state(dum_hcd);
-        spin_unlock_irqrestore (&dum->lock, flags);
+        spin_unlock_irqrestore(&dum->lock, flags);
 
         usb_hcd_poll_rh_status(dummy_hcd_to_hcd(dum_hcd));
         return 0;
@@ -864,16 +867,16 @@ static const struct usb_gadget_ops dummy_ops = {
 /*-------------------------------------------------------------------------*/
 
 /* "function" sysfs attribute */
-static ssize_t
-show_function (struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_function(struct device *dev, struct device_attribute *attr,
+                char *buf)
 {
-        struct dummy    *dum = gadget_dev_to_dummy (dev);
+        struct dummy    *dum = gadget_dev_to_dummy(dev);
 
         if (!dum->driver || !dum->driver->function)
                 return 0;
-        return scnprintf (buf, PAGE_SIZE, "%s\n", dum->driver->function);
+        return scnprintf(buf, PAGE_SIZE, "%s\n", dum->driver->function);
 }
-static DEVICE_ATTR (function, S_IRUGO, show_function, NULL);
+static DEVICE_ATTR(function, S_IRUGO, show_function, NULL);
 
 /*-------------------------------------------------------------------------*/
 
@@ -908,7 +911,7 @@ static int dummy_udc_start(struct usb_gadget *g,
         dum->devstatus = 0;
 
         dum->driver = driver;
-        dev_dbg (udc_dev(dum), "binding gadget driver '%s'\n",
+        dev_dbg(udc_dev(dum), "binding gadget driver '%s'\n",
                         driver->driver.name);
         return 0;
 }
@@ -919,7 +922,7 @@ static int dummy_udc_stop(struct usb_gadget *g,
         struct dummy_hcd        *dum_hcd = gadget_to_dummy_hcd(g);
         struct dummy            *dum = dum_hcd->dum;
 
-        dev_dbg (udc_dev(dum), "unregister gadget driver '%s'\n",
+        dev_dbg(udc_dev(dum), "unregister gadget driver '%s'\n",
                         driver->driver.name);
 
         dum->driver = NULL;
@@ -932,8 +935,7 @@ static int dummy_udc_stop(struct usb_gadget *g,
 
 /* The gadget structure is stored inside the hcd structure and will be
  * released along with it. */
-static void
-dummy_gadget_release (struct device *dev)
+static void dummy_gadget_release(struct device *dev)
 {
         return;
 }
@@ -954,6 +956,7 @@ static void init_dummy_udc_hw(struct dummy *dum)
                 ep->halted = ep->wedged = ep->already_seen =
                                 ep->setup_stage = 0;
                 ep->ep.maxpacket = ~0;
+                ep->ep.max_streams = 16;
                 ep->last_io = jiffies;
                 ep->gadget = &dum->gadget;
                 ep->desc = NULL;
@@ -969,7 +972,7 @@ static void init_dummy_udc_hw(struct dummy *dum)
 #endif
 }
 
-static int dummy_udc_probe (struct platform_device *pdev)
+static int dummy_udc_probe(struct platform_device *pdev)
 {
         struct dummy    *dum = &the_controller;
         int             rc;
@@ -981,7 +984,7 @@ static int dummy_udc_probe (struct platform_device *pdev)
         dev_set_name(&dum->gadget.dev, "gadget");
         dum->gadget.dev.parent = &pdev->dev;
         dum->gadget.dev.release = dummy_gadget_release;
-        rc = device_register (&dum->gadget.dev);
+        rc = device_register(&dum->gadget.dev);
         if (rc < 0) {
                 put_device(&dum->gadget.dev);
                 return rc;
@@ -993,7 +996,7 @@ static int dummy_udc_probe (struct platform_device *pdev)
         if (rc < 0)
                 goto err_udc;
 
-        rc = device_create_file (&dum->gadget.dev, &dev_attr_function);
+        rc = device_create_file(&dum->gadget.dev, &dev_attr_function);
         if (rc < 0)
                 goto err_dev;
         platform_set_drvdata(pdev, dum);
@@ -1006,14 +1009,14 @@ err_udc:
         return rc;
 }
 
-static int dummy_udc_remove (struct platform_device *pdev)
+static int dummy_udc_remove(struct platform_device *pdev)
 {
-        struct dummy    *dum = platform_get_drvdata (pdev);
+        struct dummy    *dum = platform_get_drvdata(pdev);
 
         usb_del_gadget_udc(&dum->gadget);
-        platform_set_drvdata (pdev, NULL);
-        device_remove_file (&dum->gadget.dev, &dev_attr_function);
-        device_unregister (&dum->gadget.dev);
+        platform_set_drvdata(pdev, NULL);
+        device_remove_file(&dum->gadget.dev, &dev_attr_function);
+        device_unregister(&dum->gadget.dev);
         return 0;
 }
 
@@ -1061,6 +1064,16 @@ static struct platform_driver dummy_udc_driver = {
 
 /*-------------------------------------------------------------------------*/
 
+static unsigned int dummy_get_ep_idx(const struct usb_endpoint_descriptor *desc)
+{
+        unsigned int index;
+
+        index = usb_endpoint_num(desc) << 1;
+        if (usb_endpoint_dir_in(desc))
+                index |= 1;
+        return index;
+}
+
 /* MASTER/HOST SIDE DRIVER
  *
  * this uses the hcd framework to hook up to host side drivers.
@@ -1073,7 +1086,82 @@ static struct platform_driver dummy_udc_driver = {
  * usb 2.0 rules.
  */
 
-static int dummy_urb_enqueue (
+static int dummy_ep_stream_en(struct dummy_hcd *dum_hcd, struct urb *urb)
+{
+        const struct usb_endpoint_descriptor *desc = &urb->ep->desc;
+        u32 index;
+
+        if (!usb_endpoint_xfer_bulk(desc))
+                return 0;
+
+        index = dummy_get_ep_idx(desc);
+        return (1 << index) & dum_hcd->stream_en_ep;
+}
+
+/*
+ * The max stream number is saved as a nibble so for the 30 possible endpoints
+ * we only 15 bytes of memory. Therefore we are limited to max 16 streams (0
+ * means we use only 1 stream). The maximum according to the spec is 16bit so
+ * if the 16 stream limit is about to go, the array size should be incremented
+ * to 30 elements of type u16.
+ */
+static int get_max_streams_for_pipe(struct dummy_hcd *dum_hcd,
+                unsigned int pipe)
+{
+        int max_streams;
+
+        max_streams = dum_hcd->num_stream[usb_pipeendpoint(pipe)];
+        if (usb_pipeout(pipe))
+                max_streams >>= 4;
+        else
+                max_streams &= 0xf;
+        max_streams++;
+        return max_streams;
+}
+
+static void set_max_streams_for_pipe(struct dummy_hcd *dum_hcd,
+                unsigned int pipe, unsigned int streams)
+{
+        int max_streams;
+
+        streams--;
+        max_streams = dum_hcd->num_stream[usb_pipeendpoint(pipe)];
+        if (usb_pipeout(pipe)) {
+                streams <<= 4;
+                max_streams &= 0xf;
+        } else {
+                max_streams &= 0xf0;
+        }
+        max_streams |= streams;
+        dum_hcd->num_stream[usb_pipeendpoint(pipe)] = max_streams;
+}
+
+static int dummy_validate_stream(struct dummy_hcd *dum_hcd, struct urb *urb)
+{
+        unsigned int max_streams;
+        int enabled;
+
+        enabled = dummy_ep_stream_en(dum_hcd, urb);
+        if (!urb->stream_id) {
+                if (enabled)
+                        return -EINVAL;
+                return 0;
+        }
+        if (!enabled)
+                return -EINVAL;
+
+        max_streams = get_max_streams_for_pipe(dum_hcd,
+                        usb_pipeendpoint(urb->pipe));
+        if (urb->stream_id > max_streams) {
+                dev_err(dummy_dev(dum_hcd), "Stream id %d is out of range.\n",
+                                urb->stream_id);
+                BUG();
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int dummy_urb_enqueue(
         struct usb_hcd                  *hcd,
         struct urb                      *urb,
         gfp_t                           mem_flags
@@ -1083,16 +1171,21 @@ static int dummy_urb_enqueue (
         unsigned long   flags;
         int             rc;
 
-        if (!urb->transfer_buffer && urb->transfer_buffer_length)
-                return -EINVAL;
-
-        urbp = kmalloc (sizeof *urbp, mem_flags);
+        urbp = kmalloc(sizeof *urbp, mem_flags);
         if (!urbp)
                 return -ENOMEM;
         urbp->urb = urb;
+        urbp->miter_started = 0;
 
         dum_hcd = hcd_to_dummy_hcd(hcd);
         spin_lock_irqsave(&dum_hcd->dum->lock, flags);
+
+        rc = dummy_validate_stream(dum_hcd, urb);
+        if (rc) {
+                kfree(urbp);
+                goto done;
+        }
+
         rc = usb_hcd_link_urb_to_ep(hcd, urb);
         if (rc) {
                 kfree(urbp);
@@ -1107,7 +1200,7 @@ static int dummy_urb_enqueue (
 
         list_add_tail(&urbp->urbp_list, &dum_hcd->urbp_list);
         urb->hcpriv = urbp;
-        if (usb_pipetype (urb->pipe) == PIPE_CONTROL)
+        if (usb_pipetype(urb->pipe) == PIPE_CONTROL)
                 urb->error_count = 1;           /* mark as a new urb */
 
         /* kick the scheduler, it'll do the rest */
@@ -1139,20 +1232,91 @@ static int dummy_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         return rc;
 }
 
+static int dummy_perform_transfer(struct urb *urb, struct dummy_request *req,
+                u32 len)
+{
+        void *ubuf, *rbuf;
+        struct urbp *urbp = urb->hcpriv;
+        int to_host;
+        struct sg_mapping_iter *miter = &urbp->miter;
+        u32 trans = 0;
+        u32 this_sg;
+        bool next_sg;
+
+        to_host = usb_pipein(urb->pipe);
+        rbuf = req->req.buf + req->req.actual;
+
+        if (!urb->num_sgs) {
+                ubuf = urb->transfer_buffer + urb->actual_length;
+                if (to_host)
+                        memcpy(ubuf, rbuf, len);
+                else
+                        memcpy(rbuf, ubuf, len);
+                return len;
+        }
+
+        if (!urbp->miter_started) {
+                u32 flags = SG_MITER_ATOMIC;
+
+                if (to_host)
+                        flags |= SG_MITER_TO_SG;
+                else
+                        flags |= SG_MITER_FROM_SG;
+
+                sg_miter_start(miter, urb->sg, urb->num_sgs, flags);
+                urbp->miter_started = 1;
+        }
+        next_sg = sg_miter_next(miter);
+        if (next_sg == false) {
+                WARN_ON_ONCE(1);
+                return -EINVAL;
+        }
+        do {
+                ubuf = miter->addr;
+                this_sg = min_t(u32, len, miter->length);
+                miter->consumed = this_sg;
+                trans += this_sg;
+
+                if (to_host)
+                        memcpy(ubuf, rbuf, this_sg);
+                else
+                        memcpy(rbuf, ubuf, this_sg);
+                len -= this_sg;
+
+                if (!len)
+                        break;
+                next_sg = sg_miter_next(miter);
+                if (next_sg == false) {
+                        WARN_ON_ONCE(1);
+                        return -EINVAL;
+                }
+
+                rbuf += this_sg;
+        } while (1);
+
+        sg_miter_stop(miter);
+        return trans;
+}
+
 /* transfer up to a frame's worth; caller must own lock */
-static int
-transfer(struct dummy *dum, struct urb *urb, struct dummy_ep *ep, int limit,
-                int *status)
+static int transfer(struct dummy_hcd *dum_hcd, struct urb *urb,
+                struct dummy_ep *ep, int limit, int *status)
 {
+        struct dummy            *dum = dum_hcd->dum;
         struct dummy_request    *req;
 
 top:
         /* if there's no request queued, the device is NAKing; return */
-        list_for_each_entry (req, &ep->queue, queue) {
+        list_for_each_entry(req, &ep->queue, queue) {
                 unsigned        host_len, dev_len, len;
                 int             is_short, to_host;
                 int             rescan = 0;
 
+                if (dummy_ep_stream_en(dum_hcd, urb)) {
+                        if ((urb->stream_id != req->req.stream_id))
+                                continue;
+                }
+
                 /* 1..N packets of ep->ep.maxpacket each ... the last one
                  * may be short (including zero length).
                  *
@@ -1162,20 +1326,18 @@ top:
                  */
                 host_len = urb->transfer_buffer_length - urb->actual_length;
                 dev_len = req->req.length - req->req.actual;
-                len = min (host_len, dev_len);
+                len = min(host_len, dev_len);
 
                 /* FIXME update emulated data toggle too */
 
-                to_host = usb_pipein (urb->pipe);
-                if (unlikely (len == 0))
+                to_host = usb_pipein(urb->pipe);
+                if (unlikely(len == 0))
                         is_short = 1;
                 else {
-                        char            *ubuf, *rbuf;
-
                         /* not enough bandwidth left? */
                         if (limit < ep->ep.maxpacket && limit < len)
                                 break;
-                        len = min (len, (unsigned) limit);
+                        len = min_t(unsigned, len, limit);
                         if (len == 0)
                                 break;
 
@@ -1186,18 +1348,16 @@ top:
                         }
                         is_short = (len % ep->ep.maxpacket) != 0;
 
-                        /* else transfer packet(s) */
-                        ubuf = urb->transfer_buffer + urb->actual_length;
-                        rbuf = req->req.buf + req->req.actual;
-                        if (to_host)
-                                memcpy (ubuf, rbuf, len);
-                        else
-                                memcpy (rbuf, ubuf, len);
-                        ep->last_io = jiffies;
+                        len = dummy_perform_transfer(urb, req, len);
 
-                        limit -= len;
-                        urb->actual_length += len;
-                        req->req.actual += len;
+                        ep->last_io = jiffies;
+                        if ((int)len < 0) {
+                                req->req.status = len;
+                        } else {
+                                limit -= len;
+                                urb->actual_length += len;
+                                req->req.actual += len;
+                        }
                 }
 
                 /* short packets terminate, maybe with overflow/underflow.
@@ -1238,11 +1398,11 @@ top:
 
                 /* device side completion --> continuable */
                 if (req->req.status != -EINPROGRESS) {
-                        list_del_init (&req->queue);
+                        list_del_init(&req->queue);
 
-                        spin_unlock (&dum->lock);
-                        req->req.complete (&ep->ep, &req->req);
-                        spin_lock (&dum->lock);
+                        spin_unlock(&dum->lock);
+                        req->req.complete(&ep->ep, &req->req);
+                        spin_lock(&dum->lock);
 
                         /* requests might have been unlinked... */
                         rescan = 1;
@@ -1259,7 +1419,7 @@ top:
         return limit;
 }
 
-static int periodic_bytes (struct dummy *dum, struct dummy_ep *ep)
+static int periodic_bytes(struct dummy *dum, struct dummy_ep *ep)
 {
         int     limit = ep->ep.maxpacket;
 
@@ -1273,7 +1433,7 @@ static int periodic_bytes (struct dummy *dum, struct dummy_ep *ep)
                 limit += limit * tmp;
         }
         if (dum->gadget.speed == USB_SPEED_SUPER) {
-                switch (ep->desc->bmAttributes & 0x03) {
+                switch (usb_endpoint_type(ep->desc)) {
                 case USB_ENDPOINT_XFER_ISOC:
                         /* Sec. 4.4.8.2 USB3.0 Spec */
                         limit = 3 * 16 * 1024 * 8;
@@ -1295,7 +1455,7 @@ static int periodic_bytes (struct dummy *dum, struct dummy_ep *ep)
                         USB_PORT_STAT_SUSPEND)) \
                 == (USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE))
 
-static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address)
+static struct dummy_ep *find_endpoint(struct dummy *dum, u8 address)
 {
         int             i;
 
@@ -1303,9 +1463,9 @@ static struct dummy_ep *find_endpoint (struct dummy *dum, u8 address)
                         dum->ss_hcd : dum->hs_hcd)))
                 return NULL;
         if ((address & ~USB_DIR_IN) == 0)
-                return &dum->ep [0];
+                return &dum->ep[0];
         for (i = 1; i < DUMMY_ENDPOINTS; i++) {
-                struct dummy_ep *ep = &dum->ep [i];
+                struct dummy_ep *ep = &dum->ep[i];
 
                 if (!ep->desc)
                         continue;
@@ -1535,19 +1695,19 @@ static void dummy_timer(unsigned long _dum_hcd)
         /* FIXME if HZ != 1000 this will probably misbehave ... */
 
         /* look at each urb queued by the host side driver */
-        spin_lock_irqsave (&dum->lock, flags);
+        spin_lock_irqsave(&dum->lock, flags);
 
         if (!dum_hcd->udev) {
                 dev_err(dummy_dev(dum_hcd),
                                 "timer fired with no URBs pending?\n");
-                spin_unlock_irqrestore (&dum->lock, flags);
+                spin_unlock_irqrestore(&dum->lock, flags);
                 return;
         }
 
         for (i = 0; i < DUMMY_ENDPOINTS; i++) {
-                if (!ep_name [i])
+                if (!ep_name[i])
                         break;
-                dum->ep [i].already_seen = 0;
+                dum->ep[i].already_seen = 0;
         }
 
 restart:
@@ -1564,7 +1724,7 @@ restart:
                         goto return_urb;
                 else if (dum_hcd->rh_state != DUMMY_RH_RUNNING)
                         continue;
-                type = usb_pipetype (urb->pipe);
+                type = usb_pipetype(urb->pipe);
 
                 /* used up this frame's non-periodic bandwidth?
                  * FIXME there's infinite bandwidth for control and
@@ -1575,7 +1735,7 @@ restart:
 
                 /* find the gadget's ep for this request (if configured) */
                 address = usb_pipeendpoint (urb->pipe);
-                if (usb_pipein (urb->pipe))
+                if (usb_pipein(urb->pipe))
                         address |= USB_DIR_IN;
                 ep = find_endpoint(dum, address);
                 if (!ep) {
@@ -1590,7 +1750,7 @@ restart:
                 if (ep->already_seen)
                         continue;
                 ep->already_seen = 1;
-                if (ep == &dum->ep [0] && urb->error_count) {
+                if (ep == &dum->ep[0] && urb->error_count) {
                         ep->setup_stage = 1;    /* a new urb */
                         urb->error_count = 0;
                 }
@@ -1604,21 +1764,21 @@ restart:
                 /* FIXME make sure both ends agree on maxpacket */
 
                 /* handle control requests */
-                if (ep == &dum->ep [0] && ep->setup_stage) {
+                if (ep == &dum->ep[0] && ep->setup_stage) {
                         struct usb_ctrlrequest          setup;
                         int                             value = 1;
 
-                        setup = *(struct usb_ctrlrequest*) urb->setup_packet;
+                        setup = *(struct usb_ctrlrequest *) urb->setup_packet;
                         /* paranoia, in case of stale queued data */
-                        list_for_each_entry (req, &ep->queue, queue) {
-                                list_del_init (&req->queue);
+                        list_for_each_entry(req, &ep->queue, queue) {
+                                list_del_init(&req->queue);
                                 req->req.status = -EOVERFLOW;
-                                dev_dbg (udc_dev(dum), "stale req = %p\n",
+                                dev_dbg(udc_dev(dum), "stale req = %p\n",
                                                 req);
 
-                                spin_unlock (&dum->lock);
-                                req->req.complete (&ep->ep, &req->req);
-                                spin_lock (&dum->lock);
+                                spin_unlock(&dum->lock);
+                                req->req.complete(&ep->ep, &req->req);
+                                spin_lock(&dum->lock);
                                 ep->already_seen = 0;
                                 goto restart;
                         }
@@ -1638,10 +1798,10 @@ restart:
                          * until setup() returns; no reentrancy issues etc.
                          */
                         if (value > 0) {
-                                spin_unlock (&dum->lock);
-                                value = dum->driver->setup (&dum->gadget,
+                                spin_unlock(&dum->lock);
+                                value = dum->driver->setup(&dum->gadget,
                                                 &setup);
-                                spin_lock (&dum->lock);
+                                spin_lock(&dum->lock);
 
                                 if (value >= 0) {
                                         /* no delays (max 64KB data stage) */
@@ -1653,7 +1813,7 @@ restart:
 
                         if (value < 0) {
                                 if (value != -EOPNOTSUPP)
-                                        dev_dbg (udc_dev(dum),
+                                        dev_dbg(udc_dev(dum),
                                                 "setup --> %d\n",
                                                 value);
                                 status = -EPIPE;
@@ -1665,14 +1825,14 @@ restart:
 
                 /* non-control requests */
                 limit = total;
-                switch (usb_pipetype (urb->pipe)) {
+                switch (usb_pipetype(urb->pipe)) {
                 case PIPE_ISOCHRONOUS:
                         /* FIXME is it urb->interval since the last xfer?
                          * use urb->iso_frame_desc[i].
                          * complete whether or not ep has requests queued.
                          * report random errors, to debug drivers.
                          */
-                        limit = max (limit, periodic_bytes (dum, ep));
+                        limit = max(limit, periodic_bytes(dum, ep));
                         status = -ENOSYS;
                         break;
 
@@ -1680,14 +1840,13 @@ restart:
                         /* FIXME is it urb->interval since the last xfer?
                          * this almost certainly polls too fast.
                          */
-                        limit = max (limit, periodic_bytes (dum, ep));
+                        limit = max(limit, periodic_bytes(dum, ep));
                         /* FALLTHROUGH */
 
-                // case PIPE_BULK:  case PIPE_CONTROL:
                 default:
-                treat_control_like_bulk:
+treat_control_like_bulk:
                         ep->last_io = jiffies;
-                        total = transfer(dum, urb, ep, limit, &status);
+                        total = transfer(dum_hcd, urb, ep, limit, &status);
                         break;
                 }
 
@@ -1696,15 +1855,15 @@ restart:
                         continue;
 
 return_urb:
-                list_del (&urbp->urbp_list);
-                kfree (urbp);
+                list_del(&urbp->urbp_list);
+                kfree(urbp);
                 if (ep)
                         ep->already_seen = ep->setup_stage = 0;
 
                 usb_hcd_unlink_urb_from_ep(dummy_hcd_to_hcd(dum_hcd), urb);
-                spin_unlock (&dum->lock);
+                spin_unlock(&dum->lock);
                 usb_hcd_giveback_urb(dummy_hcd_to_hcd(dum_hcd), urb, status);
-                spin_lock (&dum->lock);
+                spin_lock(&dum->lock);
 
                 goto restart;
         }
@@ -1717,7 +1876,7 @@ return_urb:
                 mod_timer(&dum_hcd->timer, jiffies + msecs_to_jiffies(1));
         }
 
-        spin_unlock_irqrestore (&dum->lock, flags);
+        spin_unlock_irqrestore(&dum->lock, flags);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -1729,7 +1888,7 @@ return_urb:
         | USB_PORT_STAT_C_OVERCURRENT \
         | USB_PORT_STAT_C_RESET) << 16)
 
-static int dummy_hub_status (struct usb_hcd *hcd, char *buf)
+static int dummy_hub_status(struct usb_hcd *hcd, char *buf)
 {
         struct dummy_hcd        *dum_hcd;
         unsigned long           flags;
@@ -1753,7 +1912,7 @@ static int dummy_hub_status (struct usb_hcd *hcd, char *buf)
                                 dum_hcd->port_status);
                 retval = 1;
                 if (dum_hcd->rh_state == DUMMY_RH_SUSPENDED)
-                        usb_hcd_resume_root_hub (hcd);
+                        usb_hcd_resume_root_hub(hcd);
         }
 done:
         spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
@@ -1772,10 +1931,9 @@ ss_hub_descriptor(struct usb_hub_descriptor *desc)
         desc->u.ss.DeviceRemovable = 0xffff;
 }
 
-static inline void
-hub_descriptor (struct usb_hub_descriptor *desc)
+static inline void hub_descriptor(struct usb_hub_descriptor *desc)
 {
-        memset (desc, 0, sizeof *desc);
+        memset(desc, 0, sizeof *desc);
         desc->bDescriptorType = 0x29;
         desc->bDescLength = 9;
         desc->wHubCharacteristics = cpu_to_le16(0x0001);
@@ -1784,7 +1942,7 @@ hub_descriptor (struct usb_hub_descriptor *desc)
         desc->u.hs.DeviceRemovable[1] = 0xff;
 }
 
-static int dummy_hub_control (
+static int dummy_hub_control(
         struct usb_hcd  *hcd,
         u16             typeReq,
         u16             wValue,
@@ -1852,7 +2010,7 @@ static int dummy_hub_control (
                         hub_descriptor((struct usb_hub_descriptor *) buf);
                 break;
         case GetHubStatus:
-                *(__le32 *) buf = cpu_to_le32 (0);
+                *(__le32 *) buf = cpu_to_le32(0);
                 break;
         case GetPortStatus:
                 if (wIndex != 1)
@@ -1894,8 +2052,8 @@ static int dummy_hub_control (
                         }
                 }
                 set_link_state(dum_hcd);
-                ((__le16 *) buf)[0] = cpu_to_le16 (dum_hcd->port_status);
-                ((__le16 *) buf)[1] = cpu_to_le16 (dum_hcd->port_status >> 16);
+                ((__le16 *) buf)[0] = cpu_to_le16(dum_hcd->port_status);
+                ((__le16 *) buf)[1] = cpu_to_le16(dum_hcd->port_status >> 16);
                 break;
         case SetHubFeature:
                 retval = -EPIPE;
@@ -2029,15 +2187,15 @@ error:
         spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
 
         if ((dum_hcd->port_status & PORT_C_MASK) != 0)
-                usb_hcd_poll_rh_status (hcd);
+                usb_hcd_poll_rh_status(hcd);
         return retval;
 }
 
-static int dummy_bus_suspend (struct usb_hcd *hcd)
+static int dummy_bus_suspend(struct usb_hcd *hcd)
 {
         struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
 
-        dev_dbg (&hcd->self.root_hub->dev, "%s\n", __func__);
+        dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
 
         spin_lock_irq(&dum_hcd->dum->lock);
         dum_hcd->rh_state = DUMMY_RH_SUSPENDED;
@@ -2047,12 +2205,12 @@ static int dummy_bus_suspend (struct usb_hcd *hcd)
         return 0;
 }
 
-static int dummy_bus_resume (struct usb_hcd *hcd)
+static int dummy_bus_resume(struct usb_hcd *hcd)
 {
         struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
         int rc = 0;
 
-        dev_dbg (&hcd->self.root_hub->dev, "%s\n", __func__);
+        dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
 
         spin_lock_irq(&dum_hcd->dum->lock);
         if (!HCD_HW_ACCESSIBLE(hcd)) {
@@ -2070,55 +2228,54 @@ static int dummy_bus_resume (struct usb_hcd *hcd)
 
 /*-------------------------------------------------------------------------*/
 
-static inline ssize_t
-show_urb (char *buf, size_t size, struct urb *urb)
+static inline ssize_t show_urb(char *buf, size_t size, struct urb *urb)
 {
-        int ep = usb_pipeendpoint (urb->pipe);
+        int ep = usb_pipeendpoint(urb->pipe);
 
-        return snprintf (buf, size,
+        return snprintf(buf, size,
                 "urb/%p %s ep%d%s%s len %d/%d\n",
                 urb,
                 ({ char *s;
-                 switch (urb->dev->speed) {
-                 case USB_SPEED_LOW:
+                switch (urb->dev->speed) {
+                case USB_SPEED_LOW:
                         s = "ls";
                         break;
-                 case USB_SPEED_FULL:
+                case USB_SPEED_FULL:
                         s = "fs";
                         break;
-                 case USB_SPEED_HIGH:
+                case USB_SPEED_HIGH:
                         s = "hs";
                         break;
-                 case USB_SPEED_SUPER:
+                case USB_SPEED_SUPER:
                         s = "ss";
                         break;
-                 default:
+                default:
                         s = "?";
                         break;
                  }; s; }),
-                ep, ep ? (usb_pipein (urb->pipe) ? "in" : "out") : "",
+                ep, ep ? (usb_pipein(urb->pipe) ? "in" : "out") : "",
                 ({ char *s; \
-                 switch (usb_pipetype (urb->pipe)) { \
-                 case PIPE_CONTROL: \
+                switch (usb_pipetype(urb->pipe)) { \
+                case PIPE_CONTROL: \
                         s = ""; \
                         break; \
-                 case PIPE_BULK: \
+                case PIPE_BULK: \
                         s = "-bulk"; \
                         break; \
-                 case PIPE_INTERRUPT: \
+                case PIPE_INTERRUPT: \
                         s = "-int"; \
                         break; \
-                 default: \
+                default: \
                         s = "-iso"; \
                         break; \
-                }; s;}),
+                }; s; }),
                 urb->actual_length, urb->transfer_buffer_length);
 }
 
-static ssize_t
-show_urbs (struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_urbs(struct device *dev, struct device_attribute *attr,
+                char *buf)
 {
-        struct usb_hcd          *hcd = dev_get_drvdata (dev);
+        struct usb_hcd          *hcd = dev_get_drvdata(dev);
         struct dummy_hcd        *dum_hcd = hcd_to_dummy_hcd(hcd);
         struct urbp             *urbp;
         size_t                  size = 0;
@@ -2128,7 +2285,7 @@ show_urbs (struct device *dev, struct device_attribute *attr, char *buf)
         list_for_each_entry(urbp, &dum_hcd->urbp_list, urbp_list) {
                 size_t          temp;
 
-                temp = show_urb (buf, PAGE_SIZE - size, urbp->urb);
+                temp = show_urb(buf, PAGE_SIZE - size, urbp->urb);
                 buf += temp;
                 size += temp;
         }
@@ -2136,7 +2293,7 @@ show_urbs (struct device *dev, struct device_attribute *attr, char *buf)
 
         return size;
 }
-static DEVICE_ATTR (urbs, S_IRUGO, show_urbs, NULL);
+static DEVICE_ATTR(urbs, S_IRUGO, show_urbs, NULL);
 
 static int dummy_start_ss(struct dummy_hcd *dum_hcd)
 {
@@ -2144,6 +2301,7 @@ static int dummy_start_ss(struct dummy_hcd *dum_hcd)
         dum_hcd->timer.function = dummy_timer;
         dum_hcd->timer.data = (unsigned long)dum_hcd;
         dum_hcd->rh_state = DUMMY_RH_RUNNING;
+        dum_hcd->stream_en_ep = 0;
         INIT_LIST_HEAD(&dum_hcd->urbp_list);
         dummy_hcd_to_hcd(dum_hcd)->power_budget = POWER_BUDGET;
         dummy_hcd_to_hcd(dum_hcd)->state = HC_STATE_RUNNING;
@@ -2189,11 +2347,11 @@ static int dummy_start(struct usb_hcd *hcd)
         return device_create_file(dummy_dev(dum_hcd), &dev_attr_urbs);
 }
 
-static void dummy_stop (struct usb_hcd *hcd)
+static void dummy_stop(struct usb_hcd *hcd)
 {
         struct dummy            *dum;
 
-        dum = (hcd_to_dummy_hcd(hcd))->dum;
+        dum = hcd_to_dummy_hcd(hcd)->dum;
         device_remove_file(dummy_dev(hcd_to_dummy_hcd(hcd)), &dev_attr_urbs);
         usb_gadget_unregister_driver(dum->driver);
         dev_info(dummy_dev(hcd_to_dummy_hcd(hcd)), "stopped\n");
@@ -2201,13 +2359,14 @@ static void dummy_stop (struct usb_hcd *hcd)
 
 /*-------------------------------------------------------------------------*/
 
-static int dummy_h_get_frame (struct usb_hcd *hcd)
+static int dummy_h_get_frame(struct usb_hcd *hcd)
 {
-        return dummy_g_get_frame (NULL);
+        return dummy_g_get_frame(NULL);
 }
 
 static int dummy_setup(struct usb_hcd *hcd)
 {
+        hcd->self.sg_tablesize = ~0;
         if (usb_hcd_is_primary_hcd(hcd)) {
                 the_controller.hs_hcd = hcd_to_dummy_hcd(hcd);
                 the_controller.hs_hcd->dum = &the_controller;
@@ -2228,27 +2387,82 @@ static int dummy_setup(struct usb_hcd *hcd)
 }
 
 /* Change a group of bulk endpoints to support multiple stream IDs */
-int dummy_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
+static int dummy_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
         struct usb_host_endpoint **eps, unsigned int num_eps,
         unsigned int num_streams, gfp_t mem_flags)
 {
-        if (hcd->speed != HCD_USB3)
-                dev_dbg(dummy_dev(hcd_to_dummy_hcd(hcd)),
-                        "%s() - ERROR! Not supported for USB2.0 roothub\n",
-                        __func__);
-        return 0;
+        struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
+        unsigned long flags;
+        int max_stream;
+        int ret_streams = num_streams;
+        unsigned int index;
+        unsigned int i;
+
+        if (!num_eps)
+                return -EINVAL;
+
+        spin_lock_irqsave(&dum_hcd->dum->lock, flags);
+        for (i = 0; i < num_eps; i++) {
+                index = dummy_get_ep_idx(&eps[i]->desc);
+                if ((1 << index) & dum_hcd->stream_en_ep) {
+                        ret_streams = -EINVAL;
+                        goto out;
+                }
+                max_stream = usb_ss_max_streams(&eps[i]->ss_ep_comp);
+                if (!max_stream) {
+                        ret_streams = -EINVAL;
+                        goto out;
+                }
+                if (max_stream < ret_streams) {
+                        dev_dbg(dummy_dev(dum_hcd), "Ep 0x%x only supports %u "
+                                        "stream IDs.\n",
+                                        eps[i]->desc.bEndpointAddress,
+                                        max_stream);
+                        ret_streams = max_stream;
+                }
+        }
+
+        for (i = 0; i < num_eps; i++) {
+                index = dummy_get_ep_idx(&eps[i]->desc);
+                dum_hcd->stream_en_ep |= 1 << index;
+                set_max_streams_for_pipe(dum_hcd,
+                                usb_endpoint_num(&eps[i]->desc), ret_streams);
+        }
+out:
+        spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
+        return ret_streams;
 }
 
 /* Reverts a group of bulk endpoints back to not using stream IDs. */
-int dummy_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
+static int dummy_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
         struct usb_host_endpoint **eps, unsigned int num_eps,
         gfp_t mem_flags)
 {
-        if (hcd->speed != HCD_USB3)
-                dev_dbg(dummy_dev(hcd_to_dummy_hcd(hcd)),
-                        "%s() - ERROR! Not supported for USB2.0 roothub\n",
-                        __func__);
-        return 0;
+        struct dummy_hcd *dum_hcd = hcd_to_dummy_hcd(hcd);
+        unsigned long flags;
+        int ret;
+        unsigned int index;
+        unsigned int i;
+
+        spin_lock_irqsave(&dum_hcd->dum->lock, flags);
+        for (i = 0; i < num_eps; i++) {
+                index = dummy_get_ep_idx(&eps[i]->desc);
+                if (!((1 << index) & dum_hcd->stream_en_ep)) {
+                        ret = -EINVAL;
+                        goto out;
+                }
+        }
+
+        for (i = 0; i < num_eps; i++) {
+                index = dummy_get_ep_idx(&eps[i]->desc);
+                dum_hcd->stream_en_ep &= ~(1 << index);
+                set_max_streams_for_pipe(dum_hcd,
+                                usb_endpoint_num(&eps[i]->desc), 0);
+        }
+        ret = 0;
+out:
+        spin_unlock_irqrestore(&dum_hcd->dum->lock, flags);
+        return ret;
 }
 
 static struct hc_driver dummy_hcd = {
@@ -2262,13 +2476,13 @@ static struct hc_driver dummy_hcd = {
         .start =                dummy_start,
         .stop =                 dummy_stop,
 
-        .urb_enqueue =          dummy_urb_enqueue,
-        .urb_dequeue =          dummy_urb_dequeue,
+        .urb_enqueue =          dummy_urb_enqueue,
+        .urb_dequeue =          dummy_urb_dequeue,
 
-        .get_frame_number =     dummy_h_get_frame,
+        .get_frame_number =     dummy_h_get_frame,
 
-        .hub_status_data =      dummy_hub_status,
-        .hub_control =          dummy_hub_control,
+        .hub_status_data =      dummy_hub_status,
+        .hub_control =          dummy_hub_control,
         .bus_suspend =          dummy_bus_suspend,
         .bus_resume =           dummy_bus_resume,
 
@@ -2323,7 +2537,7 @@ static int dummy_hcd_remove(struct platform_device *pdev)
 {
         struct dummy            *dum;
 
-        dum = (hcd_to_dummy_hcd(platform_get_drvdata(pdev)))->dum;
+        dum = hcd_to_dummy_hcd(platform_get_drvdata(pdev))->dum;
 
         if (dum->ss_hcd) {
                 usb_remove_hcd(dummy_hcd_to_hcd(dum->ss_hcd));
@@ -2339,15 +2553,15 @@ static int dummy_hcd_remove(struct platform_device *pdev)
         return 0;
 }
 
-static int dummy_hcd_suspend (struct platform_device *pdev, pm_message_t state)
+static int dummy_hcd_suspend(struct platform_device *pdev, pm_message_t state)
 {
         struct usb_hcd          *hcd;
         struct dummy_hcd        *dum_hcd;
         int                     rc = 0;
 
-        dev_dbg (&pdev->dev, "%s\n", __func__);
+        dev_dbg(&pdev->dev, "%s\n", __func__);
 
-        hcd = platform_get_drvdata (pdev);
+        hcd = platform_get_drvdata(pdev);
         dum_hcd = hcd_to_dummy_hcd(hcd);
         if (dum_hcd->rh_state == DUMMY_RH_RUNNING) {
                 dev_warn(&pdev->dev, "Root hub isn't suspended!\n");
@@ -2357,15 +2571,15 @@ static int dummy_hcd_suspend (struct platform_device *pdev, pm_message_t state)
         return rc;
 }
 
-static int dummy_hcd_resume (struct platform_device *pdev)
+static int dummy_hcd_resume(struct platform_device *pdev)
 {
         struct usb_hcd          *hcd;
 
-        dev_dbg (&pdev->dev, "%s\n", __func__);
+        dev_dbg(&pdev->dev, "%s\n", __func__);
 
-        hcd = platform_get_drvdata (pdev);
+        hcd = platform_get_drvdata(pdev);
         set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-        usb_hcd_poll_rh_status (hcd);
+        usb_hcd_poll_rh_status(hcd);
         return 0;
 }
 
@@ -2385,11 +2599,11 @@ static struct platform_driver dummy_hcd_driver = {
 static struct platform_device *the_udc_pdev;
 static struct platform_device *the_hcd_pdev;
 
-static int __init init (void)
+static int __init init(void)
 {
         int     retval = -ENOMEM;
 
-        if (usb_disabled ())
+        if (usb_disabled())
                 return -ENODEV;
 
         if (!mod_data.is_high_speed && mod_data.is_super_speed)
@@ -2448,13 +2662,13 @@ err_alloc_udc:
         platform_device_put(the_hcd_pdev);
         return retval;
 }
-module_init (init);
+module_init(init);
 
-static void __exit cleanup (void)
+static void __exit cleanup(void)
 {
         platform_device_unregister(the_udc_pdev);
         platform_device_unregister(the_hcd_pdev);
         platform_driver_unregister(&dummy_udc_driver);
         platform_driver_unregister(&dummy_hcd_driver);
 }
-module_exit (cleanup);
+module_exit(cleanup);
diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
index e0e6375ef5dd..51f3d42f5a64 100644
--- a/drivers/usb/gadget/epautoconf.c
+++ b/drivers/usb/gadget/epautoconf.c
@@ -275,24 +275,24 @@ struct usb_ep *usb_ep_autoconfig_ss(
                 /* ep-e, ep-f are PIO with only 64 byte fifos */
                 ep = find_ep (gadget, "ep-e");
                 if (ep && ep_matches(gadget, ep, desc, ep_comp))
-                        return ep;
+                        goto found_ep;
                 ep = find_ep (gadget, "ep-f");
                 if (ep && ep_matches(gadget, ep, desc, ep_comp))
-                        return ep;
+                        goto found_ep;
 
         } else if (gadget_is_goku (gadget)) {
                 if (USB_ENDPOINT_XFER_INT == type) {
                         /* single buffering is enough */
                         ep = find_ep(gadget, "ep3-bulk");
                         if (ep && ep_matches(gadget, ep, desc, ep_comp))
-                                return ep;
+                                goto found_ep;
                 } else if (USB_ENDPOINT_XFER_BULK == type
                                 && (USB_DIR_IN & desc->bEndpointAddress)) {
                         /* DMA may be available */
                         ep = find_ep(gadget, "ep2-bulk");
                         if (ep && ep_matches(gadget, ep, desc,
                                               ep_comp))
-                                return ep;
+                                goto found_ep;
                 }
 
 #ifdef CONFIG_BLACKFIN
@@ -311,18 +311,22 @@ struct usb_ep *usb_ep_autoconfig_ss(
                 } else
                         ep = NULL;
                 if (ep && ep_matches(gadget, ep, desc, ep_comp))
-                        return ep;
+                        goto found_ep;
 #endif
         }
 
         /* Second, look at endpoints until an unclaimed one looks usable */
         list_for_each_entry (ep, &gadget->ep_list, ep_list) {
                 if (ep_matches(gadget, ep, desc, ep_comp))
-                        return ep;
+                        goto found_ep;
         }
 
         /* Fail */
         return NULL;
+found_ep:
+        ep->desc = NULL;
+        ep->comp_desc = NULL;
+        return ep;
 }
 
 /**
diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
index 3f8849339ade..d672250a61fa 100644
--- a/drivers/usb/gadget/f_acm.c
+++ b/drivers/usb/gadget/f_acm.c
@@ -5,7 +5,7 @@
  * Copyright (C) 2008 by David Brownell
  * Copyright (C) 2008 by Nokia Corporation
  * Copyright (C) 2009 by Samsung Electronics
- * Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
+ * Author: Michal Nazarewicz (mina86@mina86.com)
  *
  * This software is distributed under the terms of the GNU General
  * Public License ("GPL") as published by the Free Software Foundation,
@@ -237,6 +237,42 @@ static struct usb_descriptor_header *acm_hs_function[] = {
         NULL,
 };
 
+static struct usb_endpoint_descriptor acm_ss_in_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(1024),
+};
+
+static struct usb_endpoint_descriptor acm_ss_out_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(1024),
+};
+
+static struct usb_ss_ep_comp_descriptor acm_ss_bulk_comp_desc = {
+        .bLength =              sizeof acm_ss_bulk_comp_desc,
+        .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
+};
+
+static struct usb_descriptor_header *acm_ss_function[] = {
+        (struct usb_descriptor_header *) &acm_iad_descriptor,
+        (struct usb_descriptor_header *) &acm_control_interface_desc,
+        (struct usb_descriptor_header *) &acm_header_desc,
+        (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
+        (struct usb_descriptor_header *) &acm_descriptor,
+        (struct usb_descriptor_header *) &acm_union_desc,
+        (struct usb_descriptor_header *) &acm_hs_notify_desc,
+        (struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
+        (struct usb_descriptor_header *) &acm_data_interface_desc,
+        (struct usb_descriptor_header *) &acm_ss_in_desc,
+        (struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
+        (struct usb_descriptor_header *) &acm_ss_out_desc,
+        (struct usb_descriptor_header *) &acm_ss_bulk_comp_desc,
+        NULL,
+};
+
 /* string descriptors: */
 
 #define ACM_CTRL_IDX    0
@@ -643,9 +679,21 @@ acm_bind(struct usb_configuration *c, struct usb_function *f)
                 /* copy descriptors */
                 f->hs_descriptors = usb_copy_descriptors(acm_hs_function);
         }
+        if (gadget_is_superspeed(c->cdev->gadget)) {
+                acm_ss_in_desc.bEndpointAddress =
+                        acm_fs_in_desc.bEndpointAddress;
+                acm_ss_out_desc.bEndpointAddress =
+                        acm_fs_out_desc.bEndpointAddress;
+
+                /* copy descriptors, and track endpoint copies */
+                f->ss_descriptors = usb_copy_descriptors(acm_ss_function);
+                if (!f->ss_descriptors)
+                        goto fail;
+        }
 
         DBG(cdev, "acm ttyGS%d: %s speed IN/%s OUT/%s NOTIFY/%s\n",
                         acm->port_num,
+                        gadget_is_superspeed(c->cdev->gadget) ? "super" :
                         gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
                         acm->port.in->name, acm->port.out->name,
                         acm->notify->name);
@@ -675,6 +723,8 @@ acm_unbind(struct usb_configuration *c, struct usb_function *f)
 
         if (gadget_is_dualspeed(c->cdev->gadget))
                 usb_free_descriptors(f->hs_descriptors);
+        if (gadget_is_superspeed(c->cdev->gadget))
+                usb_free_descriptors(f->ss_descriptors);
         usb_free_descriptors(f->descriptors);
         gs_free_req(acm->notify, acm->notify_req);
         kfree(acm);
diff --git a/drivers/usb/gadget/f_ecm.c b/drivers/usb/gadget/f_ecm.c
index 11c07cb7d337..30b908f2a53d 100644
--- a/drivers/usb/gadget/f_ecm.c
+++ b/drivers/usb/gadget/f_ecm.c
@@ -97,6 +97,20 @@ static inline unsigned ecm_bitrate(struct usb_gadget *g)
 
 /* interface descriptor: */
 
+static struct usb_interface_assoc_descriptor
+ecm_iad_descriptor = {
+        .bLength =              sizeof ecm_iad_descriptor,
+        .bDescriptorType =      USB_DT_INTERFACE_ASSOCIATION,
+
+        /* .bFirstInterface =   DYNAMIC, */
+        .bInterfaceCount =      2,      /* control + data */
+        .bFunctionClass =       USB_CLASS_COMM,
+        .bFunctionSubClass =    USB_CDC_SUBCLASS_ETHERNET,
+        .bFunctionProtocol =    USB_CDC_PROTO_NONE,
+        /* .iFunction =         DYNAMIC */
+};
+
+
 static struct usb_interface_descriptor ecm_control_intf = {
         .bLength =              sizeof ecm_control_intf,
         .bDescriptorType =      USB_DT_INTERFACE,
@@ -199,6 +213,7 @@ static struct usb_endpoint_descriptor fs_ecm_out_desc = {
 
 static struct usb_descriptor_header *ecm_fs_function[] = {
         /* CDC ECM control descriptors */
+        (struct usb_descriptor_header *) &ecm_iad_descriptor,
         (struct usb_descriptor_header *) &ecm_control_intf,
         (struct usb_descriptor_header *) &ecm_header_desc,
         (struct usb_descriptor_header *) &ecm_union_desc,
@@ -247,6 +262,7 @@ static struct usb_endpoint_descriptor hs_ecm_out_desc = {
 
 static struct usb_descriptor_header *ecm_hs_function[] = {
         /* CDC ECM control descriptors */
+        (struct usb_descriptor_header *) &ecm_iad_descriptor,
         (struct usb_descriptor_header *) &ecm_control_intf,
         (struct usb_descriptor_header *) &ecm_header_desc,
         (struct usb_descriptor_header *) &ecm_union_desc,
@@ -339,6 +355,7 @@ static struct usb_string ecm_string_defs[] = {
         [0].s = "CDC Ethernet Control Model (ECM)",
         [1].s = NULL /* DYNAMIC */,
         [2].s = "CDC Ethernet Data",
+        [3].s = "CDC ECM",
         {  } /* end of list */
 };
 
@@ -674,6 +691,7 @@ ecm_bind(struct usb_configuration *c, struct usb_function *f)
         if (status < 0)
                 goto fail;
         ecm->ctrl_id = status;
+        ecm_iad_descriptor.bFirstInterface = status;
 
         ecm_control_intf.bInterfaceNumber = status;
         ecm_union_desc.bMasterInterface0 = status;
@@ -864,6 +882,13 @@ ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
                         return status;
                 ecm_string_defs[1].id = status;
                 ecm_desc.iMACAddress = status;
+
+                /* IAD label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ecm_string_defs[3].id = status;
+                ecm_iad_descriptor.iFunction = status;
         }
 
         /* allocate and initialize one new instance */
diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c
index f63dc6c150d2..1cbba70836bc 100644
--- a/drivers/usb/gadget/f_fs.c
+++ b/drivers/usb/gadget/f_fs.c
@@ -2,7 +2,7 @@
  * f_fs.c -- user mode file system API for USB composite function controllers
  *
  * Copyright (C) 2010 Samsung Electronics
- * Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
+ * Author: Michal Nazarewicz <mina86@mina86.com>
  *
  * Based on inode.c (GadgetFS) which was:
  * Copyright (C) 2003-2004 David Brownell
@@ -1063,13 +1063,9 @@ static int ffs_sb_fill(struct super_block *sb, void *_data, int silent)
                                   &simple_dir_operations,
                                   &simple_dir_inode_operations,
                                   &data->perms);
-        if (unlikely(!inode))
+        sb->s_root = d_make_root(inode);
+        if (unlikely(!sb->s_root))
                 goto Enomem;
-        sb->s_root = d_alloc_root(inode);
-        if (unlikely(!sb->s_root)) {
-                iput(inode);
-                goto Enomem;
-        }
 
         /* EP0 file */
         if (unlikely(!ffs_sb_create_file(sb, "ep0", ffs,
@@ -1258,9 +1254,7 @@ static void ffs_data_put(struct ffs_data *ffs)
         if (unlikely(atomic_dec_and_test(&ffs->ref))) {
                 pr_info("%s(): freeing\n", __func__);
                 ffs_data_clear(ffs);
-                BUG_ON(mutex_is_locked(&ffs->mutex) ||
-                       spin_is_locked(&ffs->ev.waitq.lock) ||
-                       waitqueue_active(&ffs->ev.waitq) ||
+                BUG_ON(waitqueue_active(&ffs->ev.waitq) ||
                        waitqueue_active(&ffs->ep0req_completion.wait));
                 kfree(ffs);
         }
diff --git a/drivers/usb/gadget/f_loopback.c b/drivers/usb/gadget/f_loopback.c
index 6d87f288df4e..2c0cd824c667 100644
--- a/drivers/usb/gadget/f_loopback.c
+++ b/drivers/usb/gadget/f_loopback.c
@@ -418,7 +418,7 @@ int __init loopback_add(struct usb_composite_dev *cdev, bool autoresume)
 
         /* support autoresume for remote wakeup testing */
         if (autoresume)
-                sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+                loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
 
         /* support OTG systems */
         if (gadget_is_otg(cdev->gadget)) {
diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
index ee8ceec01560..a371e966425f 100644
--- a/drivers/usb/gadget/f_mass_storage.c
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 2003-2008 Alan Stern
  * Copyright (C) 2009 Samsung Electronics
- *                    Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
+ *                    Author: Michal Nazarewicz <mina86@mina86.com>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -304,7 +304,6 @@
 
 static const char fsg_string_interface[] = "Mass Storage";
 
-#define FSG_NO_INTR_EP 1
 #define FSG_NO_DEVICE_STRINGS    1
 #define FSG_NO_OTG               1
 #define FSG_NO_INTR_EP           1
@@ -620,7 +619,7 @@ static int fsg_setup(struct usb_function *f,
 
         switch (ctrl->bRequest) {
 
-        case USB_BULK_RESET_REQUEST:
+        case US_BULK_RESET_REQUEST:
                 if (ctrl->bRequestType !=
                     (USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
                         break;
@@ -636,7 +635,7 @@ static int fsg_setup(struct usb_function *f,
                 raise_exception(fsg->common, FSG_STATE_RESET);
                 return DELAYED_STATUS;
 
-        case USB_BULK_GET_MAX_LUN_REQUEST:
+        case US_BULK_GET_MAX_LUN:
                 if (ctrl->bRequestType !=
                     (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE))
                         break;
@@ -1742,7 +1741,7 @@ static int send_status(struct fsg_common *common)
         struct fsg_buffhd       *bh;
         struct bulk_cs_wrap     *csw;
         int                     rc;
-        u8                      status = USB_STATUS_PASS;
+        u8                      status = US_BULK_STAT_OK;
         u32                     sd, sdinfo = 0;
 
         /* Wait for the next buffer to become available */
@@ -1763,11 +1762,11 @@ static int send_status(struct fsg_common *common)
 
         if (common->phase_error) {
                 DBG(common, "sending phase-error status\n");
-                status = USB_STATUS_PHASE_ERROR;
+                status = US_BULK_STAT_PHASE;
                 sd = SS_INVALID_COMMAND;
         } else if (sd != SS_NO_SENSE) {
                 DBG(common, "sending command-failure status\n");
-                status = USB_STATUS_FAIL;
+                status = US_BULK_STAT_FAIL;
                 VDBG(common, "  sense data: SK x%02x, ASC x%02x, ASCQ x%02x;"
                                 "  info x%x\n",
                                 SK(sd), ASC(sd), ASCQ(sd), sdinfo);
@@ -1776,12 +1775,12 @@ static int send_status(struct fsg_common *common)
         /* Store and send the Bulk-only CSW */
         csw = (void *)bh->buf;
 
-        csw->Signature = cpu_to_le32(USB_BULK_CS_SIG);
+        csw->Signature = cpu_to_le32(US_BULK_CS_SIGN);
         csw->Tag = common->tag;
         csw->Residue = cpu_to_le32(common->residue);
         csw->Status = status;
 
-        bh->inreq->length = USB_BULK_CS_WRAP_LEN;
+        bh->inreq->length = US_BULK_CS_WRAP_LEN;
         bh->inreq->zero = 0;
         if (!start_in_transfer(common, bh))
                 /* Don't know what to do if common->fsg is NULL */
@@ -2221,7 +2220,7 @@ unknown_cmnd:
 static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
         struct usb_request      *req = bh->outreq;
-        struct fsg_bulk_cb_wrap *cbw = req->buf;
+        struct bulk_cb_wrap     *cbw = req->buf;
         struct fsg_common       *common = fsg->common;
 
         /* Was this a real packet?  Should it be ignored? */
@@ -2229,9 +2228,9 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
                 return -EINVAL;
 
         /* Is the CBW valid? */
-        if (req->actual != USB_BULK_CB_WRAP_LEN ||
+        if (req->actual != US_BULK_CB_WRAP_LEN ||
                         cbw->Signature != cpu_to_le32(
-                                USB_BULK_CB_SIG)) {
+                                US_BULK_CB_SIGN)) {
                 DBG(fsg, "invalid CBW: len %u sig 0x%x\n",
                                 req->actual,
                                 le32_to_cpu(cbw->Signature));
@@ -2253,7 +2252,7 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
         }
 
         /* Is the CBW meaningful? */
-        if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG ||
+        if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~US_BULK_FLAG_IN ||
                         cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) {
                 DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
                                 "cmdlen %u\n",
@@ -2273,7 +2272,7 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
         /* Save the command for later */
         common->cmnd_size = cbw->Length;
         memcpy(common->cmnd, cbw->CDB, common->cmnd_size);
-        if (cbw->Flags & USB_BULK_IN_FLAG)
+        if (cbw->Flags & US_BULK_FLAG_IN)
                 common->data_dir = DATA_DIR_TO_HOST;
         else
                 common->data_dir = DATA_DIR_FROM_HOST;
@@ -2303,7 +2302,7 @@ static int get_next_command(struct fsg_common *common)
         }
 
         /* Queue a request to read a Bulk-only CBW */
-        set_bulk_out_req_length(common, bh, USB_BULK_CB_WRAP_LEN);
+        set_bulk_out_req_length(common, bh, US_BULK_CB_WRAP_LEN);
         if (!start_out_transfer(common, bh))
                 /* Don't know what to do if common->fsg is NULL */
                 return -EIO;
diff --git a/drivers/usb/gadget/f_midi.c b/drivers/usb/gadget/f_midi.c
index 3797b3d6c622..2f7e8f2930cc 100644
--- a/drivers/usb/gadget/f_midi.c
+++ b/drivers/usb/gadget/f_midi.c
@@ -780,7 +780,7 @@ f_midi_bind(struct usb_configuration *c, struct usb_function *f)
         midi->out_ep->driver_data = cdev;       /* claim */
 
         /* allocate temporary function list */
-        midi_function = kcalloc((MAX_PORTS * 4) + 9, sizeof(midi_function),
+        midi_function = kcalloc((MAX_PORTS * 4) + 9, sizeof(*midi_function),
                                 GFP_KERNEL);
         if (!midi_function) {
                 status = -ENOMEM;
diff --git a/drivers/usb/gadget/f_phonet.c b/drivers/usb/gadget/f_phonet.c
index 7cdcb63b21ff..965a6293206a 100644
--- a/drivers/usb/gadget/f_phonet.c
+++ b/drivers/usb/gadget/f_phonet.c
@@ -345,7 +345,7 @@ static void pn_rx_complete(struct usb_ep *ep, struct usb_request *req)
                 }
 
                 skb_add_rx_frag(skb, skb_shinfo(skb)->nr_frags, page,
-                                skb->len <= 1, req->actual);
+                                skb->len <= 1, req->actual, PAGE_SIZE);
                 page = NULL;
 
                 if (req->actual < req->length) { /* Last fragment */
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
index 704d1d94f72a..7b1cf18df5e3 100644
--- a/drivers/usb/gadget/f_rndis.c
+++ b/drivers/usb/gadget/f_rndis.c
@@ -5,7 +5,7 @@
  * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
  * Copyright (C) 2008 Nokia Corporation
  * Copyright (C) 2009 Samsung Electronics
- *                    Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
+ *                    Author: Michal Nazarewicz (mina86@mina86.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
diff --git a/drivers/usb/gadget/f_serial.c b/drivers/usb/gadget/f_serial.c
index cf33a8d0fd5d..07197d63d9b1 100644
--- a/drivers/usb/gadget/f_serial.c
+++ b/drivers/usb/gadget/f_serial.c
@@ -99,6 +99,34 @@ static struct usb_descriptor_header *gser_hs_function[] __initdata = {
         NULL,
 };
 
+static struct usb_endpoint_descriptor gser_ss_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(1024),
+};
+
+static struct usb_endpoint_descriptor gser_ss_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       cpu_to_le16(1024),
+};
+
+static struct usb_ss_ep_comp_descriptor gser_ss_bulk_comp_desc __initdata = {
+        .bLength =              sizeof gser_ss_bulk_comp_desc,
+        .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
+};
+
+static struct usb_descriptor_header *gser_ss_function[] __initdata = {
+        (struct usb_descriptor_header *) &gser_interface_desc,
+        (struct usb_descriptor_header *) &gser_ss_in_desc,
+        (struct usb_descriptor_header *) &gser_ss_bulk_comp_desc,
+        (struct usb_descriptor_header *) &gser_ss_out_desc,
+        (struct usb_descriptor_header *) &gser_ss_bulk_comp_desc,
+        NULL,
+};
+
 /* string descriptors: */
 
 static struct usb_string gser_string_defs[] = {
@@ -201,9 +229,21 @@ gser_bind(struct usb_configuration *c, struct usb_function *f)
                 /* copy descriptors, and track endpoint copies */
                 f->hs_descriptors = usb_copy_descriptors(gser_hs_function);
         }
+        if (gadget_is_superspeed(c->cdev->gadget)) {
+                gser_ss_in_desc.bEndpointAddress =
+                        gser_fs_in_desc.bEndpointAddress;
+                gser_ss_out_desc.bEndpointAddress =
+                        gser_fs_out_desc.bEndpointAddress;
+
+                /* copy descriptors, and track endpoint copies */
+                f->ss_descriptors = usb_copy_descriptors(gser_ss_function);
+                if (!f->ss_descriptors)
+                        goto fail;
+        }
 
         DBG(cdev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",
                         gser->port_num,
+                        gadget_is_superspeed(c->cdev->gadget) ? "super" :
                         gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
                         gser->port.in->name, gser->port.out->name);
         return 0;
@@ -225,6 +265,8 @@ gser_unbind(struct usb_configuration *c, struct usb_function *f)
 {
         if (gadget_is_dualspeed(c->cdev->gadget))
                 usb_free_descriptors(f->hs_descriptors);
+        if (gadget_is_superspeed(c->cdev->gadget))
+                usb_free_descriptors(f->ss_descriptors);
         usb_free_descriptors(f->descriptors);
         kfree(func_to_gser(f));
 }
diff --git a/drivers/usb/gadget/f_subset.c b/drivers/usb/gadget/f_subset.c
index c1540648125a..21ab474aca07 100644
--- a/drivers/usb/gadget/f_subset.c
+++ b/drivers/usb/gadget/f_subset.c
@@ -74,7 +74,7 @@ static inline struct f_gether *func_to_geth(struct usb_function *f)
 
 /* interface descriptor: */
 
-static struct usb_interface_descriptor subset_data_intf __initdata = {
+static struct usb_interface_descriptor subset_data_intf = {
         .bLength =              sizeof subset_data_intf,
         .bDescriptorType =      USB_DT_INTERFACE,
 
@@ -87,7 +87,7 @@ static struct usb_interface_descriptor subset_data_intf __initdata = {
         /* .iInterface = DYNAMIC */
 };
 
-static struct usb_cdc_header_desc mdlm_header_desc __initdata = {
+static struct usb_cdc_header_desc mdlm_header_desc = {
         .bLength =              sizeof mdlm_header_desc,
         .bDescriptorType =      USB_DT_CS_INTERFACE,
         .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
@@ -95,7 +95,7 @@ static struct usb_cdc_header_desc mdlm_header_desc __initdata = {
         .bcdCDC =               cpu_to_le16(0x0110),
 };
 
-static struct usb_cdc_mdlm_desc mdlm_desc __initdata = {
+static struct usb_cdc_mdlm_desc mdlm_desc = {
         .bLength =              sizeof mdlm_desc,
         .bDescriptorType =      USB_DT_CS_INTERFACE,
         .bDescriptorSubType =   USB_CDC_MDLM_TYPE,
@@ -111,7 +111,7 @@ static struct usb_cdc_mdlm_desc mdlm_desc __initdata = {
  * can't really use its struct.  All we do here is say that we're using
  * the submode of "SAFE" which directly matches the CDC Subset.
  */
-static u8 mdlm_detail_desc[] __initdata = {
+static u8 mdlm_detail_desc[] = {
         6,
         USB_DT_CS_INTERFACE,
         USB_CDC_MDLM_DETAIL_TYPE,
@@ -121,7 +121,7 @@ static u8 mdlm_detail_desc[] __initdata = {
         0,      /* network data capabilities ("raw" encapsulation) */
 };
 
-static struct usb_cdc_ether_desc ether_desc __initdata = {
+static struct usb_cdc_ether_desc ether_desc = {
         .bLength =              sizeof ether_desc,
         .bDescriptorType =      USB_DT_CS_INTERFACE,
         .bDescriptorSubType =   USB_CDC_ETHERNET_TYPE,
@@ -136,7 +136,7 @@ static struct usb_cdc_ether_desc ether_desc __initdata = {
 
 /* full speed support: */
 
-static struct usb_endpoint_descriptor fs_subset_in_desc __initdata = {
+static struct usb_endpoint_descriptor fs_subset_in_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -144,7 +144,7 @@ static struct usb_endpoint_descriptor fs_subset_in_desc __initdata = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 };
 
-static struct usb_endpoint_descriptor fs_subset_out_desc __initdata = {
+static struct usb_endpoint_descriptor fs_subset_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -152,7 +152,7 @@ static struct usb_endpoint_descriptor fs_subset_out_desc __initdata = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 };
 
-static struct usb_descriptor_header *fs_eth_function[] __initdata = {
+static struct usb_descriptor_header *fs_eth_function[] = {
         (struct usb_descriptor_header *) &subset_data_intf,
         (struct usb_descriptor_header *) &mdlm_header_desc,
         (struct usb_descriptor_header *) &mdlm_desc,
@@ -165,7 +165,7 @@ static struct usb_descriptor_header *fs_eth_function[] __initdata = {
 
 /* high speed support: */
 
-static struct usb_endpoint_descriptor hs_subset_in_desc __initdata = {
+static struct usb_endpoint_descriptor hs_subset_in_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -173,7 +173,7 @@ static struct usb_endpoint_descriptor hs_subset_in_desc __initdata = {
         .wMaxPacketSize =       cpu_to_le16(512),
 };
 
-static struct usb_endpoint_descriptor hs_subset_out_desc __initdata = {
+static struct usb_endpoint_descriptor hs_subset_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -181,7 +181,7 @@ static struct usb_endpoint_descriptor hs_subset_out_desc __initdata = {
         .wMaxPacketSize =       cpu_to_le16(512),
 };
 
-static struct usb_descriptor_header *hs_eth_function[] __initdata = {
+static struct usb_descriptor_header *hs_eth_function[] = {
         (struct usb_descriptor_header *) &subset_data_intf,
         (struct usb_descriptor_header *) &mdlm_header_desc,
         (struct usb_descriptor_header *) &mdlm_desc,
@@ -194,7 +194,7 @@ static struct usb_descriptor_header *hs_eth_function[] __initdata = {
 
 /* super speed support: */
 
-static struct usb_endpoint_descriptor ss_subset_in_desc __initdata = {
+static struct usb_endpoint_descriptor ss_subset_in_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -202,7 +202,7 @@ static struct usb_endpoint_descriptor ss_subset_in_desc __initdata = {
         .wMaxPacketSize =       cpu_to_le16(1024),
 };
 
-static struct usb_endpoint_descriptor ss_subset_out_desc __initdata = {
+static struct usb_endpoint_descriptor ss_subset_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -210,7 +210,7 @@ static struct usb_endpoint_descriptor ss_subset_out_desc __initdata = {
         .wMaxPacketSize =       cpu_to_le16(1024),
 };
 
-static struct usb_ss_ep_comp_descriptor ss_subset_bulk_comp_desc __initdata = {
+static struct usb_ss_ep_comp_descriptor ss_subset_bulk_comp_desc = {
         .bLength =              sizeof ss_subset_bulk_comp_desc,
         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 
@@ -219,7 +219,7 @@ static struct usb_ss_ep_comp_descriptor ss_subset_bulk_comp_desc __initdata = {
         /* .bmAttributes =      0, */
 };
 
-static struct usb_descriptor_header *ss_eth_function[] __initdata = {
+static struct usb_descriptor_header *ss_eth_function[] = {
         (struct usb_descriptor_header *) &subset_data_intf,
         (struct usb_descriptor_header *) &mdlm_header_desc,
         (struct usb_descriptor_header *) &mdlm_desc,
@@ -290,7 +290,7 @@ static void geth_disable(struct usb_function *f)
 
 /* serial function driver setup/binding */
 
-static int __init
+static int
 geth_bind(struct usb_configuration *c, struct usb_function *f)
 {
         struct usb_composite_dev *cdev = c->cdev;
@@ -404,7 +404,7 @@ geth_unbind(struct usb_configuration *c, struct usb_function *f)
  * Caller must have called @gether_setup().  Caller is also responsible
  * for calling @gether_cleanup() before module unload.
  */
-int __init geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
+int geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
 {
         struct f_gether *geth;
         int             status;
diff --git a/drivers/usb/gadget/f_audio.c b/drivers/usb/gadget/f_uac1.c
index ec7ffcd0d0cd..1a5dcd5565e3 100644
--- a/drivers/usb/gadget/f_audio.c
+++ b/drivers/usb/gadget/f_uac1.c
@@ -14,7 +14,7 @@
 #include <linux/device.h>
 #include <linux/atomic.h>
 
-#include "u_audio.h"
+#include "u_uac1.h"
 
 #define OUT_EP_MAX_PACKET_SIZE  200
 static int req_buf_size = OUT_EP_MAX_PACKET_SIZE;
@@ -216,29 +216,6 @@ static struct usb_descriptor_header *f_audio_desc[] __initdata = {
         NULL,
 };
 
-/* string IDs are assigned dynamically */
-
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-
-static char manufacturer[50];
-
-static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s = manufacturer,
-        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
-        {  } /* end of list */
-};
-
-static struct usb_gadget_strings stringtab_dev = {
-        .language       = 0x0409,       /* en-us */
-        .strings        = strings_dev,
-};
-
-static struct usb_gadget_strings *audio_strings[] = {
-        &stringtab_dev,
-        NULL,
-};
-
 /*
  * This function is an ALSA sound card following USB Audio Class Spec 1.0.
  */
diff --git a/drivers/usb/gadget/f_uac2.c b/drivers/usb/gadget/f_uac2.c
new file mode 100644
index 000000000000..e7cc4de93e33
--- /dev/null
+++ b/drivers/usb/gadget/f_uac2.c
@@ -0,0 +1,1449 @@
+/*
+ * f_uac2.c -- USB Audio Class 2.0 Function
+ *
+ * Copyright (C) 2011
+ *    Yadwinder Singh (yadi.brar01@gmail.com)
+ *    Jaswinder Singh (jaswinder.singh@linaro.org)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/usb/audio.h>
+#include <linux/usb/audio-v2.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+
+/* Playback(USB-IN) Default Stereo - Fl/Fr */
+static int p_chmask = 0x3;
+module_param(p_chmask, uint, S_IRUGO);
+MODULE_PARM_DESC(p_chmask, "Playback Channel Mask");
+
+/* Playback Default 48 KHz */
+static int p_srate = 48000;
+module_param(p_srate, uint, S_IRUGO);
+MODULE_PARM_DESC(p_srate, "Playback Sampling Rate");
+
+/* Playback Default 16bits/sample */
+static int p_ssize = 2;
+module_param(p_ssize, uint, S_IRUGO);
+MODULE_PARM_DESC(p_ssize, "Playback Sample Size(bytes)");
+
+/* Capture(USB-OUT) Default Stereo - Fl/Fr */
+static int c_chmask = 0x3;
+module_param(c_chmask, uint, S_IRUGO);
+MODULE_PARM_DESC(c_chmask, "Capture Channel Mask");
+
+/* Capture Default 64 KHz */
+static int c_srate = 64000;
+module_param(c_srate, uint, S_IRUGO);
+MODULE_PARM_DESC(c_srate, "Capture Sampling Rate");
+
+/* Capture Default 16bits/sample */
+static int c_ssize = 2;
+module_param(c_ssize, uint, S_IRUGO);
+MODULE_PARM_DESC(c_ssize, "Capture Sample Size(bytes)");
+
+#define DMA_ADDR_INVALID        (~(dma_addr_t)0)
+
+#define ALT_SET(x, a)   do {(x) &= ~0xff; (x) |= (a); } while (0)
+#define ALT_GET(x)      ((x) & 0xff)
+#define INTF_SET(x, i)  do {(x) &= 0xff; (x) |= ((i) << 8); } while (0)
+#define INTF_GET(x)     ((x >> 8) & 0xff)
+
+/* Keep everyone on toes */
+#define USB_XFERS       2
+
+/*
+ * The driver implements a simple UAC_2 topology.
+ * USB-OUT -> IT_1 -> OT_3 -> ALSA_Capture
+ * ALSA_Playback -> IT_2 -> OT_4 -> USB-IN
+ * Capture and Playback sampling rates are independently
+ *  controlled by two clock sources :
+ *    CLK_5 := c_srate, and CLK_6 := p_srate
+ */
+#define USB_OUT_IT_ID   1
+#define IO_IN_IT_ID     2
+#define IO_OUT_OT_ID    3
+#define USB_IN_OT_ID    4
+#define USB_OUT_CLK_ID  5
+#define USB_IN_CLK_ID   6
+
+#define CONTROL_ABSENT  0
+#define CONTROL_RDONLY  1
+#define CONTROL_RDWR    3
+
+#define CLK_FREQ_CTRL   0
+#define CLK_VLD_CTRL    2
+
+#define COPY_CTRL       0
+#define CONN_CTRL       2
+#define OVRLD_CTRL      4
+#define CLSTR_CTRL      6
+#define UNFLW_CTRL      8
+#define OVFLW_CTRL      10
+
+const char *uac2_name = "snd_uac2";
+
+struct uac2_req {
+        struct uac2_rtd_params *pp; /* parent param */
+        struct usb_request *req;
+};
+
+struct uac2_rtd_params {
+        bool ep_enabled; /* if the ep is enabled */
+        /* Size of the ring buffer */
+        size_t dma_bytes;
+        unsigned char *dma_area;
+
+        struct snd_pcm_substream *ss;
+
+        /* Ring buffer */
+        ssize_t hw_ptr;
+
+        void *rbuf;
+
+        size_t period_size;
+
+        unsigned max_psize;
+        struct uac2_req ureq[USB_XFERS];
+
+        spinlock_t lock;
+};
+
+struct snd_uac2_chip {
+        struct platform_device pdev;
+        struct platform_driver pdrv;
+
+        struct uac2_rtd_params p_prm;
+        struct uac2_rtd_params c_prm;
+
+        struct snd_card *card;
+        struct snd_pcm *pcm;
+};
+
+#define BUFF_SIZE_MAX   (PAGE_SIZE * 16)
+#define PRD_SIZE_MAX    PAGE_SIZE
+#define MIN_PERIODS     4
+
+static struct snd_pcm_hardware uac2_pcm_hardware = {
+        .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
+                 | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
+                 | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
+        .rates = SNDRV_PCM_RATE_CONTINUOUS,
+        .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
+        .buffer_bytes_max = BUFF_SIZE_MAX,
+        .period_bytes_max = PRD_SIZE_MAX,
+        .periods_min = MIN_PERIODS,
+};
+
+struct audio_dev {
+        /* Currently active {Interface[15:8] | AltSettings[7:0]} */
+        __u16 ac_alt, as_out_alt, as_in_alt;
+
+        struct usb_ep *in_ep, *out_ep;
+        struct usb_function func;
+
+        /* The ALSA Sound Card it represents on the USB-Client side */
+        struct snd_uac2_chip uac2;
+};
+
+static struct audio_dev *agdev_g;
+
+static inline
+struct audio_dev *func_to_agdev(struct usb_function *f)
+{
+        return container_of(f, struct audio_dev, func);
+}
+
+static inline
+struct audio_dev *uac2_to_agdev(struct snd_uac2_chip *u)
+{
+        return container_of(u, struct audio_dev, uac2);
+}
+
+static inline
+struct snd_uac2_chip *pdev_to_uac2(struct platform_device *p)
+{
+        return container_of(p, struct snd_uac2_chip, pdev);
+}
+
+static inline
+struct snd_uac2_chip *prm_to_uac2(struct uac2_rtd_params *r)
+{
+        struct snd_uac2_chip *uac2 = container_of(r,
+                                        struct snd_uac2_chip, c_prm);
+
+        if (&uac2->c_prm != r)
+                uac2 = container_of(r, struct snd_uac2_chip, p_prm);
+
+        return uac2;
+}
+
+static inline
+uint num_channels(uint chanmask)
+{
+        uint num = 0;
+
+        while (chanmask) {
+                num += (chanmask & 1);
+                chanmask >>= 1;
+        }
+
+        return num;
+}
+
+static void
+agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        unsigned pending;
+        unsigned long flags;
+        bool update_alsa = false;
+        unsigned char *src, *dst;
+        int status = req->status;
+        struct uac2_req *ur = req->context;
+        struct snd_pcm_substream *substream;
+        struct uac2_rtd_params *prm = ur->pp;
+        struct snd_uac2_chip *uac2 = prm_to_uac2(prm);
+
+        /* i/f shutting down */
+        if (!prm->ep_enabled)
+                return;
+
+        /*
+         * We can't really do much about bad xfers.
+         * Afterall, the ISOCH xfers could fail legitimately.
+         */
+        if (status)
+                pr_debug("%s: iso_complete status(%d) %d/%d\n",
+                        __func__, status, req->actual, req->length);
+
+        substream = prm->ss;
+
+        /* Do nothing if ALSA isn't active */
+        if (!substream)
+                goto exit;
+
+        spin_lock_irqsave(&prm->lock, flags);
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                src = prm->dma_area + prm->hw_ptr;
+                req->actual = req->length;
+                dst = req->buf;
+        } else {
+                dst = prm->dma_area + prm->hw_ptr;
+                src = req->buf;
+        }
+
+        pending = prm->hw_ptr % prm->period_size;
+        pending += req->actual;
+        if (pending >= prm->period_size)
+                update_alsa = true;
+
+        prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes;
+
+        spin_unlock_irqrestore(&prm->lock, flags);
+
+        /* Pack USB load in ALSA ring buffer */
+        memcpy(dst, src, req->actual);
+exit:
+        if (usb_ep_queue(ep, req, GFP_ATOMIC))
+                dev_err(&uac2->pdev.dev, "%d Error!\n", __LINE__);
+
+        if (update_alsa)
+                snd_pcm_period_elapsed(substream);
+
+        return;
+}
+
+static int
+uac2_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
+        struct audio_dev *agdev = uac2_to_agdev(uac2);
+        struct uac2_rtd_params *prm;
+        unsigned long flags;
+        struct usb_ep *ep;
+        int err = 0;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                ep = agdev->in_ep;
+                prm = &uac2->p_prm;
+        } else {
+                ep = agdev->out_ep;
+                prm = &uac2->c_prm;
+        }
+
+        spin_lock_irqsave(&prm->lock, flags);
+
+        /* Reset */
+        prm->hw_ptr = 0;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_RESUME:
+                prm->ss = substream;
+                break;
+        case SNDRV_PCM_TRIGGER_STOP:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
+                prm->ss = NULL;
+                break;
+        default:
+                err = -EINVAL;
+        }
+
+        spin_unlock_irqrestore(&prm->lock, flags);
+
+        /* Clear buffer after Play stops */
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
+                memset(prm->rbuf, 0, prm->max_psize * USB_XFERS);
+
+        return err;
+}
+
+static snd_pcm_uframes_t uac2_pcm_pointer(struct snd_pcm_substream *substream)
+{
+        struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
+        struct uac2_rtd_params *prm;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                prm = &uac2->p_prm;
+        else
+                prm = &uac2->c_prm;
+
+        return bytes_to_frames(substream->runtime, prm->hw_ptr);
+}
+
+static int uac2_pcm_hw_params(struct snd_pcm_substream *substream,
+                               struct snd_pcm_hw_params *hw_params)
+{
+        struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
+        struct uac2_rtd_params *prm;
+        int err;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                prm = &uac2->p_prm;
+        else
+                prm = &uac2->c_prm;
+
+        err = snd_pcm_lib_malloc_pages(substream,
+                                        params_buffer_bytes(hw_params));
+        if (err >= 0) {
+                prm->dma_bytes = substream->runtime->dma_bytes;
+                prm->dma_area = substream->runtime->dma_area;
+                prm->period_size = params_period_bytes(hw_params);
+        }
+
+        return err;
+}
+
+static int uac2_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+        struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
+        struct uac2_rtd_params *prm;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                prm = &uac2->p_prm;
+        else
+                prm = &uac2->c_prm;
+
+        prm->dma_area = NULL;
+        prm->dma_bytes = 0;
+        prm->period_size = 0;
+
+        return snd_pcm_lib_free_pages(substream);
+}
+
+static int uac2_pcm_open(struct snd_pcm_substream *substream)
+{
+        struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
+        struct snd_pcm_runtime *runtime = substream->runtime;
+
+        runtime->hw = uac2_pcm_hardware;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                spin_lock_init(&uac2->p_prm.lock);
+                runtime->hw.rate_min = p_srate;
+                runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE; /* ! p_ssize ! */
+                runtime->hw.channels_min = num_channels(p_chmask);
+                runtime->hw.period_bytes_min = 2 * uac2->p_prm.max_psize
+                                                / runtime->hw.periods_min;
+        } else {
+                spin_lock_init(&uac2->c_prm.lock);
+                runtime->hw.rate_min = c_srate;
+                runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE; /* ! c_ssize ! */
+                runtime->hw.channels_min = num_channels(c_chmask);
+                runtime->hw.period_bytes_min = 2 * uac2->c_prm.max_psize
+                                                / runtime->hw.periods_min;
+        }
+
+        runtime->hw.rate_max = runtime->hw.rate_min;
+        runtime->hw.channels_max = runtime->hw.channels_min;
+
+        snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
+
+        return 0;
+}
+
+/* ALSA cries without these function pointers */
+static int uac2_pcm_null(struct snd_pcm_substream *substream)
+{
+        return 0;
+}
+
+static struct snd_pcm_ops uac2_pcm_ops = {
+        .open = uac2_pcm_open,
+        .close = uac2_pcm_null,
+        .ioctl = snd_pcm_lib_ioctl,
+        .hw_params = uac2_pcm_hw_params,
+        .hw_free = uac2_pcm_hw_free,
+        .trigger = uac2_pcm_trigger,
+        .pointer = uac2_pcm_pointer,
+        .prepare = uac2_pcm_null,
+};
+
+static int __devinit snd_uac2_probe(struct platform_device *pdev)
+{
+        struct snd_uac2_chip *uac2 = pdev_to_uac2(pdev);
+        struct snd_card *card;
+        struct snd_pcm *pcm;
+        int err;
+
+        /* Choose any slot, with no id */
+        err = snd_card_create(-1, NULL, THIS_MODULE, 0, &card);
+        if (err < 0)
+                return err;
+
+        uac2->card = card;
+
+        /*
+         * Create first PCM device
+         * Create a substream only for non-zero channel streams
+         */
+        err = snd_pcm_new(uac2->card, "UAC2 PCM", 0,
+                               p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
+        if (err < 0)
+                goto snd_fail;
+
+        strcpy(pcm->name, "UAC2 PCM");
+        pcm->private_data = uac2;
+
+        uac2->pcm = pcm;
+
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac2_pcm_ops);
+        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac2_pcm_ops);
+
+        strcpy(card->driver, "UAC2_Gadget");
+        strcpy(card->shortname, "UAC2_Gadget");
+        sprintf(card->longname, "UAC2_Gadget %i", pdev->id);
+
+        snd_card_set_dev(card, &pdev->dev);
+
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
+                snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
+
+        err = snd_card_register(card);
+        if (!err) {
+                platform_set_drvdata(pdev, card);
+                return 0;
+        }
+
+snd_fail:
+        snd_card_free(card);
+
+        uac2->pcm = NULL;
+        uac2->card = NULL;
+
+        return err;
+}
+
+static int __devexit snd_uac2_remove(struct platform_device *pdev)
+{
+        struct snd_card *card = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+
+        if (card)
+                return snd_card_free(card);
+
+        return 0;
+}
+
+static int alsa_uac2_init(struct audio_dev *agdev)
+{
+        struct snd_uac2_chip *uac2 = &agdev->uac2;
+        int err;
+
+        uac2->pdrv.probe = snd_uac2_probe;
+        uac2->pdrv.remove = snd_uac2_remove;
+        uac2->pdrv.driver.name = uac2_name;
+
+        uac2->pdev.id = 0;
+        uac2->pdev.name = uac2_name;
+
+        /* Register snd_uac2 driver */
+        err = platform_driver_register(&uac2->pdrv);
+        if (err)
+                return err;
+
+        /* Register snd_uac2 device */
+        err = platform_device_register(&uac2->pdev);
+        if (err)
+                platform_driver_unregister(&uac2->pdrv);
+
+        return err;
+}
+
+static void alsa_uac2_exit(struct audio_dev *agdev)
+{
+        struct snd_uac2_chip *uac2 = &agdev->uac2;
+
+        platform_driver_unregister(&uac2->pdrv);
+        platform_device_unregister(&uac2->pdev);
+}
+
+
+/* --------- USB Function Interface ------------- */
+
+enum {
+        STR_ASSOC,
+        STR_IF_CTRL,
+        STR_CLKSRC_IN,
+        STR_CLKSRC_OUT,
+        STR_USB_IT,
+        STR_IO_IT,
+        STR_USB_OT,
+        STR_IO_OT,
+        STR_AS_OUT_ALT0,
+        STR_AS_OUT_ALT1,
+        STR_AS_IN_ALT0,
+        STR_AS_IN_ALT1,
+};
+
+static const char ifassoc[] = "Source/Sink";
+static const char ifctrl[] = "Topology Control";
+static char clksrc_in[8];
+static char clksrc_out[8];
+static const char usb_it[] = "USBH Out";
+static const char io_it[] = "USBD Out";
+static const char usb_ot[] = "USBH In";
+static const char io_ot[] = "USBD In";
+static const char out_alt0[] = "Playback Inactive";
+static const char out_alt1[] = "Playback Active";
+static const char in_alt0[] = "Capture Inactive";
+static const char in_alt1[] = "Capture Active";
+
+static struct usb_string strings_fn[] = {
+        [STR_ASSOC].s = ifassoc,
+        [STR_IF_CTRL].s = ifctrl,
+        [STR_CLKSRC_IN].s = clksrc_in,
+        [STR_CLKSRC_OUT].s = clksrc_out,
+        [STR_USB_IT].s = usb_it,
+        [STR_IO_IT].s = io_it,
+        [STR_USB_OT].s = usb_ot,
+        [STR_IO_OT].s = io_ot,
+        [STR_AS_OUT_ALT0].s = out_alt0,
+        [STR_AS_OUT_ALT1].s = out_alt1,
+        [STR_AS_IN_ALT0].s = in_alt0,
+        [STR_AS_IN_ALT1].s = in_alt1,
+        { },
+};
+
+static struct usb_gadget_strings str_fn = {
+        .language = 0x0409,     /* en-us */
+        .strings = strings_fn,
+};
+
+static struct usb_gadget_strings *fn_strings[] = {
+        &str_fn,
+        NULL,
+};
+
+static struct usb_qualifier_descriptor devqual_desc = {
+        .bLength = sizeof devqual_desc,
+        .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
+
+        .bcdUSB = cpu_to_le16(0x200),
+        .bDeviceClass = USB_CLASS_MISC,
+        .bDeviceSubClass = 0x02,
+        .bDeviceProtocol = 0x01,
+        .bNumConfigurations = 1,
+        .bRESERVED = 0,
+};
+
+static struct usb_interface_assoc_descriptor iad_desc = {
+        .bLength = sizeof iad_desc,
+        .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
+
+        .bFirstInterface = 0,
+        .bInterfaceCount = 3,
+        .bFunctionClass = USB_CLASS_AUDIO,
+        .bFunctionSubClass = UAC2_FUNCTION_SUBCLASS_UNDEFINED,
+        .bFunctionProtocol = UAC_VERSION_2,
+};
+
+/* Audio Control Interface */
+static struct usb_interface_descriptor std_ac_if_desc = {
+        .bLength = sizeof std_ac_if_desc,
+        .bDescriptorType = USB_DT_INTERFACE,
+
+        .bAlternateSetting = 0,
+        .bNumEndpoints = 0,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .bInterfaceProtocol = UAC_VERSION_2,
+};
+
+/* Clock source for IN traffic */
+struct uac_clock_source_descriptor in_clk_src_desc = {
+        .bLength = sizeof in_clk_src_desc,
+        .bDescriptorType = USB_DT_CS_INTERFACE,
+
+        .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
+        .bClockID = USB_IN_CLK_ID,
+        .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
+        .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
+        .bAssocTerminal = 0,
+};
+
+/* Clock source for OUT traffic */
+struct uac_clock_source_descriptor out_clk_src_desc = {
+        .bLength = sizeof out_clk_src_desc,
+        .bDescriptorType = USB_DT_CS_INTERFACE,
+
+        .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
+        .bClockID = USB_OUT_CLK_ID,
+        .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
+        .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
+        .bAssocTerminal = 0,
+};
+
+/* Input Terminal for USB_OUT */
+struct uac2_input_terminal_descriptor usb_out_it_desc = {
+        .bLength = sizeof usb_out_it_desc,
+        .bDescriptorType = USB_DT_CS_INTERFACE,
+
+        .bDescriptorSubtype = UAC_INPUT_TERMINAL,
+        .bTerminalID = USB_OUT_IT_ID,
+        .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
+        .bAssocTerminal = 0,
+        .bCSourceID = USB_OUT_CLK_ID,
+        .iChannelNames = 0,
+        .bmControls = (CONTROL_RDWR << COPY_CTRL),
+};
+
+/* Input Terminal for I/O-In */
+struct uac2_input_terminal_descriptor io_in_it_desc = {
+        .bLength = sizeof io_in_it_desc,
+        .bDescriptorType = USB_DT_CS_INTERFACE,
+
+        .bDescriptorSubtype = UAC_INPUT_TERMINAL,
+        .bTerminalID = IO_IN_IT_ID,
+        .wTerminalType = cpu_to_le16(UAC_INPUT_TERMINAL_UNDEFINED),
+        .bAssocTerminal = 0,
+        .bCSourceID = USB_IN_CLK_ID,
+        .iChannelNames = 0,
+        .bmControls = (CONTROL_RDWR << COPY_CTRL),
+};
+
+/* Ouput Terminal for USB_IN */
+struct uac2_output_terminal_descriptor usb_in_ot_desc = {
+        .bLength = sizeof usb_in_ot_desc,
+        .bDescriptorType = USB_DT_CS_INTERFACE,
+
+        .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
+        .bTerminalID = USB_IN_OT_ID,
+        .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
+        .bAssocTerminal = 0,
+        .bSourceID = IO_IN_IT_ID,
+        .bCSourceID = USB_IN_CLK_ID,
+        .bmControls = (CONTROL_RDWR << COPY_CTRL),
+};
+
+/* Ouput Terminal for I/O-Out */
+struct uac2_output_terminal_descriptor io_out_ot_desc = {
+        .bLength = sizeof io_out_ot_desc,
+        .bDescriptorType = USB_DT_CS_INTERFACE,
+
+        .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
+        .bTerminalID = IO_OUT_OT_ID,
+        .wTerminalType = cpu_to_le16(UAC_OUTPUT_TERMINAL_UNDEFINED),
+        .bAssocTerminal = 0,
+        .bSourceID = USB_OUT_IT_ID,
+        .bCSourceID = USB_OUT_CLK_ID,
+        .bmControls = (CONTROL_RDWR << COPY_CTRL),
+};
+
+struct uac2_ac_header_descriptor ac_hdr_desc = {
+        .bLength = sizeof ac_hdr_desc,
+        .bDescriptorType = USB_DT_CS_INTERFACE,
+
+        .bDescriptorSubtype = UAC_MS_HEADER,
+        .bcdADC = cpu_to_le16(0x200),
+        .bCategory = UAC2_FUNCTION_IO_BOX,
+        .wTotalLength = sizeof in_clk_src_desc + sizeof out_clk_src_desc
+                         + sizeof usb_out_it_desc + sizeof io_in_it_desc
+                        + sizeof usb_in_ot_desc + sizeof io_out_ot_desc,
+        .bmControls = 0,
+};
+
+/* Audio Streaming OUT Interface - Alt0 */
+static struct usb_interface_descriptor std_as_out_if0_desc = {
+        .bLength = sizeof std_as_out_if0_desc,
+        .bDescriptorType = USB_DT_INTERFACE,
+
+        .bAlternateSetting = 0,
+        .bNumEndpoints = 0,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
+        .bInterfaceProtocol = UAC_VERSION_2,
+};
+
+/* Audio Streaming OUT Interface - Alt1 */
+static struct usb_interface_descriptor std_as_out_if1_desc = {
+        .bLength = sizeof std_as_out_if1_desc,
+        .bDescriptorType = USB_DT_INTERFACE,
+
+        .bAlternateSetting = 1,
+        .bNumEndpoints = 1,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
+        .bInterfaceProtocol = UAC_VERSION_2,
+};
+
+/* Audio Stream OUT Intface Desc */
+struct uac2_as_header_descriptor as_out_hdr_desc = {
+        .bLength = sizeof as_out_hdr_desc,
+        .bDescriptorType = USB_DT_CS_INTERFACE,
+
+        .bDescriptorSubtype = UAC_AS_GENERAL,
+        .bTerminalLink = USB_OUT_IT_ID,
+        .bmControls = 0,
+        .bFormatType = UAC_FORMAT_TYPE_I,
+        .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
+        .iChannelNames = 0,
+};
+
+/* Audio USB_OUT Format */
+struct uac2_format_type_i_descriptor as_out_fmt1_desc = {
+        .bLength = sizeof as_out_fmt1_desc,
+        .bDescriptorType = USB_DT_CS_INTERFACE,
+        .bDescriptorSubtype = UAC_FORMAT_TYPE,
+        .bFormatType = UAC_FORMAT_TYPE_I,
+};
+
+/* STD AS ISO OUT Endpoint */
+struct usb_endpoint_descriptor fs_epout_desc = {
+        .bLength = USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType = USB_DT_ENDPOINT,
+
+        .bEndpointAddress = USB_DIR_OUT,
+        .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
+        .bInterval = 1,
+};
+
+struct usb_endpoint_descriptor hs_epout_desc = {
+        .bLength = USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType = USB_DT_ENDPOINT,
+
+        .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
+        .bInterval = 4,
+};
+
+/* CS AS ISO OUT Endpoint */
+static struct uac2_iso_endpoint_descriptor as_iso_out_desc = {
+        .bLength = sizeof as_iso_out_desc,
+        .bDescriptorType = USB_DT_CS_ENDPOINT,
+
+        .bDescriptorSubtype = UAC_EP_GENERAL,
+        .bmAttributes = 0,
+        .bmControls = 0,
+        .bLockDelayUnits = 0,
+        .wLockDelay = 0,
+};
+
+/* Audio Streaming IN Interface - Alt0 */
+static struct usb_interface_descriptor std_as_in_if0_desc = {
+        .bLength = sizeof std_as_in_if0_desc,
+        .bDescriptorType = USB_DT_INTERFACE,
+
+        .bAlternateSetting = 0,
+        .bNumEndpoints = 0,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
+        .bInterfaceProtocol = UAC_VERSION_2,
+};
+
+/* Audio Streaming IN Interface - Alt1 */
+static struct usb_interface_descriptor std_as_in_if1_desc = {
+        .bLength = sizeof std_as_in_if1_desc,
+        .bDescriptorType = USB_DT_INTERFACE,
+
+        .bAlternateSetting = 1,
+        .bNumEndpoints = 1,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
+        .bInterfaceProtocol = UAC_VERSION_2,
+};
+
+/* Audio Stream IN Intface Desc */
+struct uac2_as_header_descriptor as_in_hdr_desc = {
+        .bLength = sizeof as_in_hdr_desc,
+        .bDescriptorType = USB_DT_CS_INTERFACE,
+
+        .bDescriptorSubtype = UAC_AS_GENERAL,
+        .bTerminalLink = USB_IN_OT_ID,
+        .bmControls = 0,
+        .bFormatType = UAC_FORMAT_TYPE_I,
+        .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
+        .iChannelNames = 0,
+};
+
+/* Audio USB_IN Format */
+struct uac2_format_type_i_descriptor as_in_fmt1_desc = {
+        .bLength = sizeof as_in_fmt1_desc,
+        .bDescriptorType = USB_DT_CS_INTERFACE,
+        .bDescriptorSubtype = UAC_FORMAT_TYPE,
+        .bFormatType = UAC_FORMAT_TYPE_I,
+};
+
+/* STD AS ISO IN Endpoint */
+struct usb_endpoint_descriptor fs_epin_desc = {
+        .bLength = USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType = USB_DT_ENDPOINT,
+
+        .bEndpointAddress = USB_DIR_IN,
+        .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
+        .bInterval = 1,
+};
+
+struct usb_endpoint_descriptor hs_epin_desc = {
+        .bLength = USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType = USB_DT_ENDPOINT,
+
+        .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
+        .bInterval = 4,
+};
+
+/* CS AS ISO IN Endpoint */
+static struct uac2_iso_endpoint_descriptor as_iso_in_desc = {
+        .bLength = sizeof as_iso_in_desc,
+        .bDescriptorType = USB_DT_CS_ENDPOINT,
+
+        .bDescriptorSubtype = UAC_EP_GENERAL,
+        .bmAttributes = 0,
+        .bmControls = 0,
+        .bLockDelayUnits = 0,
+        .wLockDelay = 0,
+};
+
+static struct usb_descriptor_header *fs_audio_desc[] = {
+        (struct usb_descriptor_header *)&iad_desc,
+        (struct usb_descriptor_header *)&std_ac_if_desc,
+
+        (struct usb_descriptor_header *)&ac_hdr_desc,
+        (struct usb_descriptor_header *)&in_clk_src_desc,
+        (struct usb_descriptor_header *)&out_clk_src_desc,
+        (struct usb_descriptor_header *)&usb_out_it_desc,
+        (struct usb_descriptor_header *)&io_in_it_desc,
+        (struct usb_descriptor_header *)&usb_in_ot_desc,
+        (struct usb_descriptor_header *)&io_out_ot_desc,
+
+        (struct usb_descriptor_header *)&std_as_out_if0_desc,
+        (struct usb_descriptor_header *)&std_as_out_if1_desc,
+
+        (struct usb_descriptor_header *)&as_out_hdr_desc,
+        (struct usb_descriptor_header *)&as_out_fmt1_desc,
+        (struct usb_descriptor_header *)&fs_epout_desc,
+        (struct usb_descriptor_header *)&as_iso_out_desc,
+
+        (struct usb_descriptor_header *)&std_as_in_if0_desc,
+        (struct usb_descriptor_header *)&std_as_in_if1_desc,
+
+        (struct usb_descriptor_header *)&as_in_hdr_desc,
+        (struct usb_descriptor_header *)&as_in_fmt1_desc,
+        (struct usb_descriptor_header *)&fs_epin_desc,
+        (struct usb_descriptor_header *)&as_iso_in_desc,
+        NULL,
+};
+
+static struct usb_descriptor_header *hs_audio_desc[] = {
+        (struct usb_descriptor_header *)&iad_desc,
+        (struct usb_descriptor_header *)&std_ac_if_desc,
+
+        (struct usb_descriptor_header *)&ac_hdr_desc,
+        (struct usb_descriptor_header *)&in_clk_src_desc,
+        (struct usb_descriptor_header *)&out_clk_src_desc,
+        (struct usb_descriptor_header *)&usb_out_it_desc,
+        (struct usb_descriptor_header *)&io_in_it_desc,
+        (struct usb_descriptor_header *)&usb_in_ot_desc,
+        (struct usb_descriptor_header *)&io_out_ot_desc,
+
+        (struct usb_descriptor_header *)&std_as_out_if0_desc,
+        (struct usb_descriptor_header *)&std_as_out_if1_desc,
+
+        (struct usb_descriptor_header *)&as_out_hdr_desc,
+        (struct usb_descriptor_header *)&as_out_fmt1_desc,
+        (struct usb_descriptor_header *)&hs_epout_desc,
+        (struct usb_descriptor_header *)&as_iso_out_desc,
+
+        (struct usb_descriptor_header *)&std_as_in_if0_desc,
+        (struct usb_descriptor_header *)&std_as_in_if1_desc,
+
+        (struct usb_descriptor_header *)&as_in_hdr_desc,
+        (struct usb_descriptor_header *)&as_in_fmt1_desc,
+        (struct usb_descriptor_header *)&hs_epin_desc,
+        (struct usb_descriptor_header *)&as_iso_in_desc,
+        NULL,
+};
+
+struct cntrl_cur_lay3 {
+        __u32   dCUR;
+};
+
+struct cntrl_range_lay3 {
+        __u16   wNumSubRanges;
+        __u32   dMIN;
+        __u32   dMAX;
+        __u32   dRES;
+} __packed;
+
+static inline void
+free_ep(struct uac2_rtd_params *prm, struct usb_ep *ep)
+{
+        struct snd_uac2_chip *uac2 = prm_to_uac2(prm);
+        int i;
+
+        prm->ep_enabled = false;
+
+        for (i = 0; i < USB_XFERS; i++) {
+                if (prm->ureq[i].req) {
+                        usb_ep_dequeue(ep, prm->ureq[i].req);
+                        usb_ep_free_request(ep, prm->ureq[i].req);
+                        prm->ureq[i].req = NULL;
+                }
+        }
+
+        if (usb_ep_disable(ep))
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Error!\n", __func__, __LINE__);
+}
+
+static int __init
+afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
+{
+        struct audio_dev *agdev = func_to_agdev(fn);
+        struct snd_uac2_chip *uac2 = &agdev->uac2;
+        struct usb_composite_dev *cdev = cfg->cdev;
+        struct usb_gadget *gadget = cdev->gadget;
+        struct uac2_rtd_params *prm;
+        int ret;
+
+        ret = usb_interface_id(cfg, fn);
+        if (ret < 0) {
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Error!\n", __func__, __LINE__);
+                return ret;
+        }
+        std_ac_if_desc.bInterfaceNumber = ret;
+        ALT_SET(agdev->ac_alt, 0);
+        INTF_SET(agdev->ac_alt, ret);
+
+        ret = usb_interface_id(cfg, fn);
+        if (ret < 0) {
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Error!\n", __func__, __LINE__);
+                return ret;
+        }
+        std_as_out_if0_desc.bInterfaceNumber = ret;
+        std_as_out_if1_desc.bInterfaceNumber = ret;
+        ALT_SET(agdev->as_out_alt, 0);
+        INTF_SET(agdev->as_out_alt, ret);
+
+        ret = usb_interface_id(cfg, fn);
+        if (ret < 0) {
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Error!\n", __func__, __LINE__);
+                return ret;
+        }
+        std_as_in_if0_desc.bInterfaceNumber = ret;
+        std_as_in_if1_desc.bInterfaceNumber = ret;
+        ALT_SET(agdev->as_in_alt, 0);
+        INTF_SET(agdev->as_in_alt, ret);
+
+        agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
+        if (!agdev->out_ep)
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Error!\n", __func__, __LINE__);
+        agdev->out_ep->driver_data = agdev;
+
+        agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
+        if (!agdev->in_ep)
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Error!\n", __func__, __LINE__);
+        agdev->in_ep->driver_data = agdev;
+
+        hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
+        hs_epout_desc.wMaxPacketSize = fs_epout_desc.wMaxPacketSize;
+        hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
+        hs_epin_desc.wMaxPacketSize = fs_epin_desc.wMaxPacketSize;
+
+        fn->descriptors = usb_copy_descriptors(fs_audio_desc);
+        if (gadget_is_dualspeed(gadget))
+                fn->hs_descriptors = usb_copy_descriptors(hs_audio_desc);
+
+        prm = &agdev->uac2.c_prm;
+        prm->max_psize = hs_epout_desc.wMaxPacketSize;
+        prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
+        if (!prm->rbuf) {
+                prm->max_psize = 0;
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Error!\n", __func__, __LINE__);
+        }
+
+        prm = &agdev->uac2.p_prm;
+        prm->max_psize = hs_epin_desc.wMaxPacketSize;
+        prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
+        if (!prm->rbuf) {
+                prm->max_psize = 0;
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Error!\n", __func__, __LINE__);
+        }
+
+        return alsa_uac2_init(agdev);
+}
+
+static void
+afunc_unbind(struct usb_configuration *cfg, struct usb_function *fn)
+{
+        struct audio_dev *agdev = func_to_agdev(fn);
+        struct usb_composite_dev *cdev = cfg->cdev;
+        struct usb_gadget *gadget = cdev->gadget;
+        struct uac2_rtd_params *prm;
+
+        alsa_uac2_exit(agdev);
+
+        prm = &agdev->uac2.p_prm;
+        kfree(prm->rbuf);
+
+        prm = &agdev->uac2.c_prm;
+        kfree(prm->rbuf);
+
+        if (gadget_is_dualspeed(gadget))
+                usb_free_descriptors(fn->hs_descriptors);
+        usb_free_descriptors(fn->descriptors);
+
+        if (agdev->in_ep)
+                agdev->in_ep->driver_data = NULL;
+        if (agdev->out_ep)
+                agdev->out_ep->driver_data = NULL;
+}
+
+static int
+afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
+{
+        struct usb_composite_dev *cdev = fn->config->cdev;
+        struct audio_dev *agdev = func_to_agdev(fn);
+        struct snd_uac2_chip *uac2 = &agdev->uac2;
+        struct usb_gadget *gadget = cdev->gadget;
+        struct usb_request *req;
+        struct usb_ep *ep;
+        struct uac2_rtd_params *prm;
+        int i;
+
+        /* No i/f has more than 2 alt settings */
+        if (alt > 1) {
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Error!\n", __func__, __LINE__);
+                return -EINVAL;
+        }
+
+        if (intf == INTF_GET(agdev->ac_alt)) {
+                /* Control I/f has only 1 AltSetting - 0 */
+                if (alt) {
+                        dev_err(&uac2->pdev.dev,
+                                "%s:%d Error!\n", __func__, __LINE__);
+                        return -EINVAL;
+                }
+                return 0;
+        }
+
+        if (intf == INTF_GET(agdev->as_out_alt)) {
+                ep = agdev->out_ep;
+                prm = &uac2->c_prm;
+                config_ep_by_speed(gadget, fn, ep);
+                ALT_SET(agdev->as_out_alt, alt);
+        } else if (intf == INTF_GET(agdev->as_in_alt)) {
+                ep = agdev->in_ep;
+                prm = &uac2->p_prm;
+                config_ep_by_speed(gadget, fn, ep);
+                ALT_SET(agdev->as_in_alt, alt);
+        } else {
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Error!\n", __func__, __LINE__);
+                return -EINVAL;
+        }
+
+        if (alt == 0) {
+                free_ep(prm, ep);
+                return 0;
+        }
+
+        prm->ep_enabled = true;
+        usb_ep_enable(ep);
+
+        for (i = 0; i < USB_XFERS; i++) {
+                if (prm->ureq[i].req) {
+                        if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
+                                dev_err(&uac2->pdev.dev, "%d Error!\n",
+                                        __LINE__);
+                        continue;
+                }
+
+                req = usb_ep_alloc_request(ep, GFP_ATOMIC);
+                if (req == NULL) {
+                        dev_err(&uac2->pdev.dev,
+                                "%s:%d Error!\n", __func__, __LINE__);
+                        return -EINVAL;
+                }
+
+                prm->ureq[i].req = req;
+                prm->ureq[i].pp = prm;
+
+                req->zero = 0;
+                req->dma = DMA_ADDR_INVALID;
+                req->context = &prm->ureq[i];
+                req->length = prm->max_psize;
+                req->complete = agdev_iso_complete;
+                req->buf = prm->rbuf + i * req->length;
+
+                if (usb_ep_queue(ep, req, GFP_ATOMIC))
+                        dev_err(&uac2->pdev.dev, "%d Error!\n", __LINE__);
+        }
+
+        return 0;
+}
+
+static int
+afunc_get_alt(struct usb_function *fn, unsigned intf)
+{
+        struct audio_dev *agdev = func_to_agdev(fn);
+        struct snd_uac2_chip *uac2 = &agdev->uac2;
+
+        if (intf == INTF_GET(agdev->ac_alt))
+                return ALT_GET(agdev->ac_alt);
+        else if (intf == INTF_GET(agdev->as_out_alt))
+                return ALT_GET(agdev->as_out_alt);
+        else if (intf == INTF_GET(agdev->as_in_alt))
+                return ALT_GET(agdev->as_in_alt);
+        else
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Invalid Interface %d!\n",
+                        __func__, __LINE__, intf);
+
+        return -EINVAL;
+}
+
+static void
+afunc_disable(struct usb_function *fn)
+{
+        struct audio_dev *agdev = func_to_agdev(fn);
+        struct snd_uac2_chip *uac2 = &agdev->uac2;
+
+        free_ep(&uac2->p_prm, agdev->in_ep);
+        ALT_SET(agdev->as_in_alt, 0);
+
+        free_ep(&uac2->c_prm, agdev->out_ep);
+        ALT_SET(agdev->as_out_alt, 0);
+}
+
+static int
+in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
+{
+        struct usb_request *req = fn->config->cdev->req;
+        struct audio_dev *agdev = func_to_agdev(fn);
+        struct snd_uac2_chip *uac2 = &agdev->uac2;
+        u16 w_length = le16_to_cpu(cr->wLength);
+        u16 w_index = le16_to_cpu(cr->wIndex);
+        u16 w_value = le16_to_cpu(cr->wValue);
+        u8 entity_id = (w_index >> 8) & 0xff;
+        u8 control_selector = w_value >> 8;
+        int value = -EOPNOTSUPP;
+
+        if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
+                struct cntrl_cur_lay3 c;
+
+                if (entity_id == USB_IN_CLK_ID)
+                        c.dCUR = p_srate;
+                else if (entity_id == USB_OUT_CLK_ID)
+                        c.dCUR = c_srate;
+
+                value = min_t(unsigned, w_length, sizeof c);
+                memcpy(req->buf, &c, value);
+        } else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) {
+                *(u8 *)req->buf = 1;
+                value = min_t(unsigned, w_length, 1);
+        } else {
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d control_selector=%d TODO!\n",
+                        __func__, __LINE__, control_selector);
+        }
+
+        return value;
+}
+
+static int
+in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
+{
+        struct usb_request *req = fn->config->cdev->req;
+        struct audio_dev *agdev = func_to_agdev(fn);
+        struct snd_uac2_chip *uac2 = &agdev->uac2;
+        u16 w_length = le16_to_cpu(cr->wLength);
+        u16 w_index = le16_to_cpu(cr->wIndex);
+        u16 w_value = le16_to_cpu(cr->wValue);
+        u8 entity_id = (w_index >> 8) & 0xff;
+        u8 control_selector = w_value >> 8;
+        struct cntrl_range_lay3 r;
+        int value = -EOPNOTSUPP;
+
+        if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
+                if (entity_id == USB_IN_CLK_ID)
+                        r.dMIN = p_srate;
+                else if (entity_id == USB_OUT_CLK_ID)
+                        r.dMIN = c_srate;
+                else
+                        return -EOPNOTSUPP;
+
+                r.dMAX = r.dMIN;
+                r.dRES = 0;
+                r.wNumSubRanges = 1;
+
+                value = min_t(unsigned, w_length, sizeof r);
+                memcpy(req->buf, &r, value);
+        } else {
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d control_selector=%d TODO!\n",
+                        __func__, __LINE__, control_selector);
+        }
+
+        return value;
+}
+
+static int
+ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr)
+{
+        if (cr->bRequest == UAC2_CS_CUR)
+                return in_rq_cur(fn, cr);
+        else if (cr->bRequest == UAC2_CS_RANGE)
+                return in_rq_range(fn, cr);
+        else
+                return -EOPNOTSUPP;
+}
+
+static int
+out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
+{
+        u16 w_length = le16_to_cpu(cr->wLength);
+        u16 w_value = le16_to_cpu(cr->wValue);
+        u8 control_selector = w_value >> 8;
+
+        if (control_selector == UAC2_CS_CONTROL_SAM_FREQ)
+                return w_length;
+
+        return -EOPNOTSUPP;
+}
+
+static int
+setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
+{
+        struct audio_dev *agdev = func_to_agdev(fn);
+        struct snd_uac2_chip *uac2 = &agdev->uac2;
+        u16 w_index = le16_to_cpu(cr->wIndex);
+        u8 intf = w_index & 0xff;
+
+        if (intf != INTF_GET(agdev->ac_alt)) {
+                dev_err(&uac2->pdev.dev,
+                        "%s:%d Error!\n", __func__, __LINE__);
+                return -EOPNOTSUPP;
+        }
+
+        if (cr->bRequestType & USB_DIR_IN)
+                return ac_rq_in(fn, cr);
+        else if (cr->bRequest == UAC2_CS_CUR)
+                return out_rq_cur(fn, cr);
+
+        return -EOPNOTSUPP;
+}
+
+static int
+afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
+{
+        struct usb_composite_dev *cdev = fn->config->cdev;
+        struct audio_dev *agdev = func_to_agdev(fn);
+        struct snd_uac2_chip *uac2 = &agdev->uac2;
+        struct usb_request *req = cdev->req;
+        u16 w_length = le16_to_cpu(cr->wLength);
+        int value = -EOPNOTSUPP;
+
+        /* Only Class specific requests are supposed to reach here */
+        if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
+                return -EOPNOTSUPP;
+
+        if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
+                value = setup_rq_inf(fn, cr);
+        else
+                dev_err(&uac2->pdev.dev, "%s:%d Error!\n", __func__, __LINE__);
+
+        if (value >= 0) {
+                req->length = value;
+                req->zero = value < w_length;
+                value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
+                if (value < 0) {
+                        dev_err(&uac2->pdev.dev,
+                                "%s:%d Error!\n", __func__, __LINE__);
+                        req->status = 0;
+                }
+        }
+
+        return value;
+}
+
+static int audio_bind_config(struct usb_configuration *cfg)
+{
+        int id, res;
+
+        agdev_g = kzalloc(sizeof *agdev_g, GFP_KERNEL);
+        if (agdev_g == NULL) {
+                printk(KERN_ERR "Unable to allocate audio gadget\n");
+                return -ENOMEM;
+        }
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_ASSOC].id = id;
+        iad_desc.iFunction = id,
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_IF_CTRL].id = id;
+        std_ac_if_desc.iInterface = id,
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_CLKSRC_IN].id = id;
+        in_clk_src_desc.iClockSource = id,
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_CLKSRC_OUT].id = id;
+        out_clk_src_desc.iClockSource = id,
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_USB_IT].id = id;
+        usb_out_it_desc.iTerminal = id,
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_IO_IT].id = id;
+        io_in_it_desc.iTerminal = id;
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_USB_OT].id = id;
+        usb_in_ot_desc.iTerminal = id;
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_IO_OT].id = id;
+        io_out_ot_desc.iTerminal = id;
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_AS_OUT_ALT0].id = id;
+        std_as_out_if0_desc.iInterface = id;
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_AS_OUT_ALT1].id = id;
+        std_as_out_if1_desc.iInterface = id;
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_AS_IN_ALT0].id = id;
+        std_as_in_if0_desc.iInterface = id;
+
+        id = usb_string_id(cfg->cdev);
+        if (id < 0)
+                return id;
+
+        strings_fn[STR_AS_IN_ALT1].id = id;
+        std_as_in_if1_desc.iInterface = id;
+
+        agdev_g->func.name = "uac2_func";
+        agdev_g->func.strings = fn_strings;
+        agdev_g->func.bind = afunc_bind;
+        agdev_g->func.unbind = afunc_unbind;
+        agdev_g->func.set_alt = afunc_set_alt;
+        agdev_g->func.get_alt = afunc_get_alt;
+        agdev_g->func.disable = afunc_disable;
+        agdev_g->func.setup = afunc_setup;
+
+        /* Initialize the configurable parameters */
+        usb_out_it_desc.bNrChannels = num_channels(c_chmask);
+        usb_out_it_desc.bmChannelConfig = cpu_to_le32(c_chmask);
+        io_in_it_desc.bNrChannels = num_channels(p_chmask);
+        io_in_it_desc.bmChannelConfig = cpu_to_le32(p_chmask);
+        as_out_hdr_desc.bNrChannels = num_channels(c_chmask);
+        as_out_hdr_desc.bmChannelConfig = cpu_to_le32(c_chmask);
+        as_in_hdr_desc.bNrChannels = num_channels(p_chmask);
+        as_in_hdr_desc.bmChannelConfig = cpu_to_le32(p_chmask);
+        as_out_fmt1_desc.bSubslotSize = c_ssize;
+        as_out_fmt1_desc.bBitResolution = c_ssize * 8;
+        as_in_fmt1_desc.bSubslotSize = p_ssize;
+        as_in_fmt1_desc.bBitResolution = p_ssize * 8;
+
+        snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", p_srate);
+        snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", c_srate);
+
+        res = usb_add_function(cfg, &agdev_g->func);
+        if (res < 0)
+                kfree(agdev_g);
+
+        return res;
+}
+
+static void
+uac2_unbind_config(struct usb_configuration *cfg)
+{
+        kfree(agdev_g);
+        agdev_g = NULL;
+}
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 47766f0e7caa..4fac56927741 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -855,7 +855,7 @@ static int class_setup_req(struct fsg_dev *fsg,
         if (transport_is_bbb()) {
                 switch (ctrl->bRequest) {
 
-                case USB_BULK_RESET_REQUEST:
+                case US_BULK_RESET_REQUEST:
                         if (ctrl->bRequestType != (USB_DIR_OUT |
                                         USB_TYPE_CLASS | USB_RECIP_INTERFACE))
                                 break;
@@ -871,7 +871,7 @@ static int class_setup_req(struct fsg_dev *fsg,
                         value = DELAYED_STATUS;
                         break;
 
-                case USB_BULK_GET_MAX_LUN_REQUEST:
+                case US_BULK_GET_MAX_LUN:
                         if (ctrl->bRequestType != (USB_DIR_IN |
                                         USB_TYPE_CLASS | USB_RECIP_INTERFACE))
                                 break;
@@ -2125,7 +2125,7 @@ static int send_status(struct fsg_dev *fsg)
         struct fsg_lun          *curlun = fsg->curlun;
         struct fsg_buffhd       *bh;
         int                     rc;
-        u8                      status = USB_STATUS_PASS;
+        u8                      status = US_BULK_STAT_OK;
         u32                     sd, sdinfo = 0;
 
         /* Wait for the next buffer to become available */
@@ -2146,11 +2146,11 @@ static int send_status(struct fsg_dev *fsg)
 
         if (fsg->phase_error) {
                 DBG(fsg, "sending phase-error status\n");
-                status = USB_STATUS_PHASE_ERROR;
+                status = US_BULK_STAT_PHASE;
                 sd = SS_INVALID_COMMAND;
         } else if (sd != SS_NO_SENSE) {
                 DBG(fsg, "sending command-failure status\n");
-                status = USB_STATUS_FAIL;
+                status = US_BULK_STAT_FAIL;
                 VDBG(fsg, "  sense data: SK x%02x, ASC x%02x, ASCQ x%02x;"
                                 "  info x%x\n",
                                 SK(sd), ASC(sd), ASCQ(sd), sdinfo);
@@ -2160,12 +2160,12 @@ static int send_status(struct fsg_dev *fsg)
                 struct bulk_cs_wrap     *csw = bh->buf;
 
                 /* Store and send the Bulk-only CSW */
-                csw->Signature = cpu_to_le32(USB_BULK_CS_SIG);
+                csw->Signature = cpu_to_le32(US_BULK_CS_SIGN);
                 csw->Tag = fsg->tag;
                 csw->Residue = cpu_to_le32(fsg->residue);
                 csw->Status = status;
 
-                bh->inreq->length = USB_BULK_CS_WRAP_LEN;
+                bh->inreq->length = US_BULK_CS_WRAP_LEN;
                 bh->inreq->zero = 0;
                 start_transfer(fsg, fsg->bulk_in, bh->inreq,
                                 &bh->inreq_busy, &bh->state);
@@ -2609,16 +2609,16 @@ static int do_scsi_command(struct fsg_dev *fsg)
 static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
         struct usb_request              *req = bh->outreq;
-        struct fsg_bulk_cb_wrap *cbw = req->buf;
+        struct bulk_cb_wrap     *cbw = req->buf;
 
         /* Was this a real packet?  Should it be ignored? */
         if (req->status || test_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags))
                 return -EINVAL;
 
         /* Is the CBW valid? */
-        if (req->actual != USB_BULK_CB_WRAP_LEN ||
+        if (req->actual != US_BULK_CB_WRAP_LEN ||
                         cbw->Signature != cpu_to_le32(
-                                USB_BULK_CB_SIG)) {
+                                US_BULK_CB_SIGN)) {
                 DBG(fsg, "invalid CBW: len %u sig 0x%x\n",
                                 req->actual,
                                 le32_to_cpu(cbw->Signature));
@@ -2638,7 +2638,7 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
         }
 
         /* Is the CBW meaningful? */
-        if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG ||
+        if (cbw->Lun >= FSG_MAX_LUNS || cbw->Flags & ~US_BULK_FLAG_IN ||
                         cbw->Length <= 0 || cbw->Length > MAX_COMMAND_SIZE) {
                 DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
                                 "cmdlen %u\n",
@@ -2656,7 +2656,7 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
         /* Save the command for later */
         fsg->cmnd_size = cbw->Length;
         memcpy(fsg->cmnd, cbw->CDB, fsg->cmnd_size);
-        if (cbw->Flags & USB_BULK_IN_FLAG)
+        if (cbw->Flags & US_BULK_FLAG_IN)
                 fsg->data_dir = DATA_DIR_TO_HOST;
         else
                 fsg->data_dir = DATA_DIR_FROM_HOST;
@@ -2685,7 +2685,7 @@ static int get_next_command(struct fsg_dev *fsg)
                 }
 
                 /* Queue a request to read a Bulk-only CBW */
-                set_bulk_out_req_length(fsg, bh, USB_BULK_CB_WRAP_LEN);
+                set_bulk_out_req_length(fsg, bh, US_BULK_CB_WRAP_LEN);
                 start_transfer(fsg, fsg->bulk_out, bh->outreq,
                                 &bh->outreq_busy, &bh->state);
 
diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index b95697c03d07..877a2c46672b 100644
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -1638,6 +1638,7 @@ static int qe_ep_disable(struct usb_ep *_ep)
         /* Nuke all pending requests (does flush) */
         nuke(ep, -ESHUTDOWN);
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         ep->stopped = 1;
         ep->tx_req = NULL;
         qe_ep_reset(udc, ep->epnum);
diff --git a/drivers/usb/gadget/fsl_udc_core.c b/drivers/usb/gadget/fsl_udc_core.c
index b04712f19f1e..5f94e79cd6b9 100644
--- a/drivers/usb/gadget/fsl_udc_core.c
+++ b/drivers/usb/gadget/fsl_udc_core.c
@@ -43,7 +43,6 @@
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
-#include <asm/system.h>
 #include <asm/unaligned.h>
 #include <asm/dma.h>
 
@@ -659,6 +658,7 @@ static int fsl_ep_disable(struct usb_ep *_ep)
         nuke(ep, -ESHUTDOWN);
 
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         ep->stopped = 1;
         spin_unlock_irqrestore(&udc->lock, flags);
 
@@ -768,7 +768,7 @@ static void fsl_queue_td(struct fsl_ep *ep, struct fsl_req *req)
  * @is_last: return flag if it is the last dTD of the request
  * return: pointer to the built dTD */
 static struct ep_td_struct *fsl_build_dtd(struct fsl_req *req, unsigned *length,
-                dma_addr_t *dma, int *is_last)
+                dma_addr_t *dma, int *is_last, gfp_t gfp_flags)
 {
         u32 swap_temp;
         struct ep_td_struct *dtd;
@@ -777,7 +777,7 @@ static struct ep_td_struct *fsl_build_dtd(struct fsl_req *req, unsigned *length,
         *length = min(req->req.length - req->req.actual,
                         (unsigned)EP_MAX_LENGTH_TRANSFER);
 
-        dtd = dma_pool_alloc(udc_controller->td_pool, GFP_KERNEL, dma);
+        dtd = dma_pool_alloc(udc_controller->td_pool, gfp_flags, dma);
         if (dtd == NULL)
                 return dtd;
 
@@ -827,7 +827,7 @@ static struct ep_td_struct *fsl_build_dtd(struct fsl_req *req, unsigned *length,
 }
 
 /* Generate dtd chain for a request */
-static int fsl_req_to_dtd(struct fsl_req *req)
+static int fsl_req_to_dtd(struct fsl_req *req, gfp_t gfp_flags)
 {
         unsigned        count;
         int             is_last;
@@ -836,7 +836,7 @@ static int fsl_req_to_dtd(struct fsl_req *req)
         dma_addr_t dma;
 
         do {
-                dtd = fsl_build_dtd(req, &count, &dma, &is_last);
+                dtd = fsl_build_dtd(req, &count, &dma, &is_last, gfp_flags);
                 if (dtd == NULL)
                         return -ENOMEM;
 
@@ -910,13 +910,11 @@ fsl_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
         req->req.actual = 0;
         req->dtd_count = 0;
 
-        spin_lock_irqsave(&udc->lock, flags);
-
         /* build dtds and push them to device queue */
-        if (!fsl_req_to_dtd(req)) {
+        if (!fsl_req_to_dtd(req, gfp_flags)) {
+                spin_lock_irqsave(&udc->lock, flags);
                 fsl_queue_td(ep, req);
         } else {
-                spin_unlock_irqrestore(&udc->lock, flags);
                 return -ENOMEM;
         }
 
@@ -1217,7 +1215,7 @@ static int fsl_vbus_draw(struct usb_gadget *gadget, unsigned mA)
 
         udc = container_of(gadget, struct fsl_udc, gadget);
         if (udc->transceiver)
-                return otg_set_power(udc->transceiver, mA);
+                return usb_phy_set_power(udc->transceiver, mA);
         return -ENOTSUPP;
 }
 
@@ -1295,7 +1293,7 @@ static int ep0_prime_status(struct fsl_udc *udc, int direction)
                         ep_is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
         req->mapped = 1;
 
-        if (fsl_req_to_dtd(req) == 0)
+        if (fsl_req_to_dtd(req, GFP_ATOMIC) == 0)
                 fsl_queue_td(ep, req);
         else
                 return -ENOMEM;
@@ -1379,7 +1377,7 @@ static void ch9getstatus(struct fsl_udc *udc, u8 request_type, u16 value,
         req->mapped = 1;
 
         /* prime the data phase */
-        if ((fsl_req_to_dtd(req) == 0))
+        if ((fsl_req_to_dtd(req, GFP_ATOMIC) == 0))
                 fsl_queue_td(ep, req);
         else                    /* no mem */
                 goto stall;
@@ -1966,7 +1964,8 @@ static int fsl_start(struct usb_gadget_driver *driver,
 
                 /* connect to bus through transceiver */
                 if (udc_controller->transceiver) {
-                        retval = otg_set_peripheral(udc_controller->transceiver,
+                        retval = otg_set_peripheral(
+                                        udc_controller->transceiver->otg,
                                                     &udc_controller->gadget);
                         if (retval < 0) {
                                 ERR("can't bind to transceiver\n");
@@ -2006,7 +2005,7 @@ static int fsl_stop(struct usb_gadget_driver *driver)
                 return -EINVAL;
 
         if (udc_controller->transceiver)
-                otg_set_peripheral(udc_controller->transceiver, NULL);
+                otg_set_peripheral(udc_controller->transceiver->otg, NULL);
 
         /* stop DR, disable intr */
         dr_controller_stop(udc_controller);
@@ -2430,7 +2429,7 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
 
 #ifdef CONFIG_USB_OTG
         if (pdata->operating_mode == FSL_USB2_DR_OTG) {
-                udc_controller->transceiver = otg_get_transceiver();
+                udc_controller->transceiver = usb_get_transceiver();
                 if (!udc_controller->transceiver) {
                         ERR("Can't find OTG driver!\n");
                         ret = -ENODEV;
diff --git a/drivers/usb/gadget/fsl_usb2_udc.h b/drivers/usb/gadget/fsl_usb2_udc.h
index f781f5dec417..e651469fd39b 100644
--- a/drivers/usb/gadget/fsl_usb2_udc.h
+++ b/drivers/usb/gadget/fsl_usb2_udc.h
@@ -471,7 +471,7 @@ struct fsl_udc {
 
         struct usb_ctrlrequest local_setup_buff;
         spinlock_t lock;
-        struct otg_transceiver *transceiver;
+        struct usb_phy *transceiver;
         unsigned softconnect:1;
         unsigned vbus_active:1;
         unsigned stopped:1;
diff --git a/drivers/usb/gadget/g_ffs.c b/drivers/usb/gadget/g_ffs.c
index 0519d77915ec..331cd6729d3c 100644
--- a/drivers/usb/gadget/g_ffs.c
+++ b/drivers/usb/gadget/g_ffs.c
@@ -2,7 +2,7 @@
  * g_ffs.c -- user mode file system API for USB composite function controllers
  *
  * Copyright (C) 2010 Samsung Electronics
- * Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
+ * Author: Michal Nazarewicz <mina86@mina86.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
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 5af70fcce139..e151d6b87dee 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -43,7 +43,6 @@
 #include <asm/byteorder.h>
 #include <asm/io.h>
 #include <asm/irq.h>
-#include <asm/system.h>
 #include <asm/unaligned.h>
 
 
@@ -235,6 +234,7 @@ static void ep_reset(struct goku_udc_regs __iomem *regs, struct goku_ep *ep)
 
         ep->ep.maxpacket = MAX_FIFO_SIZE;
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         ep->stopped = 1;
         ep->irqs = 0;
         ep->dma = 0;
@@ -310,12 +310,9 @@ done(struct goku_ep *ep, struct goku_request *req, int status)
                 status = req->req.status;
 
         dev = ep->dev;
-        if (req->mapped) {
-                pci_unmap_single(dev->pdev, req->req.dma, req->req.length,
-                        ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-                req->req.dma = DMA_ADDR_INVALID;
-                req->mapped = 0;
-        }
+
+        if (ep->dma)
+                usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
 
 #ifndef USB_TRACE
         if (status && status != -ESHUTDOWN)
@@ -736,10 +733,11 @@ goku_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
                 return -EBUSY;
 
         /* set up dma mapping in case the caller didn't */
-        if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
-                _req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
-                        ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-                req->mapped = 1;
+        if (ep->dma) {
+                status = usb_gadget_map_request(&dev->gadget, &req->req,
+                                ep->is_in);
+                if (status)
+                        return status;
         }
 
 #ifdef USB_TRACE
diff --git a/drivers/usb/gadget/hid.c b/drivers/usb/gadget/hid.c
index f888c3ede860..3493adf064f5 100644
--- a/drivers/usb/gadget/hid.c
+++ b/drivers/usb/gadget/hid.c
@@ -60,9 +60,9 @@ static struct usb_device_descriptor device_desc = {
         /* .bDeviceClass =              USB_CLASS_COMM, */
         /* .bDeviceSubClass =   0, */
         /* .bDeviceProtocol =   0, */
-        .bDeviceClass =         0xEF,
-        .bDeviceSubClass =      2,
-        .bDeviceProtocol =      1,
+        .bDeviceClass =         USB_CLASS_PER_INTERFACE,
+        .bDeviceSubClass =      0,
+        .bDeviceProtocol =      0,
         /* .bMaxPacketSize0 = f(hardware) */
 
         /* Vendor and product id can be overridden by module parameters.  */
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index ae04266dba1b..8793f32bab11 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -1043,6 +1043,8 @@ ep0_read (struct file *fd, char __user *buf, size_t len, loff_t *ptr)
 // FIXME don't call this with the spinlock held ...
                                 if (copy_to_user (buf, dev->req->buf, len))
                                         retval = -EFAULT;
+                                else
+                                        retval = len;
                                 clean_req (dev->gadget->ep0, dev->req);
                                 /* NOTE userspace can't yet choose to stall */
                         }
@@ -1569,20 +1571,18 @@ delegate:
 
 static void destroy_ep_files (struct dev_data *dev)
 {
-        struct list_head        *entry, *tmp;
-
         DBG (dev, "%s %d\n", __func__, dev->state);
 
         /* dev->state must prevent interference */
 restart:
         spin_lock_irq (&dev->lock);
-        list_for_each_safe (entry, tmp, &dev->epfiles) {
+        while (!list_empty(&dev->epfiles)) {
                 struct ep_data  *ep;
                 struct inode    *parent;
                 struct dentry   *dentry;
 
                 /* break link to FS */
-                ep = list_entry (entry, struct ep_data, epfiles);
+                ep = list_first_entry (&dev->epfiles, struct ep_data, epfiles);
                 list_del_init (&ep->epfiles);
                 dentry = ep->dentry;
                 ep->dentry = NULL;
@@ -1605,8 +1605,7 @@ restart:
                 dput (dentry);
                 mutex_unlock (&parent->i_mutex);
 
-                /* fds may still be open */
-                goto restart;
+                spin_lock_irq (&dev->lock);
         }
         spin_unlock_irq (&dev->lock);
 }
@@ -2059,10 +2058,8 @@ gadgetfs_fill_super (struct super_block *sb, void *opts, int silent)
         if (!inode)
                 goto Enomem;
         inode->i_op = &simple_dir_inode_operations;
-        if (!(sb->s_root = d_alloc_root (inode))) {
-                iput(inode);
+        if (!(sb->s_root = d_make_root (inode)))
                 goto Enomem;
-        }
 
         /* the ep0 file is named after the controller we expect;
          * user mode code can use it for sanity checks, like we do.
diff --git a/drivers/usb/gadget/langwell_udc.c b/drivers/usb/gadget/langwell_udc.c
index e2293c1588ee..f9cedd52cf20 100644
--- a/drivers/usb/gadget/langwell_udc.c
+++ b/drivers/usb/gadget/langwell_udc.c
@@ -32,7 +32,6 @@
 #include <linux/pm.h>
 #include <linux/io.h>
 #include <linux/irq.h>
-#include <asm/system.h>
 #include <asm/unaligned.h>
 
 #include "langwell_udc.h"
@@ -401,16 +400,7 @@ static void done(struct langwell_ep *ep, struct langwell_request *req,
                 dma_pool_free(dev->dtd_pool, curr_dtd, curr_dtd->dtd_dma);
         }
 
-        if (req->mapped) {
-                dma_unmap_single(&dev->pdev->dev,
-                        req->req.dma, req->req.length,
-                        is_in(ep) ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-                req->req.dma = DMA_ADDR_INVALID;
-                req->mapped = 0;
-        } else
-                dma_sync_single_for_cpu(&dev->pdev->dev, req->req.dma,
-                                req->req.length,
-                                is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+        usb_gadget_unmap_request(&dev->gadget, &req->req, is_in(ep));
 
         if (status != -ESHUTDOWN)
                 dev_dbg(&dev->pdev->dev,
@@ -487,6 +477,7 @@ static int langwell_ep_disable(struct usb_ep *_ep)
         nuke(ep, -ESHUTDOWN);
 
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         ep->stopped = 1;
 
         spin_unlock_irqrestore(&dev->lock, flags);
@@ -749,7 +740,8 @@ static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
         struct langwell_ep      *ep;
         struct langwell_udc     *dev;
         unsigned long           flags;
-        int                     is_iso = 0, zlflag = 0;
+        int                     is_iso = 0;
+        int                     ret;
 
         /* always require a cpu-view buffer */
         req = container_of(_req, struct langwell_request, req);
@@ -776,33 +768,10 @@ static int langwell_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
         if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN))
                 return -ESHUTDOWN;
 
-        /* set up dma mapping in case the caller didn't */
-        if (_req->dma == DMA_ADDR_INVALID) {
-                /* WORKAROUND: WARN_ON(size == 0) */
-                if (_req->length == 0) {
-                        dev_vdbg(&dev->pdev->dev, "req->length: 0->1\n");
-                        zlflag = 1;
-                        _req->length++;
-                }
-
-                _req->dma = dma_map_single(&dev->pdev->dev,
-                                _req->buf, _req->length,
-                                is_in(ep) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-                if (zlflag && (_req->length == 1)) {
-                        dev_vdbg(&dev->pdev->dev, "req->length: 1->0\n");
-                        zlflag = 0;
-                        _req->length = 0;
-                }
-
-                req->mapped = 1;
-                dev_vdbg(&dev->pdev->dev, "req->mapped = 1\n");
-        } else {
-                dma_sync_single_for_device(&dev->pdev->dev,
-                                _req->dma, _req->length,
-                                is_in(ep) ?  DMA_TO_DEVICE : DMA_FROM_DEVICE);
-                req->mapped = 0;
-                dev_vdbg(&dev->pdev->dev, "req->mapped = 0\n");
-        }
+        /* set up dma mapping */
+        ret = usb_gadget_map_request(&dev->gadget, &req->req, is_in(ep));
+        if (ret)
+                return ret;
 
         dev_dbg(&dev->pdev->dev,
                         "%s queue req %p, len %u, buf %p, dma 0x%08x\n",
@@ -1261,9 +1230,9 @@ static int langwell_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
         dev_vdbg(&dev->pdev->dev, "---> %s()\n", __func__);
 
         if (dev->transceiver) {
-                dev_vdbg(&dev->pdev->dev, "otg_set_power\n");
+                dev_vdbg(&dev->pdev->dev, "usb_phy_set_power\n");
                 dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
-                return otg_set_power(dev->transceiver, mA);
+                return usb_phy_set_power(dev->transceiver, mA);
         }
 
         dev_vdbg(&dev->pdev->dev, "<--- %s()\n", __func__);
@@ -1906,7 +1875,7 @@ static int langwell_stop(struct usb_gadget *g,
 
         /* unbind OTG transceiver */
         if (dev->transceiver)
-                (void)otg_set_peripheral(dev->transceiver, 0);
+                (void)otg_set_peripheral(dev->transceiver->otg, 0);
 
         /* disable interrupt and set controller to stop state */
         langwell_udc_stop(dev);
diff --git a/drivers/usb/gadget/langwell_udc.h b/drivers/usb/gadget/langwell_udc.h
index d6e78accaffe..8c8087abb481 100644
--- a/drivers/usb/gadget/langwell_udc.h
+++ b/drivers/usb/gadget/langwell_udc.h
@@ -162,7 +162,7 @@ struct langwell_udc {
         spinlock_t              lock;   /* device lock */
         struct langwell_ep      *ep;
         struct usb_gadget_driver        *driver;
-        struct otg_transceiver  *transceiver;
+        struct usb_phy          *transceiver;
         u8                      dev_addr;
         u32                     usb_state;
         u32                     resume_state;
diff --git a/drivers/usb/gadget/mass_storage.c b/drivers/usb/gadget/mass_storage.c
index e24f72f82a47..1f376eba31f6 100644
--- a/drivers/usb/gadget/mass_storage.c
+++ b/drivers/usb/gadget/mass_storage.c
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 2003-2008 Alan Stern
  * Copyright (C) 2009 Samsung Electronics
- *                    Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
+ *                    Author: Michal Nazarewicz <mina86@mina86.com>
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
diff --git a/drivers/usb/gadget/multi.c b/drivers/usb/gadget/multi.c
index 7e7f515b8b19..c37fb33a3d1b 100644
--- a/drivers/usb/gadget/multi.c
+++ b/drivers/usb/gadget/multi.c
@@ -4,7 +4,7 @@
  * Copyright (C) 2008 David Brownell
  * Copyright (C) 2008 Nokia Corporation
  * Copyright (C) 2009 Samsung Electronics
- * Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
+ * Author: Michal Nazarewicz (mina86@mina86.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
diff --git a/drivers/usb/gadget/mv_udc.h b/drivers/usb/gadget/mv_udc.h
index 34aadfae723d..e2be9519abbe 100644
--- a/drivers/usb/gadget/mv_udc.h
+++ b/drivers/usb/gadget/mv_udc.h
@@ -217,7 +217,7 @@ struct mv_udc {
         struct work_struct      vbus_work;
         struct workqueue_struct *qwork;
 
-        struct otg_transceiver  *transceiver;
+        struct usb_phy          *transceiver;
 
         struct mv_usb_platform_data     *pdata;
 
diff --git a/drivers/usb/gadget/mv_udc_core.c b/drivers/usb/gadget/mv_udc_core.c
index f97e737d26f7..a73cf406e2a4 100644
--- a/drivers/usb/gadget/mv_udc_core.c
+++ b/drivers/usb/gadget/mv_udc_core.c
@@ -34,7 +34,6 @@
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <linux/platform_data/mv_usb.h>
-#include <asm/system.h>
 #include <asm/unaligned.h>
 
 #include "mv_udc.h"
@@ -608,6 +607,7 @@ static int  mv_ep_disable(struct usb_ep *_ep)
         nuke(ep, -ESHUTDOWN);
 
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         ep->stopped = 1;
 
         spin_unlock_irqrestore(&udc->lock, flags);
@@ -771,8 +771,7 @@ mv_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
                 udc->ep0_state = DATA_STATE_XMIT;
 
         /* irq handler advances the queue */
-        if (req != NULL)
-                list_add_tail(&req->queue, &ep->queue);
+        list_add_tail(&req->queue, &ep->queue);
         spin_unlock_irqrestore(&udc->lock, flags);
 
         return 0;
@@ -1384,7 +1383,8 @@ static int mv_udc_start(struct usb_gadget_driver *driver,
         }
 
         if (udc->transceiver) {
-                retval = otg_set_peripheral(udc->transceiver, &udc->gadget);
+                retval = otg_set_peripheral(udc->transceiver->otg,
+                                        &udc->gadget);
                 if (retval) {
                         dev_err(&udc->dev->dev,
                                 "unable to register peripheral to otg\n");
@@ -2181,7 +2181,7 @@ static int __devinit mv_udc_probe(struct platform_device *dev)
 
 #ifdef CONFIG_USB_OTG_UTILS
         if (pdata->mode == MV_USB_MODE_OTG)
-                udc->transceiver = otg_get_transceiver();
+                udc->transceiver = usb_get_transceiver();
 #endif
 
         udc->clknum = pdata->clknum;
diff --git a/drivers/usb/gadget/net2272.c b/drivers/usb/gadget/net2272.c
index 7322d293213e..43ac7482fa91 100644
--- a/drivers/usb/gadget/net2272.c
+++ b/drivers/usb/gadget/net2272.c
@@ -42,7 +42,6 @@
 #include <linux/usb/gadget.h>
 
 #include <asm/byteorder.h>
-#include <asm/system.h>
 #include <asm/unaligned.h>
 
 #include "net2272.h"
@@ -385,12 +384,9 @@ net2272_done(struct net2272_ep *ep, struct net2272_request *req, int status)
                 status = req->req.status;
 
         dev = ep->dev;
-        if (use_dma && req->mapped) {
-                dma_unmap_single(dev->dev, req->req.dma, req->req.length,
-                        ep->is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-                req->req.dma = DMA_ADDR_INVALID;
-                req->mapped = 0;
-        }
+        if (use_dma && ep->dma)
+                usb_gadget_unmap_request(&dev->gadget, &req->req,
+                                ep->is_in);
 
         if (status && status != -ESHUTDOWN)
                 dev_vdbg(dev->dev, "complete %s req %p stat %d len %u/%u buf %p\n",
@@ -850,10 +846,11 @@ net2272_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
                 return -ESHUTDOWN;
 
         /* set up dma mapping in case the caller didn't */
-        if (use_dma && ep->dma && _req->dma == DMA_ADDR_INVALID) {
-                _req->dma = dma_map_single(dev->dev, _req->buf, _req->length,
-                        ep->is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-                req->mapped = 1;
+        if (use_dma && ep->dma) {
+                status = usb_gadget_map_request(&dev->gadget, _req,
+                                ep->is_in);
+                if (status)
+                        return status;
         }
 
         dev_vdbg(dev->dev, "%s queue req %p, len %d buf %p dma %08llx %s\n",
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index cdedd1336745..ac335af154ba 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -59,7 +59,6 @@
 #include <asm/byteorder.h>
 #include <asm/io.h>
 #include <asm/irq.h>
-#include <asm/system.h>
 #include <asm/unaligned.h>
 
 
@@ -806,12 +805,8 @@ done (struct net2280_ep *ep, struct net2280_request *req, int status)
                 status = req->req.status;
 
         dev = ep->dev;
-        if (req->mapped) {
-                pci_unmap_single (dev->pdev, req->req.dma, req->req.length,
-                        ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-                req->req.dma = DMA_ADDR_INVALID;
-                req->mapped = 0;
-        }
+        if (ep->dma)
+                usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
 
         if (status && status != -ESHUTDOWN)
                 VDEBUG (dev, "complete %s req %p stat %d len %u/%u\n",
@@ -857,10 +852,13 @@ net2280_queue (struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
                 return -EOPNOTSUPP;
 
         /* set up dma mapping in case the caller didn't */
-        if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
-                _req->dma = pci_map_single (dev->pdev, _req->buf, _req->length,
-                        ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
-                req->mapped = 1;
+        if (ep->dma) {
+                int ret;
+
+                ret = usb_gadget_map_request(&dev->gadget, _req,
+                                ep->is_in);
+                if (ret)
+                        return ret;
         }
 
 #if 0
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index 576cd8578b45..3b4b6dd0f95a 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -40,7 +40,6 @@
 #include <asm/byteorder.h>
 #include <asm/io.h>
 #include <asm/irq.h>
-#include <asm/system.h>
 #include <asm/unaligned.h>
 #include <asm/mach-types.h>
 
@@ -251,6 +250,7 @@ static int omap_ep_disable(struct usb_ep *_ep)
 
         spin_lock_irqsave(&ep->udc->lock, flags);
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         nuke (ep, -ESHUTDOWN);
         ep->ep.maxpacket = ep->maxpacket;
         ep->has_dma = 0;
@@ -1213,7 +1213,7 @@ static int omap_wakeup(struct usb_gadget *gadget)
         /* NOTE:  non-OTG systems may use SRP TOO... */
         } else if (!(udc->devstat & UDC_ATT)) {
                 if (udc->transceiver)
-                        retval = otg_start_srp(udc->transceiver);
+                        retval = otg_start_srp(udc->transceiver->otg);
         }
         spin_unlock_irqrestore(&udc->lock, flags);
 
@@ -1345,7 +1345,7 @@ static int omap_vbus_draw(struct usb_gadget *gadget, unsigned mA)
 
         udc = container_of(gadget, struct omap_udc, gadget);
         if (udc->transceiver)
-                return otg_set_power(udc->transceiver, mA);
+                return usb_phy_set_power(udc->transceiver, mA);
         return -EOPNOTSUPP;
 }
 
@@ -1839,11 +1839,13 @@ static void devstate_irq(struct omap_udc *udc, u16 irq_src)
                                         spin_lock(&udc->lock);
                                 }
                                 if (udc->transceiver)
-                                        otg_set_suspend(udc->transceiver, 1);
+                                        usb_phy_set_suspend(
+                                                        udc->transceiver, 1);
                         } else {
                                 VDBG("resume\n");
                                 if (udc->transceiver)
-                                        otg_set_suspend(udc->transceiver, 0);
+                                        usb_phy_set_suspend(
+                                                        udc->transceiver, 0);
                                 if (udc->gadget.speed == USB_SPEED_FULL
                                                 && udc->driver->resume) {
                                         spin_unlock(&udc->lock);
@@ -2154,7 +2156,8 @@ static int omap_udc_start(struct usb_gadget_driver *driver,
 
         /* connect to bus through transceiver */
         if (udc->transceiver) {
-                status = otg_set_peripheral(udc->transceiver, &udc->gadget);
+                status = otg_set_peripheral(udc->transceiver->otg,
+                                                &udc->gadget);
                 if (status < 0) {
                         ERR("can't bind to transceiver\n");
                         if (driver->unbind) {
@@ -2200,7 +2203,7 @@ static int omap_udc_stop(struct usb_gadget_driver *driver)
                 omap_vbus_session(&udc->gadget, 0);
 
         if (udc->transceiver)
-                (void) otg_set_peripheral(udc->transceiver, NULL);
+                (void) otg_set_peripheral(udc->transceiver->otg, NULL);
         else
                 pullup_disable(udc);
 
@@ -2650,7 +2653,7 @@ static void omap_udc_release(struct device *dev)
 }
 
 static int __init
-omap_udc_setup(struct platform_device *odev, struct otg_transceiver *xceiv)
+omap_udc_setup(struct platform_device *odev, struct usb_phy *xceiv)
 {
         unsigned        tmp, buf;
 
@@ -2790,7 +2793,7 @@ static int __init omap_udc_probe(struct platform_device *pdev)
 {
         int                     status = -ENODEV;
         int                     hmc;
-        struct otg_transceiver  *xceiv = NULL;
+        struct usb_phy          *xceiv = NULL;
         const char              *type = NULL;
         struct omap_usb_config  *config = pdev->dev.platform_data;
         struct clk              *dc_clk;
@@ -2863,7 +2866,7 @@ static int __init omap_udc_probe(struct platform_device *pdev)
                  * use it.  Except for OTG, we don't _need_ to talk to one;
                  * but not having one probably means no VBUS detection.
                  */
-                xceiv = otg_get_transceiver();
+                xceiv = usb_get_transceiver();
                 if (xceiv)
                         type = xceiv->label;
                 else if (config->otg) {
@@ -3009,7 +3012,7 @@ cleanup1:
 
 cleanup0:
         if (xceiv)
-                otg_put_transceiver(xceiv);
+                usb_put_transceiver(xceiv);
 
         if (cpu_is_omap16xx() || cpu_is_omap24xx() || cpu_is_omap7xx()) {
                 clk_disable(hhc_clk);
@@ -3039,7 +3042,7 @@ static int __exit omap_udc_remove(struct platform_device *pdev)
 
         pullup_disable(udc);
         if (udc->transceiver) {
-                otg_put_transceiver(udc->transceiver);
+                usb_put_transceiver(udc->transceiver);
                 udc->transceiver = NULL;
         }
         omap_writew(0, UDC_SYSCON1);
diff --git a/drivers/usb/gadget/omap_udc.h b/drivers/usb/gadget/omap_udc.h
index 29edc51b6b22..59d3b2213cb1 100644
--- a/drivers/usb/gadget/omap_udc.h
+++ b/drivers/usb/gadget/omap_udc.h
@@ -164,7 +164,7 @@ struct omap_udc {
         struct omap_ep                  ep[32];
         u16                             devstat;
         u16                             clr_halt;
-        struct otg_transceiver          *transceiver;
+        struct usb_phy                  *transceiver;
         struct list_head                iso;
         unsigned                        softconnect:1;
         unsigned                        vbus_active:1;
diff --git a/drivers/usb/gadget/pch_udc.c b/drivers/usb/gadget/pch_udc.c
index a3fcaae4bc2a..65307064a6fd 100644
--- a/drivers/usb/gadget/pch_udc.c
+++ b/drivers/usb/gadget/pch_udc.c
@@ -15,6 +15,14 @@
 #include <linux/interrupt.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/gpio.h>
+#include <linux/irq.h>
+
+/* GPIO port for VBUS detecting */
+static int vbus_gpio_port = -1;         /* GPIO port number (-1:Not used) */
+
+#define PCH_VBUS_PERIOD         3000    /* VBUS polling period (msec) */
+#define PCH_VBUS_INTERVAL       10      /* VBUS polling interval (msec) */
 
 /* Address offset of Registers */
 #define UDC_EP_REG_SHIFT        0x20    /* Offset to next EP */
@@ -296,6 +304,21 @@ struct pch_udc_ep {
 };
 
 /**
+ * struct pch_vbus_gpio_data - Structure holding GPIO informaton
+ *                                      for detecting VBUS
+ * @port:               gpio port number
+ * @intr:               gpio interrupt number
+ * @irq_work_fall       Structure for WorkQueue
+ * @irq_work_rise       Structure for WorkQueue
+ */
+struct pch_vbus_gpio_data {
+        int                     port;
+        int                     intr;
+        struct work_struct      irq_work_fall;
+        struct work_struct      irq_work_rise;
+};
+
+/**
  * struct pch_udc_dev - Structure holding complete information
  *                      of the PCH USB device
  * @gadget:             gadget driver data
@@ -311,6 +334,7 @@ struct pch_udc_ep {
  * @registered:         driver regsitered with system
  * @suspended:          driver in suspended state
  * @connected:          gadget driver associated
+ * @vbus_session:       required vbus_session state
  * @set_cfg_not_acked:  pending acknowledgement 4 setup
  * @waiting_zlp_ack:    pending acknowledgement 4 ZLP
  * @data_requests:      DMA pool for data requests
@@ -322,6 +346,7 @@ struct pch_udc_ep {
  * @base_addr:          for mapped device memory
  * @irq:                IRQ line for the device
  * @cfg_data:           current cfg, intf, and alt in use
+ * @vbus_gpio:          GPIO informaton for detecting VBUS
  */
 struct pch_udc_dev {
         struct usb_gadget               gadget;
@@ -337,6 +362,7 @@ struct pch_udc_dev {
                         registered:1,
                         suspended:1,
                         connected:1,
+                        vbus_session:1,
                         set_cfg_not_acked:1,
                         waiting_zlp_ack:1;
         struct pci_pool         *data_requests;
@@ -347,7 +373,8 @@ struct pch_udc_dev {
         unsigned long                   phys_addr;
         void __iomem                    *base_addr;
         unsigned                        irq;
-        struct pch_udc_cfg_data cfg_data;
+        struct pch_udc_cfg_data         cfg_data;
+        struct pch_vbus_gpio_data       vbus_gpio;
 };
 
 #define PCH_UDC_PCI_BAR                 1
@@ -554,6 +581,29 @@ static void pch_udc_clear_disconnect(struct pch_udc_dev *dev)
 }
 
 /**
+ * pch_udc_reconnect() - This API initializes usb device controller,
+ *                                              and clear the disconnect status.
+ * @dev:                Reference to pch_udc_regs structure
+ */
+static void pch_udc_init(struct pch_udc_dev *dev);
+static void pch_udc_reconnect(struct pch_udc_dev *dev)
+{
+        pch_udc_init(dev);
+
+        /* enable device interrupts */
+        /* pch_udc_enable_interrupts() */
+        pch_udc_bit_clr(dev, UDC_DEVIRQMSK_ADDR,
+                        UDC_DEVINT_UR | UDC_DEVINT_ENUM);
+
+        /* Clear the disconnect */
+        pch_udc_bit_set(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_SD);
+        mdelay(1);
+        /* Resume USB signalling */
+        pch_udc_bit_clr(dev, UDC_DEVCTL_ADDR, UDC_DEVCTL_RES);
+}
+
+/**
  * pch_udc_vbus_session() - set or clearr the disconnect status.
  * @dev:        Reference to pch_udc_regs structure
  * @is_active:  Parameter specifying the action
@@ -563,10 +613,18 @@ static void pch_udc_clear_disconnect(struct pch_udc_dev *dev)
 static inline void pch_udc_vbus_session(struct pch_udc_dev *dev,
                                           int is_active)
 {
-        if (is_active)
-                pch_udc_clear_disconnect(dev);
-        else
+        if (is_active) {
+                pch_udc_reconnect(dev);
+                dev->vbus_session = 1;
+        } else {
+                if (dev->driver && dev->driver->disconnect) {
+                        spin_unlock(&dev->lock);
+                        dev->driver->disconnect(&dev->gadget);
+                        spin_lock(&dev->lock);
+                }
                 pch_udc_set_disconnect(dev);
+                dev->vbus_session = 0;
+        }
 }
 
 /**
@@ -1126,7 +1184,17 @@ static int pch_udc_pcd_pullup(struct usb_gadget *gadget, int is_on)
         if (!gadget)
                 return -EINVAL;
         dev = container_of(gadget, struct pch_udc_dev, gadget);
-        pch_udc_vbus_session(dev, is_on);
+        if (is_on) {
+                pch_udc_reconnect(dev);
+        } else {
+                if (dev->driver && dev->driver->disconnect) {
+                        spin_unlock(&dev->lock);
+                        dev->driver->disconnect(&dev->gadget);
+                        spin_lock(&dev->lock);
+                }
+                pch_udc_set_disconnect(dev);
+        }
+
         return 0;
 }
 
@@ -1183,6 +1251,188 @@ static const struct usb_gadget_ops pch_udc_ops = {
 };
 
 /**
+ * pch_vbus_gpio_get_value() - This API gets value of GPIO port as VBUS status.
+ * @dev:        Reference to the driver structure
+ *
+ * Return value:
+ *      1: VBUS is high
+ *      0: VBUS is low
+ *     -1: It is not enable to detect VBUS using GPIO
+ */
+static int pch_vbus_gpio_get_value(struct pch_udc_dev *dev)
+{
+        int vbus = 0;
+
+        if (dev->vbus_gpio.port)
+                vbus = gpio_get_value(dev->vbus_gpio.port) ? 1 : 0;
+        else
+                vbus = -1;
+
+        return vbus;
+}
+
+/**
+ * pch_vbus_gpio_work_fall() - This API keeps watch on VBUS becoming Low.
+ *                             If VBUS is Low, disconnect is processed
+ * @irq_work:   Structure for WorkQueue
+ *
+ */
+static void pch_vbus_gpio_work_fall(struct work_struct *irq_work)
+{
+        struct pch_vbus_gpio_data *vbus_gpio = container_of(irq_work,
+                struct pch_vbus_gpio_data, irq_work_fall);
+        struct pch_udc_dev *dev =
+                container_of(vbus_gpio, struct pch_udc_dev, vbus_gpio);
+        int vbus_saved = -1;
+        int vbus;
+        int count;
+
+        if (!dev->vbus_gpio.port)
+                return;
+
+        for (count = 0; count < (PCH_VBUS_PERIOD / PCH_VBUS_INTERVAL);
+                count++) {
+                vbus = pch_vbus_gpio_get_value(dev);
+
+                if ((vbus_saved == vbus) && (vbus == 0)) {
+                        dev_dbg(&dev->pdev->dev, "VBUS fell");
+                        if (dev->driver
+                                && dev->driver->disconnect) {
+                                dev->driver->disconnect(
+                                        &dev->gadget);
+                        }
+                        if (dev->vbus_gpio.intr)
+                                pch_udc_init(dev);
+                        else
+                                pch_udc_reconnect(dev);
+                        return;
+                }
+                vbus_saved = vbus;
+                mdelay(PCH_VBUS_INTERVAL);
+        }
+}
+
+/**
+ * pch_vbus_gpio_work_rise() - This API checks VBUS is High.
+ *                             If VBUS is High, connect is processed
+ * @irq_work:   Structure for WorkQueue
+ *
+ */
+static void pch_vbus_gpio_work_rise(struct work_struct *irq_work)
+{
+        struct pch_vbus_gpio_data *vbus_gpio = container_of(irq_work,
+                struct pch_vbus_gpio_data, irq_work_rise);
+        struct pch_udc_dev *dev =
+                container_of(vbus_gpio, struct pch_udc_dev, vbus_gpio);
+        int vbus;
+
+        if (!dev->vbus_gpio.port)
+                return;
+
+        mdelay(PCH_VBUS_INTERVAL);
+        vbus = pch_vbus_gpio_get_value(dev);
+
+        if (vbus == 1) {
+                dev_dbg(&dev->pdev->dev, "VBUS rose");
+                pch_udc_reconnect(dev);
+                return;
+        }
+}
+
+/**
+ * pch_vbus_gpio_irq() - IRQ handler for GPIO intrerrupt for changing VBUS
+ * @irq:        Interrupt request number
+ * @dev:        Reference to the device structure
+ *
+ * Return codes:
+ *      0: Success
+ *      -EINVAL: GPIO port is invalid or can't be initialized.
+ */
+static irqreturn_t pch_vbus_gpio_irq(int irq, void *data)
+{
+        struct pch_udc_dev *dev = (struct pch_udc_dev *)data;
+
+        if (!dev->vbus_gpio.port || !dev->vbus_gpio.intr)
+                return IRQ_NONE;
+
+        if (pch_vbus_gpio_get_value(dev))
+                schedule_work(&dev->vbus_gpio.irq_work_rise);
+        else
+                schedule_work(&dev->vbus_gpio.irq_work_fall);
+
+        return IRQ_HANDLED;
+}
+
+/**
+ * pch_vbus_gpio_init() - This API initializes GPIO port detecting VBUS.
+ * @dev:        Reference to the driver structure
+ * @vbus_gpio   Number of GPIO port to detect gpio
+ *
+ * Return codes:
+ *      0: Success
+ *      -EINVAL: GPIO port is invalid or can't be initialized.
+ */
+static int pch_vbus_gpio_init(struct pch_udc_dev *dev, int vbus_gpio_port)
+{
+        int err;
+        int irq_num = 0;
+
+        dev->vbus_gpio.port = 0;
+        dev->vbus_gpio.intr = 0;
+
+        if (vbus_gpio_port <= -1)
+                return -EINVAL;
+
+        err = gpio_is_valid(vbus_gpio_port);
+        if (!err) {
+                pr_err("%s: gpio port %d is invalid\n",
+                        __func__, vbus_gpio_port);
+                return -EINVAL;
+        }
+
+        err = gpio_request(vbus_gpio_port, "pch_vbus");
+        if (err) {
+                pr_err("%s: can't request gpio port %d, err: %d\n",
+                        __func__, vbus_gpio_port, err);
+                return -EINVAL;
+        }
+
+        dev->vbus_gpio.port = vbus_gpio_port;
+        gpio_direction_input(vbus_gpio_port);
+        INIT_WORK(&dev->vbus_gpio.irq_work_fall, pch_vbus_gpio_work_fall);
+
+        irq_num = gpio_to_irq(vbus_gpio_port);
+        if (irq_num > 0) {
+                irq_set_irq_type(irq_num, IRQ_TYPE_EDGE_BOTH);
+                err = request_irq(irq_num, pch_vbus_gpio_irq, 0,
+                        "vbus_detect", dev);
+                if (!err) {
+                        dev->vbus_gpio.intr = irq_num;
+                        INIT_WORK(&dev->vbus_gpio.irq_work_rise,
+                                pch_vbus_gpio_work_rise);
+                } else {
+                        pr_err("%s: can't request irq %d, err: %d\n",
+                                __func__, irq_num, err);
+                }
+        }
+
+        return 0;
+}
+
+/**
+ * pch_vbus_gpio_free() - This API frees resources of GPIO port
+ * @dev:        Reference to the driver structure
+ */
+static void pch_vbus_gpio_free(struct pch_udc_dev *dev)
+{
+        if (dev->vbus_gpio.intr)
+                free_irq(dev->vbus_gpio.intr, dev);
+
+        if (dev->vbus_gpio.port)
+                gpio_free(dev->vbus_gpio.port);
+}
+
+/**
  * complete_req() - This API is invoked from the driver when processing
  *                      of a request is complete
  * @ep:         Reference to the endpoint structure
@@ -1493,6 +1743,7 @@ static int pch_udc_pcd_ep_disable(struct usb_ep *usbep)
         pch_udc_ep_disable(ep);
         pch_udc_disable_ep_interrupts(ep->dev, PCH_UDC_EPINT(ep->in, ep->num));
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         INIT_LIST_HEAD(&ep->queue);
         spin_unlock_irqrestore(&ep->dev->lock, iflags);
         return 0;
@@ -2335,8 +2586,11 @@ static void pch_udc_svc_ur_interrupt(struct pch_udc_dev *dev)
                 /* Complete request queue */
                 empty_req_queue(ep);
         }
-        if (dev->driver && dev->driver->disconnect)
+        if (dev->driver && dev->driver->disconnect) {
+                spin_unlock(&dev->lock);
                 dev->driver->disconnect(&dev->gadget);
+                spin_lock(&dev->lock);
+        }
 }
 
 /**
@@ -2371,6 +2625,11 @@ static void pch_udc_svc_enum_interrupt(struct pch_udc_dev *dev)
         pch_udc_set_dma(dev, DMA_DIR_TX);
         pch_udc_set_dma(dev, DMA_DIR_RX);
         pch_udc_ep_set_rrdy(&(dev->ep[UDC_EP0OUT_IDX]));
+
+        /* enable device interrupts */
+        pch_udc_enable_interrupts(dev, UDC_DEVINT_UR | UDC_DEVINT_US |
+                                        UDC_DEVINT_ES | UDC_DEVINT_ENUM |
+                                        UDC_DEVINT_SI | UDC_DEVINT_SC);
 }
 
 /**
@@ -2459,12 +2718,18 @@ static void pch_udc_svc_cfg_interrupt(struct pch_udc_dev *dev)
  */
 static void pch_udc_dev_isr(struct pch_udc_dev *dev, u32 dev_intr)
 {
+        int vbus;
+
         /* USB Reset Interrupt */
-        if (dev_intr & UDC_DEVINT_UR)
+        if (dev_intr & UDC_DEVINT_UR) {
                 pch_udc_svc_ur_interrupt(dev);
+                dev_dbg(&dev->pdev->dev, "USB_RESET\n");
+        }
         /* Enumeration Done Interrupt */
-        if (dev_intr & UDC_DEVINT_ENUM)
+        if (dev_intr & UDC_DEVINT_ENUM) {
                 pch_udc_svc_enum_interrupt(dev);
+                dev_dbg(&dev->pdev->dev, "USB_ENUM\n");
+        }
         /* Set Interface Interrupt */
         if (dev_intr & UDC_DEVINT_SI)
                 pch_udc_svc_intf_interrupt(dev);
@@ -2472,8 +2737,30 @@ static void pch_udc_dev_isr(struct pch_udc_dev *dev, u32 dev_intr)
         if (dev_intr & UDC_DEVINT_SC)
                 pch_udc_svc_cfg_interrupt(dev);
         /* USB Suspend interrupt */
-        if (dev_intr & UDC_DEVINT_US)
+        if (dev_intr & UDC_DEVINT_US) {
+                if (dev->driver
+                        && dev->driver->suspend) {
+                        spin_unlock(&dev->lock);
+                        dev->driver->suspend(&dev->gadget);
+                        spin_lock(&dev->lock);
+                }
+
+                vbus = pch_vbus_gpio_get_value(dev);
+                if ((dev->vbus_session == 0)
+                        && (vbus != 1)) {
+                        if (dev->driver && dev->driver->disconnect) {
+                                spin_unlock(&dev->lock);
+                                dev->driver->disconnect(&dev->gadget);
+                                spin_lock(&dev->lock);
+                        }
+                        pch_udc_reconnect(dev);
+                } else if ((dev->vbus_session == 0)
+                        && (vbus == 1)
+                        && !dev->vbus_gpio.intr)
+                        schedule_work(&dev->vbus_gpio.irq_work_fall);
+
                 dev_dbg(&dev->pdev->dev, "USB_SUSPEND\n");
+        }
         /* Clear the SOF interrupt, if enabled */
         if (dev_intr & UDC_DEVINT_SOF)
                 dev_dbg(&dev->pdev->dev, "SOF\n");
@@ -2499,6 +2786,14 @@ static irqreturn_t pch_udc_isr(int irq, void *pdev)
         dev_intr = pch_udc_read_device_interrupts(dev);
         ep_intr = pch_udc_read_ep_interrupts(dev);
 
+        /* For a hot plug, this find that the controller is hung up. */
+        if (dev_intr == ep_intr)
+                if (dev_intr == pch_udc_readl(dev, UDC_DEVCFG_ADDR)) {
+                        dev_dbg(&dev->pdev->dev, "UDC: Hung up\n");
+                        /* The controller is reset */
+                        pch_udc_writel(dev, UDC_SRST, UDC_SRST_ADDR);
+                        return IRQ_HANDLED;
+                }
         if (dev_intr)
                 /* Clear device interrupts */
                 pch_udc_write_device_interrupts(dev, dev_intr);
@@ -2625,6 +2920,7 @@ static int pch_udc_pcd_init(struct pch_udc_dev *dev)
 {
         pch_udc_init(dev);
         pch_udc_pcd_reinit(dev);
+        pch_vbus_gpio_init(dev, vbus_gpio_port);
         return 0;
 }
 
@@ -2725,7 +3021,8 @@ static int pch_udc_start(struct usb_gadget_driver *driver,
         pch_udc_setup_ep0(dev);
 
         /* clear SD */
-        pch_udc_clear_disconnect(dev);
+        if ((pch_vbus_gpio_get_value(dev) != 0) || !dev->vbus_gpio.intr)
+                pch_udc_clear_disconnect(dev);
 
         dev->connected = 1;
         return 0;
@@ -2803,6 +3100,8 @@ static void pch_udc_remove(struct pci_dev *pdev)
                                  UDC_EP0OUT_BUFF_SIZE * 4, DMA_FROM_DEVICE);
         kfree(dev->ep0out_buf);
 
+        pch_vbus_gpio_free(dev);
+
         pch_udc_exit(dev);
 
         if (dev->irq_registered)
@@ -2912,8 +3211,10 @@ static int pch_udc_probe(struct pci_dev *pdev,
         }
         pch_udc = dev;
         /* initialize the hardware */
-        if (pch_udc_pcd_init(dev))
+        if (pch_udc_pcd_init(dev)) {
+                retval = -ENODEV;
                 goto finished;
+        }
         if (request_irq(pdev->irq, pch_udc_isr, IRQF_SHARED, KBUILD_MODNAME,
                         dev)) {
                 dev_err(&pdev->dev, "%s: request_irq(%d) fail\n", __func__,
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
index d83134b0f78a..4e4dc1f5f388 100644
--- a/drivers/usb/gadget/printer.c
+++ b/drivers/usb/gadget/printer.c
@@ -34,7 +34,6 @@
 #include <asm/byteorder.h>
 #include <linux/io.h>
 #include <linux/irq.h>
-#include <asm/system.h>
 #include <linux/uaccess.h>
 #include <asm/unaligned.h>
 
diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
index dd470635f4f7..41ed69c96d8c 100644
--- a/drivers/usb/gadget/pxa25x_udc.c
+++ b/drivers/usb/gadget/pxa25x_udc.c
@@ -41,7 +41,6 @@
 #include <asm/byteorder.h>
 #include <asm/dma.h>
 #include <asm/gpio.h>
-#include <asm/system.h>
 #include <asm/mach-types.h>
 #include <asm/unaligned.h>
 
@@ -283,6 +282,7 @@ static int pxa25x_ep_disable (struct usb_ep *_ep)
         pxa25x_ep_fifo_flush (_ep);
 
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         ep->stopped = 1;
 
         local_irq_restore(flags);
@@ -995,7 +995,7 @@ static int pxa25x_udc_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
         udc = container_of(_gadget, struct pxa25x_udc, gadget);
 
         if (udc->transceiver)
-                return otg_set_power(udc->transceiver, mA);
+                return usb_phy_set_power(udc->transceiver, mA);
         return -EOPNOTSUPP;
 }
 
@@ -1192,6 +1192,7 @@ static void udc_reinit(struct pxa25x_udc *dev)
                         list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
 
                 ep->desc = NULL;
+                ep->ep.desc = NULL;
                 ep->stopped = 0;
                 INIT_LIST_HEAD (&ep->queue);
                 ep->pio_irqs = 0;
@@ -1301,7 +1302,8 @@ fail:
 
         /* connect to bus through transceiver */
         if (dev->transceiver) {
-                retval = otg_set_peripheral(dev->transceiver, &dev->gadget);
+                retval = otg_set_peripheral(dev->transceiver->otg,
+                                                &dev->gadget);
                 if (retval) {
                         DMSG("can't bind to transceiver\n");
                         if (driver->unbind)
@@ -1360,7 +1362,7 @@ static int pxa25x_stop(struct usb_gadget_driver *driver)
         local_irq_enable();
 
         if (dev->transceiver)
-                (void) otg_set_peripheral(dev->transceiver, NULL);
+                (void) otg_set_peripheral(dev->transceiver->otg, NULL);
 
         driver->unbind(&dev->gadget);
         dev->gadget.dev.driver = NULL;
@@ -2159,7 +2161,7 @@ static int __init pxa25x_udc_probe(struct platform_device *pdev)
         dev->dev = &pdev->dev;
         dev->mach = pdev->dev.platform_data;
 
-        dev->transceiver = otg_get_transceiver();
+        dev->transceiver = usb_get_transceiver();
 
         if (gpio_is_valid(dev->mach->gpio_pullup)) {
                 if ((retval = gpio_request(dev->mach->gpio_pullup,
@@ -2238,7 +2240,7 @@ lubbock_fail0:
                 gpio_free(dev->mach->gpio_pullup);
  err_gpio_pullup:
         if (dev->transceiver) {
-                otg_put_transceiver(dev->transceiver);
+                usb_put_transceiver(dev->transceiver);
                 dev->transceiver = NULL;
         }
         clk_put(dev->clk);
@@ -2280,7 +2282,7 @@ static int __exit pxa25x_udc_remove(struct platform_device *pdev)
         clk_put(dev->clk);
 
         if (dev->transceiver) {
-                otg_put_transceiver(dev->transceiver);
+                usb_put_transceiver(dev->transceiver);
                 dev->transceiver = NULL;
         }
 
diff --git a/drivers/usb/gadget/pxa25x_udc.h b/drivers/usb/gadget/pxa25x_udc.h
index 8eaf4e43726b..893e917f048e 100644
--- a/drivers/usb/gadget/pxa25x_udc.h
+++ b/drivers/usb/gadget/pxa25x_udc.h
@@ -119,7 +119,7 @@ struct pxa25x_udc {
         struct device                           *dev;
         struct clk                              *clk;
         struct pxa2xx_udc_mach_info             *mach;
-        struct otg_transceiver                  *transceiver;
+        struct usb_phy                          *transceiver;
         u64                                     dma_mask;
         struct pxa25x_ep                        ep [PXA_UDC_NUM_ENDPOINTS];
 
diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
index f4c44eb806c3..98acb3ab9e17 100644
--- a/drivers/usb/gadget/pxa27x_udc.c
+++ b/drivers/usb/gadget/pxa27x_udc.c
@@ -1666,7 +1666,7 @@ static int pxa_udc_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
 
         udc = to_gadget_udc(_gadget);
         if (udc->transceiver)
-                return otg_set_power(udc->transceiver, mA);
+                return usb_phy_set_power(udc->transceiver, mA);
         return -EOPNOTSUPP;
 }
 
@@ -1835,7 +1835,8 @@ static int pxa27x_udc_start(struct usb_gadget_driver *driver,
                 driver->driver.name);
 
         if (udc->transceiver) {
-                retval = otg_set_peripheral(udc->transceiver, &udc->gadget);
+                retval = otg_set_peripheral(udc->transceiver->otg,
+                                                &udc->gadget);
                 if (retval) {
                         dev_err(udc->dev, "can't bind to transceiver\n");
                         goto transceiver_fail;
@@ -1908,7 +1909,7 @@ static int pxa27x_udc_stop(struct usb_gadget_driver *driver)
                  driver->driver.name);
 
         if (udc->transceiver)
-                return otg_set_peripheral(udc->transceiver, NULL);
+                return otg_set_peripheral(udc->transceiver->otg, NULL);
         return 0;
 }
 
@@ -2463,7 +2464,7 @@ static int __init pxa_udc_probe(struct platform_device *pdev)
 
         udc->dev = &pdev->dev;
         udc->mach = pdev->dev.platform_data;
-        udc->transceiver = otg_get_transceiver();
+        udc->transceiver = usb_get_transceiver();
 
         gpio = udc->mach->gpio_pullup;
         if (gpio_is_valid(gpio)) {
@@ -2542,7 +2543,7 @@ static int __exit pxa_udc_remove(struct platform_device *_dev)
         if (gpio_is_valid(gpio))
                 gpio_free(gpio);
 
-        otg_put_transceiver(udc->transceiver);
+        usb_put_transceiver(udc->transceiver);
 
         udc->transceiver = NULL;
         platform_set_drvdata(_dev, NULL);
diff --git a/drivers/usb/gadget/pxa27x_udc.h b/drivers/usb/gadget/pxa27x_udc.h
index 7f4e8f424e80..a1d268c6f2cc 100644
--- a/drivers/usb/gadget/pxa27x_udc.h
+++ b/drivers/usb/gadget/pxa27x_udc.h
@@ -447,7 +447,7 @@ struct pxa_udc {
         struct usb_gadget_driver                *driver;
         struct device                           *dev;
         struct pxa2xx_udc_mach_info             *mach;
-        struct otg_transceiver                  *transceiver;
+        struct usb_phy                          *transceiver;
 
         enum ep0_state                          ep0state;
         struct udc_stats                        stats;
diff --git a/drivers/usb/gadget/r8a66597-udc.c b/drivers/usb/gadget/r8a66597-udc.c
index f5b8d215e1d5..c4401e7dd3a6 100644
--- a/drivers/usb/gadget/r8a66597-udc.c
+++ b/drivers/usb/gadget/r8a66597-udc.c
@@ -663,11 +663,7 @@ static int sudmac_alloc_channel(struct r8a66597 *r8a66597,
         ep->fifoctr = D0FIFOCTR;
 
         /* dma mapping */
-        req->req.dma = dma_map_single(r8a66597_to_dev(ep->r8a66597),
-                                req->req.buf, req->req.length,
-                                dma->dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-
-        return 0;
+        return usb_gadget_map_request(&r8a66597->gadget, &req->req, dma->dir);
 }
 
 static void sudmac_free_channel(struct r8a66597 *r8a66597,
@@ -677,9 +673,7 @@ static void sudmac_free_channel(struct r8a66597 *r8a66597,
         if (!r8a66597_is_sudmac(r8a66597))
                 return;
 
-        dma_unmap_single(r8a66597_to_dev(ep->r8a66597),
-                         req->req.dma, req->req.length,
-                         ep->dma->dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+        usb_gadget_unmap_request(&r8a66597->gadget, &req->req, ep->dma->dir);
 
         r8a66597_bclr(r8a66597, DREQE, ep->fifosel);
         r8a66597_change_curpipe(r8a66597, 0, 0, ep->fifosel);
diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
index d3cdffea9c8a..73a934a170d1 100644
--- a/drivers/usb/gadget/rndis.c
+++ b/drivers/usb/gadget/rndis.c
@@ -34,7 +34,6 @@
 
 #include <asm/io.h>
 #include <asm/byteorder.h>
-#include <asm/system.h>
 #include <asm/unaligned.h>
 
 
diff --git a/drivers/usb/gadget/s3c-hsudc.c b/drivers/usb/gadget/s3c-hsudc.c
index df8661d266cb..cef9b82ff911 100644
--- a/drivers/usb/gadget/s3c-hsudc.c
+++ b/drivers/usb/gadget/s3c-hsudc.c
@@ -30,6 +30,7 @@
 #include <linux/prefetch.h>
 #include <linux/platform_data/s3c-hsudc.h>
 #include <linux/regulator/consumer.h>
+#include <linux/pm_runtime.h>
 
 #include <mach/regs-s3c2443-clock.h>
 
@@ -145,7 +146,7 @@ struct s3c_hsudc {
         struct usb_gadget_driver *driver;
         struct device *dev;
         struct s3c24xx_hsudc_platdata *pd;
-        struct otg_transceiver *transceiver;
+        struct usb_phy *transceiver;
         struct regulator_bulk_data supplies[ARRAY_SIZE(s3c_hsudc_supply_names)];
         spinlock_t lock;
         void __iomem *regs;
@@ -759,7 +760,7 @@ static int s3c_hsudc_ep_enable(struct usb_ep *_ep,
         unsigned long flags;
         u32 ecr = 0;
 
-        hsep = container_of(_ep, struct s3c_hsudc_ep, ep);
+        hsep = our_ep(_ep);
         if (!_ep || !desc || hsep->desc || _ep->name == ep0name
                 || desc->bDescriptorType != USB_DT_ENDPOINT
                 || hsep->bEndpointAddress != desc->bEndpointAddress
@@ -816,6 +817,7 @@ static int s3c_hsudc_ep_disable(struct usb_ep *_ep)
         s3c_hsudc_nuke_ep(hsep, -ESHUTDOWN);
 
         hsep->desc = 0;
+        hsep->ep.desc = NULL;
         hsep->stopped = 1;
 
         spin_unlock_irqrestore(&hsudc->lock, flags);
@@ -853,7 +855,7 @@ static void s3c_hsudc_free_request(struct usb_ep *ep, struct usb_request *_req)
 {
         struct s3c_hsudc_req *hsreq;
 
-        hsreq = container_of(_req, struct s3c_hsudc_req, req);
+        hsreq = our_req(_req);
         WARN_ON(!list_empty(&hsreq->queue));
         kfree(hsreq);
 }
@@ -876,12 +878,12 @@ static int s3c_hsudc_queue(struct usb_ep *_ep, struct usb_request *_req,
         u32 offset;
         u32 csr;
 
-        hsreq = container_of(_req, struct s3c_hsudc_req, req);
+        hsreq = our_req(_req);
         if ((!_req || !_req->complete || !_req->buf ||
                 !list_empty(&hsreq->queue)))
                 return -EINVAL;
 
-        hsep = container_of(_ep, struct s3c_hsudc_ep, ep);
+        hsep = our_ep(_ep);
         hsudc = hsep->dev;
         if (!hsudc->driver || hsudc->gadget.speed == USB_SPEED_UNKNOWN)
                 return -ESHUTDOWN;
@@ -935,7 +937,7 @@ static int s3c_hsudc_dequeue(struct usb_ep *_ep, struct usb_request *_req)
         struct s3c_hsudc_req *hsreq;
         unsigned long flags;
 
-        hsep = container_of(_ep, struct s3c_hsudc_ep, ep);
+        hsep = our_ep(_ep);
         if (!_ep || hsep->ep.name == ep0name)
                 return -EINVAL;
 
@@ -1005,6 +1007,7 @@ static void s3c_hsudc_initep(struct s3c_hsudc *hsudc,
         hsep->ep.ops = &s3c_hsudc_ep_ops;
         hsep->fifo = hsudc->regs + S3C_BR(epnum);
         hsep->desc = 0;
+        hsep->ep.desc = NULL;
         hsep->stopped = 0;
         hsep->wedge = 0;
 
@@ -1166,7 +1169,8 @@ static int s3c_hsudc_start(struct usb_gadget *gadget,
 
         /* connect to bus through transceiver */
         if (hsudc->transceiver) {
-                ret = otg_set_peripheral(hsudc->transceiver, &hsudc->gadget);
+                ret = otg_set_peripheral(hsudc->transceiver->otg,
+                                        &hsudc->gadget);
                 if (ret) {
                         dev_err(hsudc->dev, "%s: can't bind to transceiver\n",
                                         hsudc->gadget.name);
@@ -1178,6 +1182,9 @@ static int s3c_hsudc_start(struct usb_gadget *gadget,
         dev_info(hsudc->dev, "bound driver %s\n", driver->driver.name);
 
         s3c_hsudc_reconfig(hsudc);
+
+        pm_runtime_get_sync(hsudc->dev);
+
         s3c_hsudc_init_phy();
         if (hsudc->pd->gpio_init)
                 hsudc->pd->gpio_init();
@@ -1208,13 +1215,16 @@ static int s3c_hsudc_stop(struct usb_gadget *gadget,
         hsudc->gadget.dev.driver = NULL;
         hsudc->gadget.speed = USB_SPEED_UNKNOWN;
         s3c_hsudc_uninit_phy();
+
+        pm_runtime_put(hsudc->dev);
+
         if (hsudc->pd->gpio_uninit)
                 hsudc->pd->gpio_uninit();
         s3c_hsudc_stop_activity(hsudc);
         spin_unlock_irqrestore(&hsudc->lock, flags);
 
         if (hsudc->transceiver)
-                (void) otg_set_peripheral(hsudc->transceiver, NULL);
+                (void) otg_set_peripheral(hsudc->transceiver->otg, NULL);
 
         disable_irq(hsudc->irq);
 
@@ -1243,7 +1253,7 @@ static int s3c_hsudc_vbus_draw(struct usb_gadget *gadget, unsigned mA)
                 return -ENODEV;
 
         if (hsudc->transceiver)
-                return otg_set_power(hsudc->transceiver, mA);
+                return usb_phy_set_power(hsudc->transceiver, mA);
 
         return -EOPNOTSUPP;
 }
@@ -1275,7 +1285,7 @@ static int __devinit s3c_hsudc_probe(struct platform_device *pdev)
         hsudc->dev = dev;
         hsudc->pd = pdev->dev.platform_data;
 
-        hsudc->transceiver = otg_get_transceiver();
+        hsudc->transceiver = usb_get_transceiver();
 
         for (i = 0; i < ARRAY_SIZE(hsudc->supplies); i++)
                 hsudc->supplies[i].supply = s3c_hsudc_supply_names[i];
@@ -1362,6 +1372,8 @@ static int __devinit s3c_hsudc_probe(struct platform_device *pdev)
         if (ret)
                 goto err_add_udc;
 
+        pm_runtime_enable(dev);
+
         return 0;
 err_add_udc:
         device_unregister(&hsudc->gadget.dev);
@@ -1377,7 +1389,7 @@ err_remap:
         release_mem_region(res->start, resource_size(res));
 err_res:
         if (hsudc->transceiver)
-                otg_put_transceiver(hsudc->transceiver);
+                usb_put_transceiver(hsudc->transceiver);
 
         regulator_bulk_free(ARRAY_SIZE(hsudc->supplies), hsudc->supplies);
 err_supplies:
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index 3f87cb9344bb..195524cde6c3 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -37,7 +37,6 @@
 #include <asm/byteorder.h>
 #include <asm/io.h>
 #include <asm/irq.h>
-#include <asm/system.h>
 #include <asm/unaligned.h>
 #include <mach/irqs.h>
 
@@ -1148,6 +1147,7 @@ static int s3c2410_udc_ep_disable(struct usb_ep *_ep)
         dprintk(DEBUG_NORMAL, "ep_disable: %s\n", _ep->name);
 
         ep->desc = NULL;
+        ep->ep.desc = NULL;
         ep->halted = 1;
 
         s3c2410_udc_nuke (ep->dev, ep, -ESHUTDOWN);
@@ -1630,6 +1630,7 @@ static void s3c2410_udc_reinit(struct s3c2410_udc *dev)
 
                 ep->dev = dev;
                 ep->desc = NULL;
+                ep->ep.desc = NULL;
                 ep->halted = 0;
                 INIT_LIST_HEAD (&ep->queue);
         }
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index ad9e5b2df642..665c07422c26 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -242,7 +242,7 @@ static struct usb_composite_driver gserial_driver = {
         .name           = "g_serial",
         .dev            = &device_desc,
         .strings        = dev_strings,
-        .max_speed      = USB_SPEED_HIGH,
+        .max_speed      = USB_SPEED_SUPER,
 };
 
 static int __init init(void)
diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
index 85ea14e2545e..8081ca3a70a2 100644
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 2003-2008 Alan Stern
  * Copyeight (C) 2009 Samsung Electronics
- * Author: Michal Nazarewicz (m.nazarewicz@samsung.com)
+ * Author: Michal Nazarewicz (mina86@mina86.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
@@ -145,48 +145,8 @@
 
 #endif /* DUMP_MSGS */
 
-
-
-
-
 /*-------------------------------------------------------------------------*/
 
-/* Bulk-only data structures */
-
-/* Command Block Wrapper */
-struct fsg_bulk_cb_wrap {
-        __le32  Signature;              /* Contains 'USBC' */
-        u32     Tag;                    /* Unique per command id */
-        __le32  DataTransferLength;     /* Size of the data */
-        u8      Flags;                  /* Direction in bit 7 */
-        u8      Lun;                    /* LUN (normally 0) */
-        u8      Length;                 /* Of the CDB, <= MAX_COMMAND_SIZE */
-        u8      CDB[16];                /* Command Data Block */
-};
-
-#define USB_BULK_CB_WRAP_LEN    31
-#define USB_BULK_CB_SIG         0x43425355      /* Spells out USBC */
-#define USB_BULK_IN_FLAG        0x80
-
-/* Command Status Wrapper */
-struct bulk_cs_wrap {
-        __le32  Signature;              /* Should = 'USBS' */
-        u32     Tag;                    /* Same as original command */
-        __le32  Residue;                /* Amount not transferred */
-        u8      Status;                 /* See below */
-};
-
-#define USB_BULK_CS_WRAP_LEN    13
-#define USB_BULK_CS_SIG         0x53425355      /* Spells out 'USBS' */
-#define USB_STATUS_PASS         0
-#define USB_STATUS_FAIL         1
-#define USB_STATUS_PHASE_ERROR  2
-
-/* Bulk-only class specific requests */
-#define USB_BULK_RESET_REQUEST          0xff
-#define USB_BULK_GET_MAX_LUN_REQUEST    0xfe
-
-
 /* CBI Interrupt data structure */
 struct interrupt_data {
         u8      bType;
diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
index a553beeb86d5..09aa92064277 100644
--- a/drivers/usb/gadget/u_serial.c
+++ b/drivers/usb/gadget/u_serial.c
@@ -725,9 +725,6 @@ static int gs_open(struct tty_struct *tty, struct file *file)
         struct gs_port  *port;
         int             status;
 
-        if (port_num < 0 || port_num >= n_ports)
-                return -ENXIO;
-
         do {
                 mutex_lock(&ports[port_num].lock);
                 port = ports[port_num].port;
@@ -1087,7 +1084,6 @@ int __init gserial_setup(struct usb_gadget *g, unsigned count)
         if (!gs_tty_driver)
                 return -ENOMEM;
 
-        gs_tty_driver->owner = THIS_MODULE;
         gs_tty_driver->driver_name = "g_serial";
         gs_tty_driver->name = PREFIX;
         /* uses dynamically assigned dev_t values */
diff --git a/drivers/usb/gadget/u_audio.c b/drivers/usb/gadget/u_uac1.c
index 59ffe1ecf1c9..af9898982059 100644
--- a/drivers/usb/gadget/u_audio.c
+++ b/drivers/usb/gadget/u_uac1.c
@@ -1,5 +1,5 @@
 /*
- * u_audio.c -- ALSA audio utilities for Gadget stack
+ * u_uac1.c -- ALSA audio utilities for Gadget stack
  *
  * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
  * Copyright (C) 2008 Analog Devices, Inc
@@ -17,7 +17,7 @@
 #include <linux/random.h>
 #include <linux/syscalls.h>
 
-#include "u_audio.h"
+#include "u_uac1.h"
 
 /*
  * This component encapsulates the ALSA devices for USB audio gadget
diff --git a/drivers/usb/gadget/u_audio.h b/drivers/usb/gadget/u_uac1.h
index 08ffce3298e6..18c2e729faf6 100644
--- a/drivers/usb/gadget/u_audio.h
+++ b/drivers/usb/gadget/u_uac1.h
@@ -1,5 +1,5 @@
 /*
- * u_audio.h -- interface to USB gadget "ALSA AUDIO" utilities
+ * u_uac1.h -- interface to USB gadget "ALSA AUDIO" utilities
  *
  * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
  * Copyright (C) 2008 Analog Devices, Inc
diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
index 0b0d12ccc487..56da49f31d6c 100644
--- a/drivers/usb/gadget/udc-core.c
+++ b/drivers/usb/gadget/udc-core.c
@@ -22,6 +22,7 @@
 #include <linux/device.h>
 #include <linux/list.h>
 #include <linux/err.h>
+#include <linux/dma-mapping.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
@@ -49,6 +50,57 @@ static DEFINE_MUTEX(udc_lock);
 
 /* ------------------------------------------------------------------------- */
 
+int usb_gadget_map_request(struct usb_gadget *gadget,
+                struct usb_request *req, int is_in)
+{
+        if (req->length == 0)
+                return 0;
+
+        if (req->num_sgs) {
+                int     mapped;
+
+                mapped = dma_map_sg(&gadget->dev, req->sg, req->num_sgs,
+                                is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                if (mapped == 0) {
+                        dev_err(&gadget->dev, "failed to map SGs\n");
+                        return -EFAULT;
+                }
+
+                req->num_mapped_sgs = mapped;
+        } else {
+                req->dma = dma_map_single(&gadget->dev, req->buf, req->length,
+                                is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+
+                if (dma_mapping_error(&gadget->dev, req->dma)) {
+                        dev_err(&gadget->dev, "failed to map buffer\n");
+                        return -EFAULT;
+                }
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(usb_gadget_map_request);
+
+void usb_gadget_unmap_request(struct usb_gadget *gadget,
+                struct usb_request *req, int is_in)
+{
+        if (req->length == 0)
+                return;
+
+        if (req->num_mapped_sgs) {
+                dma_unmap_sg(&gadget->dev, req->sg, req->num_mapped_sgs,
+                                is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+
+                req->num_mapped_sgs = 0;
+        } else {
+                dma_unmap_single(&gadget->dev, req->dma, req->length,
+                                is_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+        }
+}
+EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
+
+/* ------------------------------------------------------------------------- */
+
 /**
  * usb_gadget_start - tells usb device controller to start up
  * @gadget: The gadget we want to get started