Lines Matching refs:ep
87 EP_INFO("ep-a",
89 EP_INFO("ep-b",
91 EP_INFO("ep-c",
93 EP_INFO("ep-d",
95 EP_INFO("ep-e",
97 EP_INFO("ep-f",
99 EP_INFO("ep-g",
101 EP_INFO("ep-h",
126 /* mode 0 == ep-{a,b,c,d} 1K fifo each
127 * mode 1 == ep-{a,b} 2K fifo each, ep-{c,d} unavailable
128 * mode 2 == ep-a 2K fifo, ep-{b,c} 1K each, ep-d unavailable
162 static void ep_clear_seqnum(struct net2280_ep *ep);
168 static inline void enable_pciirqenb(struct net2280_ep *ep)
170 u32 tmp = readl(&ep->dev->regs->pciirqenb0);
172 if (ep->dev->quirks & PLX_LEGACY)
173 tmp |= BIT(ep->num);
175 tmp |= BIT(ep_bit[ep->num]);
176 writel(tmp, &ep->dev->regs->pciirqenb0);
185 struct net2280_ep *ep;
193 ep = container_of(_ep, struct net2280_ep, ep);
194 if (!_ep || !desc || ep->desc || _ep->name == ep0name ||
199 dev = ep->dev;
216 ep->is_in = !!usb_endpoint_dir_in(desc);
217 if (dev->enhanced_mode && ep->is_in && ep_key[ep->num]) {
223 /* sanity check ep-e/ep-f since their fifos are small */
225 if (ep->num > 4 && max > 64 && (dev->quirks & PLX_LEGACY)) {
232 ep->desc = desc;
235 ep->stopped = 0;
236 ep->wedged = 0;
237 ep->out_overflow = 0;
240 set_max_speed(ep, max);
243 writel(BIT(FIFO_FLUSH), &ep->regs->ep_stat);
246 tmp = readl(&ep->cfg->ep_cfg);
247 /* If USB ep number doesn't match hardware ep number */
253 if (ep->is_in)
265 &ep->regs->ep_rsp);
276 ep->is_iso = (type == USB_ENDPOINT_XFER_ISOC);
284 ep->is_in = (tmp & USB_DIR_IN) != 0;
287 if (dev->enhanced_mode && ep->is_in) {
293 tmp |= (ep->is_in << ENDPOINT_DIRECTION);
299 tmp |= (ep->ep.maxburst << MAX_BURST_SIZE);
306 if (!ep->is_in)
307 writel(BIT(SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
313 BIT(CLEAR_NAK_OUT_PACKETS_MODE), &ep->regs->ep_rsp);
317 ep_clear_seqnum(ep);
318 writel(tmp, &ep->cfg->ep_cfg);
321 if (!ep->dma) { /* pio, per-packet */
322 enable_pciirqenb(ep);
327 tmp |= readl(&ep->regs->ep_irqenb);
328 writel(tmp, &ep->regs->ep_irqenb);
330 tmp = BIT((8 + ep->num)); /* completion */
340 writel(tmp, &ep->regs->ep_irqenb);
342 enable_pciirqenb(ep);
347 ep_dbg(dev, "enabled %s (ep%d%s-%s) %s max %04x\n",
350 ep->dma ? "dma" : "pio", max);
357 dev_err(&ep->dev->pdev->dev, "%s: error=%d\n", __func__, ret);
379 struct net2280_ep *ep)
383 ep->desc = NULL;
384 INIT_LIST_HEAD(&ep->queue);
386 usb_ep_set_maxpacket_limit(&ep->ep, ~0);
387 ep->ep.ops = &net2280_ep_ops;
390 if (ep->dma) {
391 writel(0, &ep->dma->dmactl);
395 &ep->dma->dmastat);
398 tmp &= ~BIT(ep->num);
402 tmp &= ~BIT((8 + ep->num)); /* completion */
405 writel(0, &ep->regs->ep_irqenb);
410 if (!ep->is_in || (ep->dev->quirks & PLX_2280)) {
423 if (ep->num != 0) {
427 writel(tmp, &ep->regs->ep_rsp);
430 if (ep->dev->quirks & PLX_2280)
449 &ep->regs->ep_stat);
455 struct net2280_ep *ep)
459 ep->desc = NULL;
460 INIT_LIST_HEAD(&ep->queue);
462 usb_ep_set_maxpacket_limit(&ep->ep, ~0);
463 ep->ep.ops = &net2280_ep_ops;
466 if (ep->dma) {
467 writel(0, &ep->dma->dmactl);
473 &ep->dma->dmastat);
475 dmastat = readl(&ep->dma->dmastat);
477 ep_warn(ep->dev, "The dmastat return = %x!!\n",
479 writel(0x5a, &ep->dma->dmastat);
483 tmp &= ~BIT(ep_bit[ep->num]);
486 if (ep->num < 5) {
488 tmp &= ~BIT((8 + ep->num)); /* completion */
492 writel(0, &ep->regs->ep_irqenb);
500 BIT(DATA_IN_TOKEN_INTERRUPT), &ep->regs->ep_stat);
502 tmp = readl(&ep->cfg->ep_cfg);
503 if (ep->is_in)
507 writel(tmp, &ep->cfg->ep_cfg);
514 struct net2280_ep *ep;
517 ep = container_of(_ep, struct net2280_ep, ep);
519 pr_err("%s: Invalid ep=%p\n", __func__, _ep);
522 spin_lock_irqsave(&ep->dev->lock, flags);
523 nuke(ep);
525 if (ep->dev->quirks & PLX_PCIE)
526 ep_reset_338x(ep->dev->regs, ep);
528 ep_reset_228x(ep->dev->regs, ep);
530 ep_vdbg(ep->dev, "disabled %s %s\n",
531 ep->dma ? "dma" : "pio", _ep->name);
534 (void)readl(&ep->cfg->ep_cfg);
536 if (!ep->dma && ep->num >= 1 && ep->num <= 4)
537 ep->dma = &ep->dev->dma[ep->num - 1];
539 spin_unlock_irqrestore(&ep->dev->lock, flags);
548 struct net2280_ep *ep;
552 pr_err("%s: Invalid ep\n", __func__);
555 ep = container_of(_ep, struct net2280_ep, ep);
564 if (ep->dma) {
567 td = dma_pool_alloc(ep->dev->requests, gfp_flags,
582 struct net2280_ep *ep;
585 ep = container_of(_ep, struct net2280_ep, ep);
587 dev_err(&ep->dev->pdev->dev, "%s: Invalid ep=%p or req=%p\n",
595 dma_pool_free(ep->dev->requests, req->td, req->td_dma);
604 * NOTE: pio with ep-a..ep-d could stuff multiple packets into the fifo
606 * one packet. ep-a..ep-d should use dma instead.
608 static void write_fifo(struct net2280_ep *ep, struct usb_request *req)
610 struct net2280_ep_regs __iomem *regs = ep->regs;
627 count = ep->ep.maxpacket;
631 ep_vdbg(ep->dev, "write %s fifo (IN) %d bytes%s req %p\n",
632 ep->ep.name, count,
633 (count != ep->ep.maxpacket) ? " (short)" : "",
651 if (count || total < ep->ep.maxpacket) {
654 set_fifo_bytecount(ep, count & 0x03);
668 static void out_flush(struct net2280_ep *ep)
673 statp = &ep->regs->ep_stat;
677 ep_dbg(ep->dev, "%s %s %08x !NAK\n",
678 ep->ep.name, __func__, tmp);
679 writel(BIT(SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
691 ep->dev->gadget.speed == USB_SPEED_FULL) {
705 * for ep-a..ep-d this will read multiple packets out when they
708 static int read_fifo(struct net2280_ep *ep, struct net2280_request *req)
710 struct net2280_ep_regs __iomem *regs = ep->regs;
718 if (ep->dev->chiprev == 0x0100 &&
719 ep->dev->gadget.speed == USB_SPEED_FULL) {
721 tmp = readl(&ep->regs->ep_stat);
725 start_out_naking(ep);
738 tmp = readl(&ep->regs->ep_stat);
748 if ((tmp % ep->ep.maxpacket) != 0) {
749 ep_err(ep->dev,
751 ep->ep.name, count, tmp);
762 is_short = (count == 0) || ((count % ep->ep.maxpacket) != 0);
764 ep_vdbg(ep->dev, "read %s fifo (OUT) %d bytes%s%s%s req %p %d/%d\n",
765 ep->ep.name, count, is_short ? " (short)" : "",
785 out_flush(ep);
787 writel(BIT(CLEAR_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
788 (void) readl(&ep->regs->ep_rsp);
795 static void fill_dma_desc(struct net2280_ep *ep,
806 if (ep->is_in)
808 if ((!ep->is_in && (dmacount % ep->ep.maxpacket) != 0) ||
809 !(ep->dev->quirks & PLX_2280))
820 /* 2280 may be polling VALID_BIT through ep->dma->dmadesc */
847 static void start_queue(struct net2280_ep *ep, u32 dmactl, u32 td_dma)
849 struct net2280_dma_regs __iomem *dma = ep->dma;
850 unsigned int tmp = BIT(VALID_BIT) | (ep->is_in << DMA_DIRECTION);
852 if (!(ep->dev->quirks & PLX_2280))
859 if (ep->dev->quirks & PLX_PCIE)
864 (void) readl(&ep->dev->pci->pcimstctl);
869 static void start_dma(struct net2280_ep *ep, struct net2280_request *req)
872 struct net2280_dma_regs __iomem *dma = ep->dma;
878 writel(0, &ep->dma->dmactl);
881 if (!ep->is_in && (readl(&ep->regs->ep_stat) &
884 &ep->regs->ep_stat);
886 tmp = readl(&ep->regs->ep_avail);
905 stop_out_naking(ep);
914 if (ep->is_in) {
915 if (likely((req->req.length % ep->ep.maxpacket) ||
918 ep->in_fifo_validate = 1;
920 ep->in_fifo_validate = 0;
924 req->td->dmadesc = cpu_to_le32 (ep->td_dma);
925 fill_dma_desc(ep, req, 1);
929 start_queue(ep, tmp, req->td_dma);
933 queue_dma(struct net2280_ep *ep, struct net2280_request *req, int valid)
939 end = ep->dummy;
940 ep->dummy = req->td;
943 tmp = ep->td_dma;
944 ep->td_dma = req->td_dma;
947 end->dmadesc = cpu_to_le32 (ep->td_dma);
949 fill_dma_desc(ep, req, valid);
953 done(struct net2280_ep *ep, struct net2280_request *req, int status)
956 unsigned stopped = ep->stopped;
965 dev = ep->dev;
966 if (ep->dma)
967 usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
971 ep->ep.name, &req->req, status,
975 ep->stopped = 1;
977 usb_gadget_giveback_request(&ep->ep, &req->req);
979 ep->stopped = stopped;
988 struct net2280_ep *ep;
996 ep = container_of(_ep, struct net2280_ep, ep);
997 if (!_ep || (!ep->desc && ep->num != 0)) {
998 pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
1011 dev = ep->dev;
1018 if (ep->dma && _req->length == 0) {
1024 if (ep->dma) {
1026 ep->is_in);
1040 if (list_empty(&ep->queue) && !ep->stopped &&
1041 !((dev->quirks & PLX_PCIE) && ep->dma &&
1042 (readl(&ep->regs->ep_rsp) & BIT(CLEAR_ENDPOINT_HALT)))) {
1045 if (ep->dma)
1046 start_dma(ep, req);
1049 if (ep->num == 0 && _req->length == 0) {
1050 allow_status(ep);
1051 done(ep, req, 0);
1052 ep_vdbg(dev, "%s status ack\n", ep->ep.name);
1057 if (ep->is_in)
1058 write_fifo(ep, _req);
1063 s = readl(&ep->regs->ep_stat);
1071 if (read_fifo(ep, req) &&
1072 ep->num == 0) {
1073 done(ep, req, 0);
1074 allow_status(ep);
1077 } else if (read_fifo(ep, req) &&
1078 ep->num != 0) {
1079 done(ep, req, 0);
1082 s = readl(&ep->regs->ep_stat);
1088 &ep->regs->ep_rsp);
1092 } else if (ep->dma) {
1095 if (ep->is_in) {
1102 (req->req.length % ep->ep.maxpacket));
1103 if (expect != ep->in_fifo_validate)
1106 queue_dma(ep, req, valid);
1110 ep->responded = 1;
1112 list_add_tail(&req->queue, &ep->queue);
1120 dev_err(&ep->dev->pdev->dev, "%s: error=%d\n", __func__, ret);
1125 dma_done(struct net2280_ep *ep, struct net2280_request *req, u32 dmacount,
1129 done(ep, req, status);
1132 static int scan_dma_completions(struct net2280_ep *ep)
1139 while (!list_empty(&ep->queue)) {
1143 req = list_entry(ep->queue.next,
1158 u32 const ep_dmacount = readl(&ep->dma->dmacount);
1163 dma_done(ep, req, req_dma_count, 0);
1166 } else if (!ep->is_in &&
1167 (req->req.length % ep->ep.maxpacket) &&
1168 !(ep->dev->quirks & PLX_PCIE)) {
1170 u32 const ep_stat = readl(&ep->regs->ep_stat);
1176 ep_warn(ep->dev, "%s lost packet sync!\n",
1177 ep->ep.name);
1180 u32 const ep_avail = readl(&ep->regs->ep_avail);
1183 ep->out_overflow = 1;
1184 ep_dbg(ep->dev,
1186 ep->ep.name, ep_avail,
1192 dma_done(ep, req, req_dma_count, 0);
1199 static void restart_dma(struct net2280_ep *ep)
1203 if (ep->stopped)
1205 req = list_entry(ep->queue.next, struct net2280_request, queue);
1207 start_dma(ep, req);
1210 static void abort_dma(struct net2280_ep *ep)
1213 if (likely(!list_empty(&ep->queue))) {
1215 writel(BIT(DMA_ABORT), &ep->dma->dmastat);
1216 spin_stop_dma(ep->dma);
1218 stop_dma(ep->dma);
1219 scan_dma_completions(ep);
1223 static void nuke(struct net2280_ep *ep)
1228 ep->stopped = 1;
1229 if (ep->dma)
1230 abort_dma(ep);
1231 while (!list_empty(&ep->queue)) {
1232 req = list_entry(ep->queue.next,
1235 done(ep, req, -ESHUTDOWN);
1242 struct net2280_ep *ep;
1248 ep = container_of(_ep, struct net2280_ep, ep);
1249 if (!_ep || (!ep->desc && ep->num != 0) || !_req) {
1250 pr_err("%s: Invalid ep=%p or ep->desc or req=%p\n",
1255 spin_lock_irqsave(&ep->dev->lock, flags);
1256 stopped = ep->stopped;
1260 ep->stopped = 1;
1261 if (ep->dma) {
1262 dmactl = readl(&ep->dma->dmactl);
1264 stop_dma(ep->dma);
1265 scan_dma_completions(ep);
1269 list_for_each_entry(req, &ep->queue, queue) {
1274 ep->stopped = stopped;
1275 spin_unlock_irqrestore(&ep->dev->lock, flags);
1276 ep_dbg(ep->dev, "%s: Request mismatch\n", __func__);
1281 if (ep->queue.next == &req->queue) {
1282 if (ep->dma) {
1283 ep_dbg(ep->dev, "unlink (%s) dma\n", _ep->name);
1285 abort_dma(ep);
1286 if (likely(ep->queue.next == &req->queue)) {
1289 dma_done(ep, req,
1290 readl(&ep->dma->dmacount),
1294 ep_dbg(ep->dev, "unlink (%s) pio\n", _ep->name);
1295 done(ep, req, -ECONNRESET);
1301 done(ep, req, -ECONNRESET);
1302 ep->stopped = stopped;
1304 if (ep->dma) {
1306 if (list_empty(&ep->queue))
1307 stop_dma(ep->dma);
1308 else if (!ep->stopped) {
1311 writel(dmactl, &ep->dma->dmactl);
1313 start_dma(ep, list_entry(ep->queue.next,
1318 spin_unlock_irqrestore(&ep->dev->lock, flags);
1329 struct net2280_ep *ep;
1333 ep = container_of(_ep, struct net2280_ep, ep);
1334 if (!_ep || (!ep->desc && ep->num != 0)) {
1335 pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
1338 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) {
1342 if (ep->desc /* not ep0 */ && (ep->desc->bmAttributes & 0x03)
1348 spin_lock_irqsave(&ep->dev->lock, flags);
1349 if (!list_empty(&ep->queue)) {
1352 } else if (ep->is_in && value && net2280_fifo_status(_ep) != 0) {
1356 ep_vdbg(ep->dev, "%s %s %s\n", _ep->name,
1361 if (ep->num == 0)
1362 ep->dev->protocol_stall = 1;
1364 set_halt(ep);
1366 ep->wedged = 1;
1368 clear_halt(ep);
1369 if (ep->dev->quirks & PLX_PCIE &&
1370 !list_empty(&ep->queue) && ep->td_dma)
1371 restart_dma(ep);
1372 ep->wedged = 0;
1374 (void) readl(&ep->regs->ep_rsp);
1376 spin_unlock_irqrestore(&ep->dev->lock, flags);
1381 spin_unlock_irqrestore(&ep->dev->lock, flags);
1383 dev_err(&ep->dev->pdev->dev, "%s: error=%d\n", __func__, retval);
1395 pr_err("%s: Invalid ep=%p or ep0\n", __func__, _ep);
1403 struct net2280_ep *ep;
1406 ep = container_of(_ep, struct net2280_ep, ep);
1407 if (!_ep || (!ep->desc && ep->num != 0)) {
1408 pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
1411 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) {
1412 dev_err(&ep->dev->pdev->dev,
1414 __func__, ep->dev->driver, ep->dev->gadget.speed);
1418 avail = readl(&ep->regs->ep_avail) & (BIT(12) - 1);
1419 if (avail > ep->fifo_size) {
1420 dev_err(&ep->dev->pdev->dev, "%s: Fifo overflow\n", __func__);
1423 if (ep->is_in)
1424 avail = ep->fifo_size - avail;
1430 struct net2280_ep *ep;
1432 ep = container_of(_ep, struct net2280_ep, ep);
1433 if (!_ep || (!ep->desc && ep->num != 0)) {
1434 pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
1437 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) {
1438 dev_err(&ep->dev->pdev->dev,
1440 __func__, ep->dev->driver, ep->dev->gadget.speed);
1444 writel(BIT(FIFO_FLUSH), &ep->regs->ep_stat);
1445 (void) readl(&ep->regs->ep_rsp);
1557 struct usb_ep *ep;
1560 /* ep-e, ep-f are PIO with only 64 byte fifos */
1561 ep = gadget_find_ep_by_name(_gadget, "ep-e");
1562 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1563 return ep;
1564 ep = gadget_find_ep_by_name(_gadget, "ep-f");
1565 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1566 return ep;
1575 ep = gadget_find_ep_by_name(_gadget, "ep2in");
1576 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1577 return ep;
1578 ep = gadget_find_ep_by_name(_gadget, "ep4in");
1579 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1580 return ep;
1583 ep = gadget_find_ep_by_name(_gadget, "ep1out");
1584 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1585 return ep;
1586 ep = gadget_find_ep_by_name(_gadget, "ep3out");
1587 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1588 return ep;
1591 ep = gadget_find_ep_by_name(_gadget, "ep1in");
1592 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1593 return ep;
1594 ep = gadget_find_ep_by_name(_gadget, "ep3in");
1595 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1596 return ep;
1599 ep = gadget_find_ep_by_name(_gadget, "ep2out");
1600 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1601 return ep;
1602 ep = gadget_find_ep_by_name(_gadget, "ep4out");
1603 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1604 return ep;
1608 snprintf(name, sizeof(name), "ep%d%s", usb_endpoint_num(desc),
1610 ep = gadget_find_ep_by_name(_gadget, name);
1611 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1612 return ep;
1718 struct net2280_ep *ep;
1720 ep = &dev->ep[i];
1721 if (i && !ep->desc)
1724 t1 = readl(&ep->cfg->ep_cfg);
1725 t2 = readl(&ep->regs->ep_rsp) & 0xff;
1729 ep->ep.name, t1, t2,
1746 readl(&ep->regs->ep_irqenb));
1752 "(ep%d%s-%s)%s\n",
1753 readl(&ep->regs->ep_stat),
1754 readl(&ep->regs->ep_avail),
1757 ep->stopped ? "*" : "");
1761 if (!ep->dma)
1767 readl(&ep->dma->dmactl),
1768 readl(&ep->dma->dmastat),
1769 readl(&ep->dma->dmacount),
1770 readl(&ep->dma->dmaaddr),
1771 readl(&ep->dma->dmadesc));
1784 struct net2280_ep *ep;
1786 ep = &dev->ep[i];
1787 if (i && !ep->irqs)
1789 t = scnprintf(next, size, " %s/%lu", ep->ep.name, ep->irqs);
1819 struct net2280_ep *ep = &dev->ep[i];
1826 d = ep->desc;
1831 "\n%s (ep%d%s-%s) max %04x %s fifo %d\n",
1832 ep->ep.name, t & USB_ENDPOINT_NUMBER_MASK,
1836 ep->dma ? "dma" : "pio", ep->fifo_size
1840 ep->is_in ? "in" : "out");
1846 if (list_empty(&ep->queue)) {
1854 list_for_each_entry(req, &ep->queue, queue) {
1855 if (ep->dma && req->td_dma == readl(&ep->dma->dmadesc))
1861 readl(&ep->dma->dmacount));
1872 if (ep->dma) {
1915 /* always ep-{a,b,e,f} ... maybe not ep-c or ep-d */
1917 list_add_tail(&dev->ep[1].ep.ep_list, &dev->gadget.ep_list);
1918 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1921 list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list);
1922 list_add_tail(&dev->ep[4].ep.ep_list, &dev->gadget.ep_list);
1923 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 1024;
1926 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 2048;
1929 list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list);
1930 dev->ep[1].fifo_size = 2048;
1931 dev->ep[2].fifo_size = 1024;
1934 /* fifo sizes for ep0, ep-c, ep-d, ep-e, and ep-f never change */
1935 list_add_tail(&dev->ep[5].ep.ep_list, &dev->gadget.ep_list);
1936 list_add_tail(&dev->ep[6].ep.ep_list, &dev->gadget.ep_list);
1944 * returing ep regs back to normal.
1946 struct net2280_ep *ep;
1952 ep = &dev->ep[i];
1953 writel(i, &ep->cfg->ep_cfg);
2004 writel(tmp, &dev->ep[i].cfg->ep_cfg);
2076 struct net2280_ep *ep = &dev->ep[tmp + 1];
2077 if (ep->dma)
2078 abort_dma(ep);
2114 struct net2280_ep *ep = &dev->ep[tmp + 1];
2117 if (ep->dma) {
2118 abort_dma(ep);
2139 /* always ep-{1,2,3,4} ... maybe not ep-3 or ep-4 */
2143 list_add_tail(&dev->ep[tmp].ep.ep_list, &dev->gadget.ep_list);
2160 struct net2280_ep *ep = &dev->ep[tmp];
2162 ep->ep.name = ep_info_dft[tmp].name;
2163 ep->ep.caps = ep_info_dft[tmp].caps;
2164 ep->dev = dev;
2165 ep->num = tmp;
2168 ep->fifo_size = 1024;
2169 ep->dma = &dev->dma[tmp - 1];
2171 ep->fifo_size = 64;
2172 ep->regs = &dev->epregs[tmp];
2173 ep->cfg = &dev->epregs[tmp];
2174 ep_reset_228x(dev->regs, ep);
2176 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 64);
2177 usb_ep_set_maxpacket_limit(&dev->ep[5].ep, 64);
2178 usb_ep_set_maxpacket_limit(&dev->ep[6].ep, 64);
2180 dev->gadget.ep0 = &dev->ep[0].ep;
2181 dev->ep[0].stopped = 0;
2201 struct net2280_ep *ep = &dev->ep[i];
2203 ep->ep.name = dev->enhanced_mode ? ep_info_adv[i].name :
2205 ep->ep.caps = dev->enhanced_mode ? ep_info_adv[i].caps :
2207 ep->dev = dev;
2208 ep->num = i;
2211 ep->dma = &dev->dma[i - 1];
2214 ep->cfg = &dev->epregs[ne[i]];
2220 writel(ne[i], &ep->cfg->ep_cfg);
2221 ep->regs = (struct net2280_ep_regs __iomem *)
2225 ep->cfg = &dev->epregs[i];
2226 ep->regs = &dev->epregs[i];
2229 ep->fifo_size = (i != 0) ? 2048 : 512;
2231 ep_reset_338x(dev->regs, ep);
2233 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 512);
2235 dev->gadget.ep0 = &dev->ep[0].ep;
2236 dev->ep[0].stopped = 0;
2426 dev->ep[i].irqs = 0;
2472 nuke(&dev->ep[i]);
2507 /* handle ep0, ep-e, ep-f with 64 byte packets: packet per irq.
2511 static void handle_ep_small(struct net2280_ep *ep)
2518 if (!list_empty(&ep->queue))
2519 req = list_entry(ep->queue.next,
2525 t = readl(&ep->regs->ep_stat);
2526 ep->irqs++;
2528 ep_vdbg(ep->dev, "%s ack ep_stat %08x, req %p\n",
2529 ep->ep.name, t, req ? &req->req : NULL);
2531 if (!ep->is_in || (ep->dev->quirks & PLX_2280))
2532 writel(t & ~BIT(NAK_OUT_PACKETS), &ep->regs->ep_stat);
2535 writel(t, &ep->regs->ep_stat);
2547 if (unlikely(ep->num == 0)) {
2548 if (ep->is_in) {
2551 if (ep->dev->protocol_stall) {
2552 ep->stopped = 1;
2553 set_halt(ep);
2556 allow_status(ep);
2560 if (ep->dev->protocol_stall) {
2561 ep->stopped = 1;
2562 set_halt(ep);
2564 } else if (ep->responded &&
2565 !req && !ep->stopped)
2566 write_fifo(ep, NULL);
2571 if (ep->dev->protocol_stall) {
2572 ep->stopped = 1;
2573 set_halt(ep);
2580 (ep->responded && !req)) {
2581 ep->dev->protocol_stall = 1;
2582 set_halt(ep);
2583 ep->stopped = 1;
2585 done(ep, req, -EOVERFLOW);
2595 if (likely(ep->dma)) {
2598 int stopped = ep->stopped;
2607 ep->stopped = 1;
2608 for (count = 0; ; t = readl(&ep->regs->ep_stat)) {
2613 num_completed = scan_dma_completions(ep);
2614 if (unlikely(list_empty(&ep->queue) ||
2615 ep->out_overflow)) {
2619 req = list_entry(ep->queue.next,
2626 count = readl(&ep->dma->dmacount);
2628 if (readl(&ep->dma->dmadesc)
2639 readl(&ep->dma->dmadesc) !=
2642 &ep->dma->dmacount);
2645 ep_dbg(ep->dev, "%s escape stuck %d, count %u\n",
2646 ep->ep.name, stuck,
2661 /* stop DMA, leave ep NAKing */
2662 writel(BIT(DMA_ABORT), &ep->dma->dmastat);
2663 spin_stop_dma(ep->dma);
2667 t = readl(&ep->regs->ep_avail);
2668 dma_done(ep, req, count,
2669 (ep->out_overflow || t)
2674 if (unlikely(ep->out_overflow ||
2675 (ep->dev->chiprev == 0x0100 &&
2676 ep->dev->gadget.speed
2678 out_flush(ep);
2679 ep->out_overflow = 0;
2683 ep->stopped = stopped;
2684 if (!list_empty(&ep->queue))
2685 restart_dma(ep);
2687 ep_dbg(ep->dev, "%s dma ep_stat %08x ??\n",
2688 ep->ep.name, t);
2693 if (read_fifo(ep, req) && ep->num != 0)
2701 if (len > ep->ep.maxpacket)
2702 len = ep->ep.maxpacket;
2708 (!req->req.zero || len != ep->ep.maxpacket) && ep->num)
2718 done(ep, req, 0);
2721 if (ep->num == 0) {
2726 if (!ep->stopped)
2727 allow_status(ep);
2730 if (!list_empty(&ep->queue) && !ep->stopped)
2731 req = list_entry(ep->queue.next,
2735 if (req && !ep->is_in)
2736 stop_out_naking(ep);
2743 if (req && !ep->stopped) {
2747 write_fifo(ep, &req->req);
2753 struct net2280_ep *ep;
2756 return &dev->ep[0];
2757 list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
2760 if (!ep->desc)
2762 bEndpointAddress = ep->desc->bEndpointAddress;
2766 return ep;
2845 static void ep_clear_seqnum(struct net2280_ep *ep)
2847 struct net2280 *dev = ep->dev;
2852 val |= ep_pl[ep->num];
2861 struct net2280_ep *ep, struct usb_ctrlrequest r)
2885 set_fifo_bytecount(ep, sizeof(status));
2887 allow_status_338x(ep);
2897 set_fifo_bytecount(ep, sizeof(status));
2899 allow_status_338x(ep);
2917 allow_status_338x(ep);
2925 allow_status_338x(ep);
2933 allow_status_338x(ep);
2945 allow_status_338x(ep);
2956 ep_vdbg(dev, "%s clear halt\n", e->ep.name);
2965 allow_status(ep);
2966 ep->stopped = 1;
2983 allow_status_338x(ep);
2991 allow_status_338x(ep);
2999 allow_status_338x(ep);
3011 allow_status_338x(ep);
3020 ep->stopped = 1;
3021 if (ep->num == 0)
3022 ep->dev->protocol_stall = 1;
3024 if (ep->dma)
3025 abort_dma(ep);
3026 set_halt(ep);
3028 allow_status_338x(ep);
3042 readl(&ep->cfg->ep_cfg));
3044 ep->responded = 0;
3055 set_halt(ep);
3083 handle_ep_small(&dev->ep[index]);
3089 struct net2280_ep *ep;
3111 usb_ep_set_maxpacket_limit(&dev->ep[0].ep,
3115 usb_ep_set_maxpacket_limit(&dev->ep[0].ep,
3119 usb_ep_set_maxpacket_limit(&dev->ep[0].ep,
3127 ep = &dev->ep[0];
3128 ep->irqs++;
3132 while (!list_empty(&ep->queue)) {
3133 req = list_entry(ep->queue.next,
3135 done(ep, req, (req->req.actual == req->req.length)
3138 ep->stopped = 0;
3141 if (ep->dev->quirks & PLX_2280)
3159 &ep->regs->ep_stat);
3185 ep->is_in = (u.r.bRequestType & USB_DIR_IN) != 0;
3186 if (ep->is_in) {
3190 stop_out_naking(ep);
3200 ep->responded = 1;
3203 handle_stat0_irqs_superspeed(dev, ep, u.r);
3226 set_fifo_bytecount(ep, w_length);
3228 allow_status(ep);
3229 ep_vdbg(dev, "%s stat %02x\n", ep->ep.name, status);
3246 ep->ep.name);
3248 ep_vdbg(dev, "%s clear halt\n", e->ep.name);
3250 if ((ep->dev->quirks & PLX_PCIE) &&
3254 allow_status(ep);
3269 if (e->ep.name == ep0name)
3274 allow_status(ep);
3275 ep_vdbg(dev, "%s set halt\n", ep->ep.name);
3285 readl(&ep->cfg->ep_cfg));
3286 ep->responded = 0;
3333 ep = &dev->ep[num];
3334 handle_ep_small(ep);
3355 struct net2280_ep *ep;
3455 /* DMA status, for ep-{a,b,c,d} */
3467 ep = &dev->ep[num + 1];
3468 dma = ep->dma;
3473 /* clear ep's dma status */
3480 if (!ep->is_in && (r_dmacount & 0x00FFFFFF) &&
3486 ep_dbg(ep->dev, "%s no xact done? %08x\n",
3487 ep->ep.name, tmp);
3490 stop_dma(ep->dma);
3502 scan_dma_completions(ep);
3505 if (!list_empty(&ep->queue)) {
3507 restart_dma(ep);
3509 ep->irqs++;
3583 if (!dev->ep[i].dummy)
3585 dma_pool_free(dev->requests, dev->ep[i].dummy,
3586 dev->ep[i].td_dma);
3741 &dev->ep[i].td_dma);
3749 dev->ep[i].dummy = td;