1 files changed, 130 insertions, 403 deletions

diff --git a/drivers/usb/gadget/udc/net2280.c b/drivers/usb/gadget/udc/net2280.c
index d6411e0a8e03..d2c0bf65e345 100644
--- a/drivers/usb/gadget/udc/net2280.c
+++ b/drivers/usb/gadget/udc/net2280.c
@@ -12,11 +12,7 @@
  * the Mass Storage, Serial, and Ethernet/RNDIS gadget drivers
  * as well as Gadget Zero and Gadgetfs.
  *
- * DMA is enabled by default.  Drivers using transfer queues might use
- * DMA chaining to remove IRQ latencies between transfers.  (Except when
- * short OUT transfers happen.)  Drivers can use the req->no_interrupt
- * hint to completely eliminate some IRQs, if a later IRQ is guaranteed
- * and DMA chaining is enabled.
+ * DMA is enabled by default.
  *
  * MSI is enabled by default.  The legacy IRQ is used if MSI couldn't
  * be enabled.
@@ -84,23 +80,6 @@ static const char *const ep_name[] = {
         "ep-e", "ep-f", "ep-g", "ep-h",
 };
 
-/* use_dma -- general goodness, fewer interrupts, less cpu load (vs PIO)
- * use_dma_chaining -- dma descriptor queueing gives even more irq reduction
- *
- * The net2280 DMA engines are not tightly integrated with their FIFOs;
- * not all cases are (yet) handled well in this driver or the silicon.
- * Some gadget drivers work better with the dma support here than others.
- * These two parameters let you use PIO or more aggressive DMA.
- */
-static bool use_dma = true;
-static bool use_dma_chaining;
-static bool use_msi = true;
-
-/* "modprobe net2280 use_dma=n" etc */
-module_param(use_dma, bool, 0444);
-module_param(use_dma_chaining, bool, 0444);
-module_param(use_msi, bool, 0444);
-
 /* mode 0 == ep-{a,b,c,d} 1K fifo each
  * mode 1 == ep-{a,b} 2K fifo each, ep-{c,d} unavailable
  * mode 2 == ep-a 2K fifo, ep-{b,c} 1K each, ep-d unavailable
@@ -120,11 +99,6 @@ static bool enable_suspend;
 /* "modprobe net2280 enable_suspend=1" etc */
 module_param(enable_suspend, bool, 0444);
 
-/* force full-speed operation */
-static bool full_speed;
-module_param(full_speed, bool, 0444);
-MODULE_PARM_DESC(full_speed, "force full-speed mode -- for testing only!");
-
 #define DIR_STRING(bAddress) (((bAddress) & USB_DIR_IN) ? "in" : "out")
 
 static char *type_string(u8 bmAttributes)
@@ -202,15 +176,6 @@ net2280_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
         /* set speed-dependent max packet; may kick in high bandwidth */
         set_max_speed(ep, max);
 
