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)
936 swap(ep->dummy, req->td);
937 swap(ep->td_dma, req->td_dma);
939 req->td->dmadesc = cpu_to_le32 (ep->td_dma);
941 fill_dma_desc(ep, req, valid);
945 done(struct net2280_ep *ep, struct net2280_request *req, int status)
948 unsigned stopped = ep->stopped;
957 dev = ep->dev;
958 if (ep->dma)
959 usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
963 ep->ep.name, &req->req, status,
967 ep->stopped = 1;
969 usb_gadget_giveback_request(&ep->ep, &req->req);
971 ep->stopped = stopped;
980 struct net2280_ep *ep;
988 ep = container_of(_ep, struct net2280_ep, ep);
989 if (!_ep || (!ep->desc && ep->num != 0)) {
990 pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
1003 dev = ep->dev;
1010 if (ep->dma && _req->length == 0) {
1016 if (ep->dma) {
1018 ep->is_in);
1032 if (list_empty(&ep->queue) && !ep->stopped &&
1033 !((dev->quirks & PLX_PCIE) && ep->dma &&
1034 (readl(&ep->regs->ep_rsp) & BIT(CLEAR_ENDPOINT_HALT)))) {
1037 if (ep->dma)
1038 start_dma(ep, req);
1041 if (ep->num == 0 && _req->length == 0) {
1042 allow_status(ep);
1043 done(ep, req, 0);
1044 ep_vdbg(dev, "%s status ack\n", ep->ep.name);
1049 if (ep->is_in)
1050 write_fifo(ep, _req);
1055 s = readl(&ep->regs->ep_stat);
1063 if (read_fifo(ep, req) &&
1064 ep->num == 0) {
1065 done(ep, req, 0);
1066 allow_status(ep);
1069 } else if (read_fifo(ep, req) &&
1070 ep->num != 0) {
1071 done(ep, req, 0);
1074 s = readl(&ep->regs->ep_stat);
1080 &ep->regs->ep_rsp);
1084 } else if (ep->dma) {
1087 if (ep->is_in) {
1094 (req->req.length % ep->ep.maxpacket));
1095 if (expect != ep->in_fifo_validate)
1098 queue_dma(ep, req, valid);
1102 ep->responded = 1;
1104 list_add_tail(&req->queue, &ep->queue);
1112 dev_err(&ep->dev->pdev->dev, "%s: error=%d\n", __func__, ret);
1117 dma_done(struct net2280_ep *ep, struct net2280_request *req, u32 dmacount,
1121 done(ep, req, status);
1124 static int scan_dma_completions(struct net2280_ep *ep)
1131 while (!list_empty(&ep->queue)) {
1135 req = list_entry(ep->queue.next,
1150 u32 const ep_dmacount = readl(&ep->dma->dmacount);
1155 dma_done(ep, req, req_dma_count, 0);
1158 } else if (!ep->is_in &&
1159 (req->req.length % ep->ep.maxpacket) &&
1160 !(ep->dev->quirks & PLX_PCIE)) {
1162 u32 const ep_stat = readl(&ep->regs->ep_stat);
1168 ep_warn(ep->dev, "%s lost packet sync!\n",
1169 ep->ep.name);
1172 u32 const ep_avail = readl(&ep->regs->ep_avail);
1175 ep->out_overflow = 1;
1176 ep_dbg(ep->dev,
1178 ep->ep.name, ep_avail,
1184 dma_done(ep, req, req_dma_count, 0);
1191 static void restart_dma(struct net2280_ep *ep)
1195 if (ep->stopped)
1197 req = list_entry(ep->queue.next, struct net2280_request, queue);
1199 start_dma(ep, req);
1202 static void abort_dma(struct net2280_ep *ep)
1205 if (likely(!list_empty(&ep->queue))) {
1207 writel(BIT(DMA_ABORT), &ep->dma->dmastat);
1208 spin_stop_dma(ep->dma);
1210 stop_dma(ep->dma);
1211 scan_dma_completions(ep);
1215 static void nuke(struct net2280_ep *ep)
1220 ep->stopped = 1;
1221 if (ep->dma)
1222 abort_dma(ep);
1223 while (!list_empty(&ep->queue)) {
1224 req = list_entry(ep->queue.next,
1227 done(ep, req, -ESHUTDOWN);
1234 struct net2280_ep *ep;
1241 ep = container_of(_ep, struct net2280_ep, ep);
1242 if (!_ep || (!ep->desc && ep->num != 0) || !_req) {
1243 pr_err("%s: Invalid ep=%p or ep->desc or req=%p\n",
1248 spin_lock_irqsave(&ep->dev->lock, flags);
1249 stopped = ep->stopped;
1253 ep->stopped = 1;
1254 if (ep->dma) {
1255 dmactl = readl(&ep->dma->dmactl);
1257 stop_dma(ep->dma);
1258 scan_dma_completions(ep);
1262 list_for_each_entry(iter, &ep->queue, queue) {
1269 ep->stopped = stopped;
1270 spin_unlock_irqrestore(&ep->dev->lock, flags);
1271 ep_dbg(ep->dev, "%s: Request mismatch\n", __func__);
1276 if (ep->queue.next == &req->queue) {
1277 if (ep->dma) {
1278 ep_dbg(ep->dev, "unlink (%s) dma\n", _ep->name);
1280 abort_dma(ep);
1281 if (likely(ep->queue.next == &req->queue)) {
1284 dma_done(ep, req,
1285 readl(&ep->dma->dmacount),
1289 ep_dbg(ep->dev, "unlink (%s) pio\n", _ep->name);
1290 done(ep, req, -ECONNRESET);
1296 done(ep, req, -ECONNRESET);
1297 ep->stopped = stopped;
1299 if (ep->dma) {
1301 if (list_empty(&ep->queue))
1302 stop_dma(ep->dma);
1303 else if (!ep->stopped) {
1306 writel(dmactl, &ep->dma->dmactl);
1308 start_dma(ep, list_entry(ep->queue.next,
1313 spin_unlock_irqrestore(&ep->dev->lock, flags);
1324 struct net2280_ep *ep;
1328 ep = container_of(_ep, struct net2280_ep, ep);
1329 if (!_ep || (!ep->desc && ep->num != 0)) {
1330 pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
1333 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) {
1337 if (ep->desc /* not ep0 */ && (ep->desc->bmAttributes & 0x03)
1343 spin_lock_irqsave(&ep->dev->lock, flags);
1344 if (!list_empty(&ep->queue)) {
1347 } else if (ep->is_in && value && net2280_fifo_status(_ep) != 0) {
1351 ep_vdbg(ep->dev, "%s %s %s\n", _ep->name,
1356 if (ep->num == 0)
1357 ep->dev->protocol_stall = 1;
1359 set_halt(ep);
1361 ep->wedged = 1;
1363 clear_halt(ep);
1364 if (ep->dev->quirks & PLX_PCIE &&
1365 !list_empty(&ep->queue) && ep->td_dma)
1366 restart_dma(ep);
1367 ep->wedged = 0;
1369 (void) readl(&ep->regs->ep_rsp);
1371 spin_unlock_irqrestore(&ep->dev->lock, flags);
1376 spin_unlock_irqrestore(&ep->dev->lock, flags);
1378 dev_err(&ep->dev->pdev->dev, "%s: error=%d\n", __func__, retval);
1390 pr_err("%s: Invalid ep=%p or ep0\n", __func__, _ep);
1398 struct net2280_ep *ep;
1401 ep = container_of(_ep, struct net2280_ep, ep);
1402 if (!_ep || (!ep->desc && ep->num != 0)) {
1403 pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
1406 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) {
1407 dev_err(&ep->dev->pdev->dev,
1409 __func__, ep->dev->driver, ep->dev->gadget.speed);
1413 avail = readl(&ep->regs->ep_avail) & (BIT(12) - 1);
1414 if (avail > ep->fifo_size) {
1415 dev_err(&ep->dev->pdev->dev, "%s: Fifo overflow\n", __func__);
1418 if (ep->is_in)
1419 avail = ep->fifo_size - avail;
1425 struct net2280_ep *ep;
1427 ep = container_of(_ep, struct net2280_ep, ep);
1428 if (!_ep || (!ep->desc && ep->num != 0)) {
1429 pr_err("%s: Invalid ep=%p or ep->desc\n", __func__, _ep);
1432 if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN) {
1433 dev_err(&ep->dev->pdev->dev,
1435 __func__, ep->dev->driver, ep->dev->gadget.speed);
1439 writel(BIT(FIFO_FLUSH), &ep->regs->ep_stat);
1440 (void) readl(&ep->regs->ep_rsp);
1552 struct usb_ep *ep;
1555 /* ep-e, ep-f are PIO with only 64 byte fifos */
1556 ep = gadget_find_ep_by_name(_gadget, "ep-e");
1557 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1558 return ep;
1559 ep = gadget_find_ep_by_name(_gadget, "ep-f");
1560 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1561 return ep;
1570 ep = gadget_find_ep_by_name(_gadget, "ep2in");
1571 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1572 return ep;
1573 ep = gadget_find_ep_by_name(_gadget, "ep4in");
1574 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1575 return ep;
1578 ep = gadget_find_ep_by_name(_gadget, "ep1out");
1579 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1580 return ep;
1581 ep = gadget_find_ep_by_name(_gadget, "ep3out");
1582 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1583 return ep;
1586 ep = gadget_find_ep_by_name(_gadget, "ep1in");
1587 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1588 return ep;
1589 ep = gadget_find_ep_by_name(_gadget, "ep3in");
1590 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1591 return ep;
1594 ep = gadget_find_ep_by_name(_gadget, "ep2out");
1595 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1596 return ep;
1597 ep = gadget_find_ep_by_name(_gadget, "ep4out");
1598 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1599 return ep;
1603 snprintf(name, sizeof(name), "ep%d%s", usb_endpoint_num(desc),
1605 ep = gadget_find_ep_by_name(_gadget, name);
1606 if (ep && usb_gadget_ep_match_desc(_gadget, ep, desc, ep_comp))
1607 return ep;
1715 struct net2280_ep *ep;
1717 ep = &dev->ep[i];
1718 if (i && !ep->desc)
1721 t1 = readl(&ep->cfg->ep_cfg);
1722 t2 = readl(&ep->regs->ep_rsp) & 0xff;
1726 ep->ep.name, t1, t2,
1743 readl(&ep->regs->ep_irqenb));
1749 "(ep%d%s-%s)%s\n",
1750 readl(&ep->regs->ep_stat),
1751 readl(&ep->regs->ep_avail),
1754 ep->stopped ? "*" : "");
1758 if (!ep->dma)
1764 readl(&ep->dma->dmactl),
1765 readl(&ep->dma->dmastat),
1766 readl(&ep->dma->dmacount),
1767 readl(&ep->dma->dmaaddr),
1768 readl(&ep->dma->dmadesc));
1781 struct net2280_ep *ep;
1783 ep = &dev->ep[i];
1784 if (i && !ep->irqs)
1786 t = scnprintf(next, size, " %s/%lu", ep->ep.name, ep->irqs);
1816 struct net2280_ep *ep = &dev->ep[i];
1823 d = ep->desc;
1828 "\n%s (ep%d%s-%s) max %04x %s fifo %d\n",
1829 ep->ep.name, t & USB_ENDPOINT_NUMBER_MASK,
1833 ep->dma ? "dma" : "pio", ep->fifo_size
1837 ep->is_in ? "in" : "out");
1843 if (list_empty(&ep->queue)) {
1851 list_for_each_entry(req, &ep->queue, queue) {
1852 if (ep->dma && req->td_dma == readl(&ep->dma->dmadesc))
1858 readl(&ep->dma->dmacount));
1869 if (ep->dma) {
1912 /* always ep-{a,b,e,f} ... maybe not ep-c or ep-d */
1914 list_add_tail(&dev->ep[1].ep.ep_list, &dev->gadget.ep_list);
1915 list_add_tail(&dev->ep[2].ep.ep_list, &dev->gadget.ep_list);
1918 list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list);
1919 list_add_tail(&dev->ep[4].ep.ep_list, &dev->gadget.ep_list);
1920 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 1024;
1923 dev->ep[1].fifo_size = dev->ep[2].fifo_size = 2048;
1926 list_add_tail(&dev->ep[3].ep.ep_list, &dev->gadget.ep_list);
1927 dev->ep[1].fifo_size = 2048;
1928 dev->ep[2].fifo_size = 1024;
1931 /* fifo sizes for ep0, ep-c, ep-d, ep-e, and ep-f never change */
1932 list_add_tail(&dev->ep[5].ep.ep_list, &dev->gadget.ep_list);
1933 list_add_tail(&dev->ep[6].ep.ep_list, &dev->gadget.ep_list);
1941 * returing ep regs back to normal.
1943 struct net2280_ep *ep;
1949 ep = &dev->ep[i];
1950 writel(i, &ep->cfg->ep_cfg);
2001 writel(tmp, &dev->ep[i].cfg->ep_cfg);
2073 struct net2280_ep *ep = &dev->ep[tmp + 1];
2074 if (ep->dma)
2075 abort_dma(ep);
2111 struct net2280_ep *ep = &dev->ep[tmp + 1];
2114 if (ep->dma) {
2115 abort_dma(ep);
2136 /* always ep-{1,2,3,4} ... maybe not ep-3 or ep-4 */
2140 list_add_tail(&dev->ep[tmp].ep.ep_list, &dev->gadget.ep_list);
2157 struct net2280_ep *ep = &dev->ep[tmp];
2159 ep->ep.name = ep_info_dft[tmp].name;
2160 ep->ep.caps = ep_info_dft[tmp].caps;
2161 ep->dev = dev;
2162 ep->num = tmp;
2165 ep->fifo_size = 1024;
2166 ep->dma = &dev->dma[tmp - 1];
2168 ep->fifo_size = 64;
2169 ep->regs = &dev->epregs[tmp];
2170 ep->cfg = &dev->epregs[tmp];
2171 ep_reset_228x(dev->regs, ep);
2173 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 64);
2174 usb_ep_set_maxpacket_limit(&dev->ep[5].ep, 64);
2175 usb_ep_set_maxpacket_limit(&dev->ep[6].ep, 64);
2177 dev->gadget.ep0 = &dev->ep[0].ep;
2178 dev->ep[0].stopped = 0;
2198 struct net2280_ep *ep = &dev->ep[i];
2200 ep->ep.name = dev->enhanced_mode ? ep_info_adv[i].name :
2202 ep->ep.caps = dev->enhanced_mode ? ep_info_adv[i].caps :
2204 ep->dev = dev;
2205 ep->num = i;
2208 ep->dma = &dev->dma[i - 1];
2211 ep->cfg = &dev->epregs[ne[i]];
2217 writel(ne[i], &ep->cfg->ep_cfg);
2218 ep->regs = (struct net2280_ep_regs __iomem *)
2222 ep->cfg = &dev->epregs[i];
2223 ep->regs = &dev->epregs[i];
2226 ep->fifo_size = (i != 0) ? 2048 : 512;
2228 ep_reset_338x(dev->regs, ep);
2230 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, 512);
2232 dev->gadget.ep0 = &dev->ep[0].ep;
2233 dev->ep[0].stopped = 0;
2423 dev->ep[i].irqs = 0;
2468 nuke(&dev->ep[i]);
2512 /* handle ep0, ep-e, ep-f with 64 byte packets: packet per irq.
2516 static void handle_ep_small(struct net2280_ep *ep)
2523 if (!list_empty(&ep->queue))
2524 req = list_entry(ep->queue.next,
2530 t = readl(&ep->regs->ep_stat);
2531 ep->irqs++;
2533 ep_vdbg(ep->dev, "%s ack ep_stat %08x, req %p\n",
2534 ep->ep.name, t, req ? &req->req : NULL);
2536 if (!ep->is_in || (ep->dev->quirks & PLX_2280))
2537 writel(t & ~BIT(NAK_OUT_PACKETS), &ep->regs->ep_stat);
2540 writel(t, &ep->regs->ep_stat);
2552 if (unlikely(ep->num == 0)) {
2553 if (ep->is_in) {
2556 if (ep->dev->protocol_stall) {
2557 ep->stopped = 1;
2558 set_halt(ep);
2561 allow_status(ep);
2565 if (ep->dev->protocol_stall) {
2566 ep->stopped = 1;
2567 set_halt(ep);
2569 } else if (ep->responded &&
2570 !req && !ep->stopped)
2571 write_fifo(ep, NULL);
2576 if (ep->dev->protocol_stall) {
2577 ep->stopped = 1;
2578 set_halt(ep);
2585 (ep->responded && !req)) {
2586 ep->dev->protocol_stall = 1;
2587 set_halt(ep);
2588 ep->stopped = 1;
2590 done(ep, req, -EOVERFLOW);
2600 if (likely(ep->dma)) {
2603 int stopped = ep->stopped;
2612 ep->stopped = 1;
2613 for (count = 0; ; t = readl(&ep->regs->ep_stat)) {
2618 num_completed = scan_dma_completions(ep);
2619 if (unlikely(list_empty(&ep->queue) ||
2620 ep->out_overflow)) {
2624 req = list_entry(ep->queue.next,
2631 count = readl(&ep->dma->dmacount);
2633 if (readl(&ep->dma->dmadesc)
2644 readl(&ep->dma->dmadesc) !=
2647 &ep->dma->dmacount);
2650 ep_dbg(ep->dev, "%s escape stuck %d, count %u\n",
2651 ep->ep.name, stuck,
2666 /* stop DMA, leave ep NAKing */
2667 writel(BIT(DMA_ABORT), &ep->dma->dmastat);
2668 spin_stop_dma(ep->dma);
2672 t = readl(&ep->regs->ep_avail);
2673 dma_done(ep, req, count,
2674 (ep->out_overflow || t)
2679 if (unlikely(ep->out_overflow ||
2680 (ep->dev->chiprev == 0x0100 &&
2681 ep->dev->gadget.speed
2683 out_flush(ep);
2684 ep->out_overflow = 0;
2688 ep->stopped = stopped;
2689 if (!list_empty(&ep->queue))
2690 restart_dma(ep);
2692 ep_dbg(ep->dev, "%s dma ep_stat %08x ??\n",
2693 ep->ep.name, t);
2698 if (read_fifo(ep, req) && ep->num != 0)
2706 if (len > ep->ep.maxpacket)
2707 len = ep->ep.maxpacket;
2713 (!req->req.zero || len != ep->ep.maxpacket) && ep->num)
2723 done(ep, req, 0);
2726 if (ep->num == 0) {
2731 if (!ep->stopped)
2732 allow_status(ep);
2735 if (!list_empty(&ep->queue) && !ep->stopped)
2736 req = list_entry(ep->queue.next,
2740 if (req && !ep->is_in)
2741 stop_out_naking(ep);
2748 if (req && !ep->stopped) {
2752 write_fifo(ep, &req->req);
2758 struct net2280_ep *ep;
2761 return &dev->ep[0];
2762 list_for_each_entry(ep, &dev->gadget.ep_list, ep.ep_list) {
2765 if (!ep->desc)
2767 bEndpointAddress = ep->desc->bEndpointAddress;
2771 return ep;
2848 static void ep_clear_seqnum(struct net2280_ep *ep)
2850 struct net2280 *dev = ep->dev;
2855 val |= ep_pl[ep->num];
2864 struct net2280_ep *ep, struct usb_ctrlrequest r)
2888 set_fifo_bytecount(ep, sizeof(status));
2890 allow_status_338x(ep);
2900 set_fifo_bytecount(ep, sizeof(status));
2902 allow_status_338x(ep);
2920 allow_status_338x(ep);
2928 allow_status_338x(ep);
2936 allow_status_338x(ep);
2948 allow_status_338x(ep);
2959 ep_vdbg(dev, "%s clear halt\n", e->ep.name);
2968 allow_status(ep);
2969 ep->stopped = 1;
2986 allow_status_338x(ep);
2994 allow_status_338x(ep);
3002 allow_status_338x(ep);
3014 allow_status_338x(ep);
3023 ep->stopped = 1;
3024 if (ep->num == 0)
3025 ep->dev->protocol_stall = 1;
3027 if (ep->dma)
3028 abort_dma(ep);
3029 set_halt(ep);
3031 allow_status_338x(ep);
3045 readl(&ep->cfg->ep_cfg));
3047 ep->responded = 0;
3060 set_halt(ep);
3088 handle_ep_small(&dev->ep[index]);
3094 struct net2280_ep *ep;
3116 usb_ep_set_maxpacket_limit(&dev->ep[0].ep,
3120 usb_ep_set_maxpacket_limit(&dev->ep[0].ep,
3124 usb_ep_set_maxpacket_limit(&dev->ep[0].ep,
3132 ep = &dev->ep[0];
3133 ep->irqs++;
3137 while (!list_empty(&ep->queue)) {
3138 req = list_entry(ep->queue.next,
3140 done(ep, req, (req->req.actual == req->req.length)
3143 ep->stopped = 0;
3146 if (ep->dev->quirks & PLX_2280)
3164 &ep->regs->ep_stat);
3190 ep->is_in = (u.r.bRequestType & USB_DIR_IN) != 0;
3191 if (ep->is_in) {
3195 stop_out_naking(ep);
3205 ep->responded = 1;
3208 handle_stat0_irqs_superspeed(dev, ep, u.r);
3231 set_fifo_bytecount(ep, w_length);
3233 allow_status(ep);
3234 ep_vdbg(dev, "%s stat %02x\n", ep->ep.name, status);
3251 ep->ep.name);
3253 ep_vdbg(dev, "%s clear halt\n", e->ep.name);
3255 if ((ep->dev->quirks & PLX_PCIE) &&
3259 allow_status(ep);
3274 if (e->ep.name == ep0name)
3279 allow_status(ep);
3280 ep_vdbg(dev, "%s set halt\n", ep->ep.name);
3290 readl(&ep->cfg->ep_cfg));
3291 ep->responded = 0;
3340 ep = &dev->ep[num];
3341 handle_ep_small(ep);
3362 struct net2280_ep *ep;
3462 /* DMA status, for ep-{a,b,c,d} */
3474 ep = &dev->ep[num + 1];
3475 dma = ep->dma;
3480 /* clear ep's dma status */
3487 if (!ep->is_in && (r_dmacount & 0x00FFFFFF) &&
3493 ep_dbg(ep->dev, "%s no xact done? %08x\n",
3494 ep->ep.name, tmp);
3497 stop_dma(ep->dma);
3509 scan_dma_completions(ep);
3512 if (!list_empty(&ep->queue)) {
3514 restart_dma(ep);
3516 ep->irqs++;
3590 if (!dev->ep[i].dummy)
3592 dma_pool_free(dev->requests, dev->ep[i].dummy,
3593 dev->ep[i].td_dma);
3748 &dev->ep[i].td_dma);
3756 dev->ep[i].dummy = td;