-        /* FIFO lines can't go to different packets.  PIO is ok, so
-         * use it instead of troublesome (non-bulk) multi-packet DMA.
-         */
-        if (ep->dma && (max % 4) != 0 && use_dma_chaining) {
-                ep_dbg(ep->dev, "%s, no dma for maxpacket %d\n",
-                        ep->ep.name, ep->ep.maxpacket);
-                ep->dma = NULL;
-        }
-
         /* set type, direction, address; reset fifo counters */
         writel(BIT(FIFO_FLUSH), &ep->regs->ep_stat);
         tmp = (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
@@ -478,7 +443,7 @@ static int net2280_disable(struct usb_ep *_ep)
         /* synch memory views with the device */
         (void)readl(&ep->cfg->ep_cfg);
 
-        if (use_dma && !ep->dma && ep->num >= 1 && ep->num <= 4)
+        if (!ep->dma && ep->num >= 1 && ep->num <= 4)
                 ep->dma = &ep->dev->dma[ep->num - 1];
 
         spin_unlock_irqrestore(&ep->dev->lock, flags);
@@ -610,9 +575,15 @@ static void out_flush(struct net2280_ep *ep)
         u32     __iomem *statp;
         u32     tmp;
 
-        ASSERT_OUT_NAKING(ep);
-
         statp = &ep->regs->ep_stat;
+
+        tmp = readl(statp);
+        if (tmp & BIT(NAK_OUT_PACKETS)) {
+                ep_dbg(ep->dev, "%s %s %08x !NAK\n",
+                        ep->ep.name, __func__, tmp);
+                writel(BIT(SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
+        }
+
         writel(BIT(DATA_OUT_PING_TOKEN_INTERRUPT) |
                 BIT(DATA_PACKET_RECEIVED_INTERRUPT),
                 statp);
@@ -747,8 +718,7 @@ static void fill_dma_desc(struct net2280_ep *ep,
         req->valid = valid;
         if (valid)
                 dmacount |= BIT(VALID_BIT);
-        if (likely(!req->req.no_interrupt || !use_dma_chaining))
-                dmacount |= BIT(DMA_DONE_INTERRUPT_ENABLE);
+        dmacount |= BIT(DMA_DONE_INTERRUPT_ENABLE);
 
         /* td->dmadesc = previously set by caller */
         td->dmaaddr = cpu_to_le32 (req->req.dma);
@@ -862,27 +832,11 @@ static void start_dma(struct net2280_ep *ep, struct net2280_request *req)
         req->td->dmadesc = cpu_to_le32 (ep->td_dma);
         fill_dma_desc(ep, req, 1);
 
-        if (!use_dma_chaining)
-                req->td->dmacount |= cpu_to_le32(BIT(END_OF_CHAIN));
+        req->td->dmacount |= cpu_to_le32(BIT(END_OF_CHAIN));
 
         start_queue(ep, tmp, req->td_dma);
 }
 
-static inline void resume_dma(struct net2280_ep *ep)
-{
-        writel(readl(&ep->dma->dmactl) | BIT(DMA_ENABLE), &ep->dma->dmactl);
-
-        ep->dma_started = true;
-}
-
-static inline void ep_stop_dma(struct net2280_ep *ep)
-{
-        writel(readl(&ep->dma->dmactl) & ~BIT(DMA_ENABLE), &ep->dma->dmactl);
-        spin_stop_dma(ep->dma);
-
-        ep->dma_started = false;
-}
-
 static inline void
 queue_dma(struct net2280_ep *ep, struct net2280_request *req, int valid)
 {
@@ -973,10 +927,8 @@ net2280_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
                         return ret;
         }
 
-#if 0
         ep_vdbg(dev, "%s queue req %p, len %d buf %p\n",
                         _ep->name, _req, _req->length, _req->buf);
-#endif
 
         spin_lock_irqsave(&dev->lock, flags);
 
@@ -984,24 +936,12 @@ net2280_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
         _req->actual = 0;
 
         /* kickstart this i/o queue? */
-        if (list_empty(&ep->queue) && !ep->stopped) {
-                /* DMA request while EP halted */
-                if (ep->dma &&
-                    (readl(&ep->regs->ep_rsp) & BIT(CLEAR_ENDPOINT_HALT)) &&
-                        (dev->quirks & PLX_SUPERSPEED)) {
-                        int valid = 1;
-                        if (ep->is_in) {
-                                int expect;
-                                expect = likely(req->req.zero ||
-                                                ((req->req.length %
-                                                  ep->ep.maxpacket) != 0));
-                                if (expect != ep->in_fifo_validate)
-                                        valid = 0;
-                        }
-                        queue_dma(ep, req, valid);
-                }
+        if  (list_empty(&ep->queue) && !ep->stopped &&
+                !((dev->quirks & PLX_SUPERSPEED) && ep->dma &&
+                  (readl(&ep->regs->ep_rsp) & BIT(CLEAR_ENDPOINT_HALT)))) {
+
                 /* use DMA if the endpoint supports it, else pio */
-                else if (ep->dma)
+                if (ep->dma)
                         start_dma(ep, req);
                 else {
                         /* maybe there's no control data, just status ack */
@@ -1084,8 +1024,6 @@ dma_done(struct net2280_ep *ep,	struct net2280_request *req, u32 dmacount,
         done(ep, req, status);
 }
 
-static void restart_dma(struct net2280_ep *ep);
-
 static void scan_dma_completions(struct net2280_ep *ep)
 {
         /* only look at descriptors that were "naturally" retired,
@@ -1117,9 +1055,8 @@ static void scan_dma_completions(struct net2280_ep *ep)
                         dma_done(ep, req, tmp, 0);
                         break;
                 } else if (!ep->is_in &&
-                                (req->req.length % ep->ep.maxpacket) != 0) {
-                        if (ep->dev->quirks & PLX_SUPERSPEED)
-                                return dma_done(ep, req, tmp, 0);
+                           (req->req.length % ep->ep.maxpacket) &&
+                           !(ep->dev->quirks & PLX_SUPERSPEED)) {
 
                         tmp = readl(&ep->regs->ep_stat);
                         /* AVOID TROUBLE HERE by not issuing short reads from
@@ -1150,67 +1087,15 @@ static void scan_dma_completions(struct net2280_ep *ep)
 static void restart_dma(struct net2280_ep *ep)
 {
         struct net2280_request  *req;
-        u32                     dmactl = dmactl_default;
 
         if (ep->stopped)
                 return;
         req = list_entry(ep->queue.next, struct net2280_request, queue);
 
-        if (!use_dma_chaining) {
-                start_dma(ep, req);
-                return;
-        }
-
-        /* the 2280 will be processing the queue unless queue hiccups after
-         * the previous transfer:
-         *  IN:   wanted automagic zlp, head doesn't (or vice versa)
-         *        DMA_FIFO_VALIDATE doesn't init from dma descriptors.
-         *  OUT:  was "usb-short", we must restart.
-         */
-        if (ep->is_in && !req->valid) {
-                struct net2280_request  *entry, *prev = NULL;
-                int                     reqmode, done = 0;
-
-                ep_dbg(ep->dev, "%s dma hiccup td %p\n", ep->ep.name, req->td);
-                ep->in_fifo_validate = likely(req->req.zero ||
-                                (req->req.length % ep->ep.maxpacket) != 0);
-                if (ep->in_fifo_validate)
-                        dmactl |= BIT(DMA_FIFO_VALIDATE);
-                list_for_each_entry(entry, &ep->queue, queue) {
-                        __le32          dmacount;
-
-                        if (entry == req)
-                                continue;
-                        dmacount = entry->td->dmacount;
-                        if (!done) {
-                                reqmode = likely(entry->req.zero ||
-                                   (entry->req.length % ep->ep.maxpacket));
-                                if (reqmode == ep->in_fifo_validate) {
-                                        entry->valid = 1;
-                                        dmacount |= valid_bit;
-                                        entry->td->dmacount = dmacount;
-                                        prev = entry;
-                                        continue;
-                                } else {
-                                        /* force a hiccup */
-                                        prev->td->dmacount |= dma_done_ie;
-                                        done = 1;
-                                }
-                        }
-
-                        /* walk the rest of the queue so unlinks behave */
-                        entry->valid = 0;
-                        dmacount &= ~valid_bit;
-                        entry->td->dmacount = dmacount;
-                        prev = entry;
-                }
-        }
-
-        writel(0, &ep->dma->dmactl);
-        start_queue(ep, dmactl, req->td_dma);
+        start_dma(ep, req);
 }
 
-static void abort_dma_228x(struct net2280_ep *ep)
+static void abort_dma(struct net2280_ep *ep)
 {
         /* abort the current transfer */
         if (likely(!list_empty(&ep->queue))) {
@@ -1222,19 +1107,6 @@ static void abort_dma_228x(struct net2280_ep *ep)
         scan_dma_completions(ep);
 }
 
-static void abort_dma_338x(struct net2280_ep *ep)
-{
-        writel(BIT(DMA_ABORT), &ep->dma->dmastat);
-        spin_stop_dma(ep->dma);
-}
-
-static void abort_dma(struct net2280_ep *ep)
-{
-        if (ep->dev->quirks & PLX_LEGACY)
-                return abort_dma_228x(ep);
-        return abort_dma_338x(ep);
-}
-
 /* dequeue ALL requests */
 static void nuke(struct net2280_ep *ep)
 {
@@ -1306,25 +1178,6 @@ static int net2280_dequeue(struct usb_ep *_ep, struct usb_request *_req)
                         done(ep, req, -ECONNRESET);
                 }
                 req = NULL;
-
-        /* patch up hardware chaining data */
-        } else if (ep->dma && use_dma_chaining) {
-                if (req->queue.prev == ep->queue.next) {
-                        writel(le32_to_cpu(req->td->dmadesc),
-                                &ep->dma->dmadesc);
-                        if (req->td->dmacount & dma_done_ie)
-                                writel(readl(&ep->dma->dmacount) |
-                                                le32_to_cpu(dma_done_ie),
-                                        &ep->dma->dmacount);
-                } else {
-                        struct net2280_request  *prev;
-
-                        prev = list_entry(req->queue.prev,
-                                struct net2280_request, queue);
-                        prev->td->dmadesc = req->td->dmadesc;
-                        if (req->td->dmacount & dma_done_ie)
-                                prev->td->dmacount |= dma_done_ie;
-                }
         }
 
         if (req)
@@ -1512,10 +1365,10 @@ static int net2280_set_selfpowered(struct usb_gadget *_gadget, int value)
         tmp = readl(&dev->usb->usbctl);
         if (value) {
                 tmp |= BIT(SELF_POWERED_STATUS);
-                dev->selfpowered = 1;
+                _gadget->is_selfpowered = 1;
         } else {
                 tmp &= ~BIT(SELF_POWERED_STATUS);
-                dev->selfpowered = 0;
+                _gadget->is_selfpowered = 0;
         }
         writel(tmp, &dev->usb->usbctl);
         spin_unlock_irqrestore(&dev->lock, flags);
@@ -1604,14 +1457,11 @@ static ssize_t registers_show(struct device *_dev,
 
         /* Main Control Registers */
         t = scnprintf(next, size, "%s version " DRIVER_VERSION
-                        ", chiprev %04x, dma %s\n\n"
+                        ", chiprev %04x\n\n"
                         "devinit %03x fifoctl %08x gadget '%s'\n"
                         "pci irqenb0 %02x irqenb1 %08x "
                         "irqstat0 %04x irqstat1 %08x\n",
                         driver_name, dev->chiprev,
-                        use_dma
-                                ? (use_dma_chaining ? "chaining" : "enabled")
-                                : "disabled",
                         readl(&dev->regs->devinit),
                         readl(&dev->regs->fifoctl),
                         s,
@@ -1913,76 +1763,73 @@ static void defect7374_disable_data_eps(struct net2280 *dev)
 static void defect7374_enable_data_eps_zero(struct net2280 *dev)
 {
         u32 tmp = 0, tmp_reg;
-        u32 fsmvalue, scratch;
+        u32 scratch;
         int i;
         unsigned char ep_sel;
 
         scratch = get_idx_reg(dev->regs, SCRATCH);
-        fsmvalue = scratch & (0xf << DEFECT7374_FSM_FIELD);
+
+        WARN_ON((scratch & (0xf << DEFECT7374_FSM_FIELD))
+                == DEFECT7374_FSM_SS_CONTROL_READ);
+
         scratch &= ~(0xf << DEFECT7374_FSM_FIELD);
 
-        /*See if firmware needs to set up for workaround*/
-        if (fsmvalue != DEFECT7374_FSM_SS_CONTROL_READ) {
-                ep_warn(dev, "Operate Defect 7374 workaround soft this time");
-                ep_warn(dev, "It will operate on cold-reboot and SS connect");
-
-                /*GPEPs:*/
-                tmp = ((0 << ENDPOINT_NUMBER) | BIT(ENDPOINT_DIRECTION) |
-                       (2 << OUT_ENDPOINT_TYPE) | (2 << IN_ENDPOINT_TYPE) |
-                       ((dev->enhanced_mode) ?
-                       BIT(OUT_ENDPOINT_ENABLE) : BIT(ENDPOINT_ENABLE)) |
-                       BIT(IN_ENDPOINT_ENABLE));
-
-                for (i = 1; i < 5; i++)
-                        writel(tmp, &dev->ep[i].cfg->ep_cfg);
-
-                /* CSRIN, PCIIN, STATIN, RCIN*/
-                tmp = ((0 << ENDPOINT_NUMBER) | BIT(ENDPOINT_ENABLE));
-                writel(tmp, &dev->dep[1].dep_cfg);
-                writel(tmp, &dev->dep[3].dep_cfg);
-                writel(tmp, &dev->dep[4].dep_cfg);
-                writel(tmp, &dev->dep[5].dep_cfg);
-
-                /*Implemented for development and debug.
-                 * Can be refined/tuned later.*/
-                for (ep_sel = 0; ep_sel <= 21; ep_sel++) {
-                        /* Select an endpoint for subsequent operations: */
-                        tmp_reg = readl(&dev->plregs->pl_ep_ctrl);
-                        writel(((tmp_reg & ~0x1f) | ep_sel),
-                               &dev->plregs->pl_ep_ctrl);
-
-                        if (ep_sel == 1) {
-                                tmp =
-                                    (readl(&dev->plregs->pl_ep_ctrl) |
-                                     BIT(CLEAR_ACK_ERROR_CODE) | 0);
-                                writel(tmp, &dev->plregs->pl_ep_ctrl);
-                                continue;
-                        }
+        ep_warn(dev, "Operate Defect 7374 workaround soft this time");
+        ep_warn(dev, "It will operate on cold-reboot and SS connect");
 
-                        if (ep_sel == 0 || (ep_sel > 9 && ep_sel < 14) ||
-                                        ep_sel == 18  || ep_sel == 20)
-                                continue;
+        /*GPEPs:*/
+        tmp = ((0 << ENDPOINT_NUMBER) | BIT(ENDPOINT_DIRECTION) |
+                        (2 << OUT_ENDPOINT_TYPE) | (2 << IN_ENDPOINT_TYPE) |
+                        ((dev->enhanced_mode) ?
+                         BIT(OUT_ENDPOINT_ENABLE) : BIT(ENDPOINT_ENABLE)) |
+                        BIT(IN_ENDPOINT_ENABLE));
 
-                        tmp = (readl(&dev->plregs->pl_ep_cfg_4) |
-                                 BIT(NON_CTRL_IN_TOLERATE_BAD_DIR) | 0);
-                        writel(tmp, &dev->plregs->pl_ep_cfg_4);
+        for (i = 1; i < 5; i++)
+                writel(tmp, &dev->ep[i].cfg->ep_cfg);
 
-                        tmp = readl(&dev->plregs->pl_ep_ctrl) &
-                                ~BIT(EP_INITIALIZED);
-                        writel(tmp, &dev->plregs->pl_ep_ctrl);
+        /* CSRIN, PCIIN, STATIN, RCIN*/
+        tmp = ((0 << ENDPOINT_NUMBER) | BIT(ENDPOINT_ENABLE));
+        writel(tmp, &dev->dep[1].dep_cfg);
+        writel(tmp, &dev->dep[3].dep_cfg);
+        writel(tmp, &dev->dep[4].dep_cfg);
+        writel(tmp, &dev->dep[5].dep_cfg);
+
+        /*Implemented for development and debug.
+         * Can be refined/tuned later.*/
+        for (ep_sel = 0; ep_sel <= 21; ep_sel++) {
+                /* Select an endpoint for subsequent operations: */
+                tmp_reg = readl(&dev->plregs->pl_ep_ctrl);
+                writel(((tmp_reg & ~0x1f) | ep_sel),
+                                &dev->plregs->pl_ep_ctrl);
 
+                if (ep_sel == 1) {
+                        tmp =
+                                (readl(&dev->plregs->pl_ep_ctrl) |
+                                 BIT(CLEAR_ACK_ERROR_CODE) | 0);
+                        writel(tmp, &dev->plregs->pl_ep_ctrl);
+                        continue;
                 }
 
-                /* Set FSM to focus on the first Control Read:
-                 * - Tip: Connection speed is known upon the first
-                 * setup request.*/
-                scratch |= DEFECT7374_FSM_WAITING_FOR_CONTROL_READ;
-                set_idx_reg(dev->regs, SCRATCH, scratch);
+                if (ep_sel == 0 || (ep_sel > 9 && ep_sel < 14) ||
+                                ep_sel == 18  || ep_sel == 20)
+                        continue;
+
+                tmp = (readl(&dev->plregs->pl_ep_cfg_4) |
+                                BIT(NON_CTRL_IN_TOLERATE_BAD_DIR) | 0);
+                writel(tmp, &dev->plregs->pl_ep_cfg_4);
+
+                tmp = readl(&dev->plregs->pl_ep_ctrl) &
+                        ~BIT(EP_INITIALIZED);
+                writel(tmp, &dev->plregs->pl_ep_ctrl);
 
-        } else{
-                ep_warn(dev, "Defect 7374 workaround soft will NOT operate");
-                ep_warn(dev, "It will operate on cold-reboot and SS connect");
         }
+
+        /* Set FSM to focus on the first Control Read:
+         * - Tip: Connection speed is known upon the first
+         * setup request.*/
+        scratch |= DEFECT7374_FSM_WAITING_FOR_CONTROL_READ;
+        set_idx_reg(dev->regs, SCRATCH, scratch);
+
 }
 
 /* keeping it simple:
@@ -2033,21 +1880,13 @@ static void usb_reset_228x(struct net2280 *dev)
 static void usb_reset_338x(struct net2280 *dev)
 {
         u32 tmp;
-        u32 fsmvalue;
 
         dev->gadget.speed = USB_SPEED_UNKNOWN;
         (void)readl(&dev->usb->usbctl);
 
         net2280_led_init(dev);
 
-        fsmvalue = get_idx_reg(dev->regs, SCRATCH) &
-                        (0xf << DEFECT7374_FSM_FIELD);
-
-        /* See if firmware needs to set up for workaround: */
-        if (fsmvalue != DEFECT7374_FSM_SS_CONTROL_READ) {
-                ep_info(dev, "%s: Defect 7374 FsmValue 0x%08x\n", __func__,
-                     fsmvalue);
-        } else {
+        if (dev->bug7734_patched) {
                 /* disable automatic responses, and irqs */
                 writel(0, &dev->usb->stdrsp);
                 writel(0, &dev->regs->pciirqenb0);
@@ -2064,7 +1903,7 @@ static void usb_reset_338x(struct net2280 *dev)
 
         writel(~0, &dev->regs->irqstat0), writel(~0, &dev->regs->irqstat1);
 
-        if (fsmvalue == DEFECT7374_FSM_SS_CONTROL_READ) {
+        if (dev->bug7734_patched) {
                 /* reset, and enable pci */
                 tmp = readl(&dev->regs->devinit) |
                     BIT(PCI_ENABLE) |
@@ -2093,10 +1932,6 @@ static void usb_reset(struct net2280 *dev)
 static void usb_reinit_228x(struct net2280 *dev)
 {
         u32     tmp;
-        int     init_dma;
-
-        /* use_dma changes are ignored till next device re-init */
-        init_dma = use_dma;
 
         /* basic endpoint init */
         for (tmp = 0; tmp < 7; tmp++) {
@@ -2108,8 +1943,7 @@ static void usb_reinit_228x(struct net2280 *dev)
 
                 if (tmp > 0 && tmp <= 4) {
                         ep->fifo_size = 1024;
-                        if (init_dma)
-                                ep->dma = &dev->dma[tmp - 1];
+                        ep->dma = &dev->dma[tmp - 1];
                 } else
                         ep->fifo_size = 64;
                 ep->regs = &dev->epregs[tmp];
@@ -2133,17 +1967,12 @@ static void usb_reinit_228x(struct net2280 *dev)
 
 static void usb_reinit_338x(struct net2280 *dev)
 {
-        int init_dma;
         int i;
         u32 tmp, val;
-        u32 fsmvalue;
         static const u32 ne[9] = { 0, 1, 2, 3, 4, 1, 2, 3, 4 };
         static const u32 ep_reg_addr[9] = { 0x00, 0xC0, 0x00, 0xC0, 0x00,
                                                 0x00, 0xC0, 0x00, 0xC0 };
 
-        /* use_dma changes are ignored till next device re-init */
-        init_dma = use_dma;
-
         /* basic endpoint init */
         for (i = 0; i < dev->n_ep; i++) {
                 struct net2280_ep *ep = &dev->ep[i];
@@ -2152,7 +1981,7 @@ static void usb_reinit_338x(struct net2280 *dev)
                 ep->dev = dev;
                 ep->num = i;
 
-                if (i > 0 && i <= 4 && init_dma)
+                if (i > 0 && i <= 4)
                         ep->dma = &dev->dma[i - 1];
 
                 if (dev->enhanced_mode) {
@@ -2177,14 +2006,7 @@ static void usb_reinit_338x(struct net2280 *dev)
         dev->ep[0].stopped = 0;
 
         /* Link layer set up */
-        fsmvalue = get_idx_reg(dev->regs, SCRATCH) &
-                                (0xf << DEFECT7374_FSM_FIELD);
-
-        /* See if driver needs to set up for workaround: */
-        if (fsmvalue != DEFECT7374_FSM_SS_CONTROL_READ)
-                ep_info(dev, "%s: Defect 7374 FsmValue %08x\n",
-                                                __func__, fsmvalue);
-        else {
+        if (dev->bug7734_patched) {
                 tmp = readl(&dev->usb_ext->usbctl2) &
                     ~(BIT(U1_ENABLE) | BIT(U2_ENABLE) | BIT(LTM_ENABLE));
                 writel(tmp, &dev->usb_ext->usbctl2);
@@ -2291,15 +2113,8 @@ static void ep0_start_228x(struct net2280 *dev)
 
 static void ep0_start_338x(struct net2280 *dev)
 {
-        u32 fsmvalue;
-
-        fsmvalue = get_idx_reg(dev->regs, SCRATCH) &
-                        (0xf << DEFECT7374_FSM_FIELD);
 
-        if (fsmvalue != DEFECT7374_FSM_SS_CONTROL_READ)
-                ep_info(dev, "%s: Defect 7374 FsmValue %08x\n", __func__,
-                     fsmvalue);
-        else
+        if (dev->bug7734_patched)
                 writel(BIT(CLEAR_NAK_OUT_PACKETS_MODE) |
                        BIT(SET_EP_HIDE_STATUS_PHASE),
                        &dev->epregs[0].ep_rsp);
@@ -2382,16 +2197,12 @@ static int net2280_start(struct usb_gadget *_gadget,
         if (retval)
                 goto err_func;
 
-        /* Enable force-full-speed testing mode, if desired */
-        if (full_speed && (dev->quirks & PLX_LEGACY))
-                writel(BIT(FORCE_FULL_SPEED_MODE), &dev->usb->xcvrdiag);
-
-        /* ... then enable host detection and ep0; and we're ready
+        /* enable host detection and ep0; and we're ready
          * for set_configuration as well as eventual disconnect.
          */
         net2280_led_active(dev, 1);
 
-        if (dev->quirks & PLX_SUPERSPEED)
+        if ((dev->quirks & PLX_SUPERSPEED) && !dev->bug7734_patched)
                 defect7374_enable_data_eps_zero(dev);
 
         ep0_start(dev);
@@ -2444,10 +2255,6 @@ static int net2280_stop(struct usb_gadget *_gadget)
 
         net2280_led_active(dev, 0);
 
-        /* Disable full-speed test mode */
-        if (dev->quirks & PLX_LEGACY)
-                writel(0, &dev->usb->xcvrdiag);
-
         device_remove_file(&dev->pdev->dev, &dev_attr_function);
         device_remove_file(&dev->pdev->dev, &dev_attr_queues);
 
@@ -2478,10 +2285,10 @@ static void handle_ep_small(struct net2280_ep *ep)
         /* ack all, and handle what we care about */
         t = readl(&ep->regs->ep_stat);
         ep->irqs++;
-#if 0
+
         ep_vdbg(ep->dev, "%s ack ep_stat %08x, req %p\n",
-                        ep->ep.name, t, req ? &req->req : 0);
-#endif
+                        ep->ep.name, t, req ? &req->req : NULL);
+
         if (!ep->is_in || (ep->dev->quirks & PLX_2280))
                 writel(t & ~BIT(NAK_OUT_PACKETS), &ep->regs->ep_stat);
         else
@@ -2717,6 +2524,7 @@ static void defect7374_workaround(struct net2280 *dev, struct usb_ctrlrequest r)
                  * run after the next USB connection.
                  */
                 scratch |= DEFECT7374_FSM_NON_SS_CONTROL_READ;
+                dev->bug7734_patched = 1;
                 goto restore_data_eps;
         }
 
@@ -2730,6 +2538,7 @@ static void defect7374_workaround(struct net2280 *dev, struct usb_ctrlrequest r)
                 if ((state >= (ACK_GOOD_NORMAL << STATE)) &&
                         (state <= (ACK_GOOD_MORE_ACKS_TO_COME << STATE))) {
                         scratch |= DEFECT7374_FSM_SS_CONTROL_READ;
+                        dev->bug7734_patched = 1;
                         break;
                 }
 
@@ -2766,80 +2575,19 @@ restore_data_eps:
         return;
 }
 
-static void ep_stall(struct net2280_ep *ep, int stall)
+static void ep_clear_seqnum(struct net2280_ep *ep)
 {
         struct net2280 *dev = ep->dev;
         u32 val;
         static const u32 ep_pl[9] = { 0, 3, 4, 7, 8, 2, 5, 6, 9 };
 
-        if (stall) {
-                writel(BIT(SET_ENDPOINT_HALT) |
-                       /* BIT(SET_NAK_PACKETS) | */
-                       BIT(CLEAR_CONTROL_STATUS_PHASE_HANDSHAKE),
-                       &ep->regs->ep_rsp);
-                ep->is_halt = 1;
-        } else {
-                if (dev->gadget.speed == USB_SPEED_SUPER) {
-                        /*
-                         * Workaround for SS SeqNum not cleared via
-                         * Endpoint Halt (Clear) bit. select endpoint
-                         */
-                        val = readl(&dev->plregs->pl_ep_ctrl);
-                        val = (val & ~0x1f) | ep_pl[ep->num];
-                        writel(val, &dev->plregs->pl_ep_ctrl);
-
-                        val |= BIT(SEQUENCE_NUMBER_RESET);
-                        writel(val, &dev->plregs->pl_ep_ctrl);
-                }
-                val = readl(&ep->regs->ep_rsp);
-                val |= BIT(CLEAR_ENDPOINT_HALT) |
-                        BIT(CLEAR_ENDPOINT_TOGGLE);
-                writel(val,
-                       /* | BIT(CLEAR_NAK_PACKETS),*/
-                       &ep->regs->ep_rsp);
-                ep->is_halt = 0;
-                val = readl(&ep->regs->ep_rsp);
-        }
-}
-
-static void ep_stdrsp(struct net2280_ep *ep, int value, int wedged)
-{
-        /* set/clear, then synch memory views with the device */
-        if (value) {
-                ep->stopped = 1;
-                if (ep->num == 0)
-                        ep->dev->protocol_stall = 1;
-                else {
-                        if (ep->dma)
-                                ep_stop_dma(ep);
-                        ep_stall(ep, true);
-                }
-
-                if (wedged)
-                        ep->wedged = 1;
-        } else {
-                ep->stopped = 0;
-                ep->wedged = 0;
-
-                ep_stall(ep, false);
+        val = readl(&dev->plregs->pl_ep_ctrl) & ~0x1f;
+        val |= ep_pl[ep->num];
+        writel(val, &dev->plregs->pl_ep_ctrl);
+        val |= BIT(SEQUENCE_NUMBER_RESET);
+        writel(val, &dev->plregs->pl_ep_ctrl);
 
-                /* Flush the queue */
-                if (!list_empty(&ep->queue)) {
-                        struct net2280_request *req =
-                            list_entry(ep->queue.next, struct net2280_request,
-                                       queue);
-                        if (ep->dma)
-                                resume_dma(ep);
-                        else {
-                                if (ep->is_in)
-                                        write_fifo(ep, &req->req);
-                                else {
-                                        if (read_fifo(ep, req))
-                                                done(ep, req, 0);
-                                }
-                        }
-                }
-        }
+        return;
 }
 
 static void handle_stat0_irqs_superspeed(struct net2280 *dev,
@@ -2863,7 +2611,7 @@ static void handle_stat0_irqs_superspeed(struct net2280 *dev,
                 switch (r.bRequestType) {
                 case (USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE):
                         status = dev->wakeup_enable ? 0x02 : 0x00;
-                        if (dev->selfpowered)
+                        if (dev->gadget.is_selfpowered)
                                 status |= BIT(0);
                         status |= (dev->u1_enable << 2 | dev->u2_enable << 3 |
                                                         dev->ltm_enable << 4);
@@ -2940,7 +2688,12 @@ static void handle_stat0_irqs_superspeed(struct net2280 *dev,
                         if (w_value != USB_ENDPOINT_HALT)
                                 goto do_stall3;
                         ep_vdbg(dev, "%s clear halt\n", e->ep.name);
-                        ep_stall(e, false);
+                        /*
+                         * Workaround for SS SeqNum not cleared via
+                         * Endpoint Halt (Clear) bit. select endpoint
+                         */
+                        ep_clear_seqnum(e);
+                        clear_halt(e);
                         if (!list_empty(&e->queue) && e->td_dma)
                                 restart_dma(e);
                         allow_status(ep);
@@ -2998,7 +2751,14 @@ static void handle_stat0_irqs_superspeed(struct net2280 *dev,
                         e = get_ep_by_addr(dev, w_index);
                         if (!e || (w_value != USB_ENDPOINT_HALT))
                                 goto do_stall3;
-                        ep_stdrsp(e, true, false);
+                        ep->stopped = 1;
+                        if (ep->num == 0)
+                                ep->dev->protocol_stall = 1;
+                        else {
+                                if (ep->dma)
+                                        abort_dma(ep);
+                                set_halt(ep);
+                        }
                         allow_status_338x(ep);
                         break;
 
@@ -3026,7 +2786,7 @@ do_stall3:
                                 r.bRequestType, r.bRequest, tmp);
                 dev->protocol_stall = 1;
                 /* TD 9.9 Halt Endpoint test. TD 9.22 Set feature test */
-                ep_stall(ep, true);
+                set_halt(ep);
         }
 
 next_endpoints3:
@@ -3091,9 +2851,7 @@ static void handle_stat0_irqs(struct net2280 *dev, u32 stat)
                 }
                 ep->stopped = 0;
                 dev->protocol_stall = 0;
-                if (dev->quirks & PLX_SUPERSPEED)
-                        ep->is_halt = 0;
-                else{
+                if (!(dev->quirks & PLX_SUPERSPEED)) {
                         if (ep->dev->quirks & PLX_2280)
                                 tmp = BIT(FIFO_OVERFLOW) |
                                     BIT(FIFO_UNDERFLOW);
@@ -3120,7 +2878,7 @@ static void handle_stat0_irqs(struct net2280 *dev, u32 stat)
                 cpu_to_le32s(&u.raw[0]);
                 cpu_to_le32s(&u.raw[1]);
 
-                if (dev->quirks & PLX_SUPERSPEED)
+                if ((dev->quirks & PLX_SUPERSPEED) && !dev->bug7734_patched)
                         defect7374_workaround(dev, u.r);
 
                 tmp = 0;
@@ -3423,17 +3181,12 @@ static void handle_stat1_irqs(struct net2280 *dev, u32 stat)
                                 continue;
                 }
 
-                /* chaining should stop on abort, short OUT from fifo,
-                 * or (stat0 codepath) short OUT transfer.
-                 */
-                if (!use_dma_chaining) {
-                        if (!(tmp & BIT(DMA_TRANSACTION_DONE_INTERRUPT))) {
-                                ep_dbg(ep->dev, "%s no xact done? %08x\n",
-                                        ep->ep.name, tmp);
-                                continue;
-                        }
-                        stop_dma(ep->dma);
+                if (!(tmp & BIT(DMA_TRANSACTION_DONE_INTERRUPT))) {
+                        ep_dbg(ep->dev, "%s no xact done? %08x\n",
+                                ep->ep.name, tmp);
+                        continue;
                 }
+                stop_dma(ep->dma);
 
                 /* OUT transfers terminate when the data from the
                  * host is in our memory.  Process whatever's done.
@@ -3448,30 +3201,9 @@ static void handle_stat1_irqs(struct net2280 *dev, u32 stat)
                 scan_dma_completions(ep);
 
                 /* disable dma on inactive queues; else maybe restart */
-                if (list_empty(&ep->queue)) {
-                        if (use_dma_chaining)
-                                stop_dma(ep->dma);
-                } else {
+                if (!list_empty(&ep->queue)) {
                         tmp = readl(&dma->dmactl);
-                        if (!use_dma_chaining || (tmp & BIT(DMA_ENABLE)) == 0)
-                                restart_dma(ep);
-                        else if (ep->is_in && use_dma_chaining) {
-                                struct net2280_request  *req;
-                                __le32                  dmacount;
-
-                                /* the descriptor at the head of the chain
-                                 * may still have VALID_BIT clear; that's
-                                 * used to trigger changing DMA_FIFO_VALIDATE
-                                 * (affects automagic zlp writes).
-                                 */
-                                req = list_entry(ep->queue.next,
-                                                struct net2280_request, queue);
-                                dmacount = req->td->dmacount;
-                                dmacount &= cpu_to_le32(BIT(VALID_BIT) |
-                                                DMA_BYTE_COUNT_MASK);
-                                if (dmacount && (dmacount & valid_bit) == 0)
-                                        restart_dma(ep);
-                        }
+                        restart_dma(ep);
                 }
                 ep->irqs++;
         }
@@ -3556,7 +3288,7 @@ static void net2280_remove(struct pci_dev *pdev)
         }
         if (dev->got_irq)
                 free_irq(pdev->irq, dev);
-        if (use_msi && dev->quirks & PLX_SUPERSPEED)
+        if (dev->quirks & PLX_SUPERSPEED)
                 pci_disable_msi(pdev);
         if (dev->regs)
                 iounmap(dev->regs);
@@ -3581,9 +3313,6 @@ static int net2280_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         void                    __iomem *base = NULL;
         int                     retval, i;
 
-        if (!use_dma)
-                use_dma_chaining = 0;
-
         /* alloc, and start init */
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         if (dev == NULL) {
@@ -3663,9 +3392,12 @@ static int net2280_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 fsmvalue = get_idx_reg(dev->regs, SCRATCH) &
                                         (0xf << DEFECT7374_FSM_FIELD);
                 /* See if firmware needs to set up for workaround: */
-                if (fsmvalue == DEFECT7374_FSM_SS_CONTROL_READ)
+                if (fsmvalue == DEFECT7374_FSM_SS_CONTROL_READ) {
+                        dev->bug7734_patched = 1;
                         writel(0, &dev->usb->usbctl);
-        } else{
+                } else
+                        dev->bug7734_patched = 0;
+        } else {
                 dev->enhanced_mode = 0;
                 dev->n_ep = 7;
                 /* put into initial config, link up all endpoints */
@@ -3682,7 +3414,7 @@ static int net2280_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 goto done;
         }
 
-        if (use_msi && (dev->quirks & PLX_SUPERSPEED))
+        if (dev->quirks & PLX_SUPERSPEED)
                 if (pci_enable_msi(pdev))
                         ep_err(dev, "Failed to enable MSI mode\n");
 
@@ -3741,9 +3473,7 @@ static int net2280_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         ep_info(dev, "%s\n", driver_desc);
         ep_info(dev, "irq %d, pci mem %p, chip rev %04x\n",
                         pdev->irq, base, dev->chiprev);
-        ep_info(dev, "version: " DRIVER_VERSION "; dma %s %s\n",
-                use_dma ? (use_dma_chaining ? "chaining" : "enabled")
-                        : "disabled",
+        ep_info(dev, "version: " DRIVER_VERSION "; %s\n",
                 dev->enhanced_mode ? "enhanced mode" : "legacy mode");
         retval = device_create_file(&pdev->dev, &dev_attr_registers);
         if (retval)
@@ -3776,9 +3506,6 @@ static void net2280_shutdown(struct pci_dev *pdev)
         /* disable the pullup so the host will think we're gone */
         writel(0, &dev->usb->usbctl);
 
-        /* Disable full-speed test mode */
-        if (dev->quirks & PLX_LEGACY)
-                writel(0, &dev->usb->xcvrdiag);
 }