Lines Matching refs:epn
719 static void usbf_epn_send_null(struct usbf_ep *epn)
721 usbf_ep_reg_bitset(epn, USBF_REG_EPN_CONTROL, USBF_EPN_DEND);
724 static void usbf_epn_send_residue(struct usbf_ep *epn, const void *buf,
730 usbf_ep_reg_writel(epn, USBF_REG_EPN_WRITE, tmp);
732 usbf_ep_reg_clrset(epn, USBF_REG_EPN_CONTROL,
737 static int usbf_epn_pio_in(struct usbf_ep *epn, struct usbf_req *req)
748 dev_dbg(epn->udc->dev, "ep%u send_null\n", epn->id);
749 usbf_epn_send_null(epn);
753 if ((req->req.actual % epn->ep.maxpacket) == 0) {
755 dev_dbg(epn->udc->dev, "ep%u send_null\n",
756 epn->id);
757 usbf_epn_send_null(epn);
766 if (left > epn->ep.maxpacket)
767 left = epn->ep.maxpacket;
774 usbf_ep_reg_write_rep(epn, USBF_REG_EPN_WRITE, buf, nb);
781 usbf_epn_send_residue(epn, buf, left);
784 usbf_ep_reg_clrset(epn, USBF_REG_EPN_CONTROL,
789 dev_dbg(epn->udc->dev, "ep%u send %u/%u\n", epn->id, req->req.actual,
795 static void usbf_epn_enable_in_end_int(struct usbf_ep *epn)
797 usbf_ep_reg_bitset(epn, USBF_REG_EPN_INT_ENA, USBF_EPN_IN_END_EN);
800 static int usbf_epn_dma_in(struct usbf_ep *epn, struct usbf_req *req)
808 dev_dbg(epn->udc->dev, "ep%u buf unaligned -> fallback pio\n",
809 epn->id);
810 return usbf_epn_pio_in(epn, req);
819 dev_dbg(epn->udc->dev, "ep%u send null\n", epn->id);
820 usbf_epn_send_null(epn);
825 dev_dbg(epn->udc->dev, "ep%u send residue %u\n", epn->id,
827 usbf_epn_send_residue(epn,
834 ret = usb_gadget_map_request(&epn->udc->gadget, &req->req, 1);
836 dev_err(epn->udc->dev, "usb_gadget_map_request failed (%d)\n",
842 npkt = DIV_ROUND_UP(left, epn->ep.maxpacket);
843 lastpkt = (left % epn->ep.maxpacket);
845 lastpkt = epn->ep.maxpacket;
848 usbf_ep_dma_reg_writel(epn, USBF_REG_DMA_EPN_DCR2,
849 USBF_SYS_EPN_MPKT(epn->ep.maxpacket) | USBF_SYS_EPN_LMPKT(lastpkt));
850 usbf_ep_dma_reg_writel(epn, USBF_REG_DMA_EPN_TADR,
852 usbf_ep_dma_reg_writel(epn, USBF_REG_DMA_EPN_DCR1,
854 usbf_ep_dma_reg_bitset(epn, USBF_REG_DMA_EPN_DCR1,
857 usbf_ep_reg_writel(epn, USBF_REG_EPN_LEN_DCNT, USBF_EPN_SET_DMACNT(npkt));
859 usbf_ep_reg_bitset(epn, USBF_REG_EPN_CONTROL, USBF_EPN_AUTO);
868 usbf_ep_reg_bitclr(epn, USBF_REG_EPN_INT_ENA,
870 epn->bridge_on_dma_end = usbf_epn_enable_in_end_int;
873 usbf_ep_reg_writel(epn, USBF_REG_EPN_STATUS, ~(u32)USBF_EPN_IN_END_INT);
875 usbf_ep_reg_writel(epn, USBF_REG_EPN_DMA_CTRL,
877 usbf_ep_reg_bitset(epn, USBF_REG_EPN_DMA_CTRL,
880 req->dma_size = (npkt - 1) * epn->ep.maxpacket + lastpkt;
882 dev_dbg(epn->udc->dev, "ep%u dma xfer %zu\n", epn->id,
889 if (!(epn->status & USBF_EPN_IN_END_INT)) {
890 dev_dbg(epn->udc->dev, "ep%u dma not done\n", epn->id);
893 dev_dbg(epn->udc->dev, "ep%u dma done\n", epn->id);
895 usb_gadget_unmap_request(&epn->udc->gadget, &req->req, 1);
898 usbf_ep_reg_bitclr(epn, USBF_REG_EPN_CONTROL, USBF_EPN_AUTO);
900 usbf_ep_reg_clrset(epn, USBF_REG_EPN_INT_ENA,
908 usbf_ep_reg_writel(epn, USBF_REG_EPN_STATUS, ~(u32)USBF_EPN_IN_INT);
910 dev_dbg(epn->udc->dev, "ep%u send residue %u\n", epn->id,
912 usbf_epn_send_residue(epn,
919 if (req->req.actual % epn->ep.maxpacket) {
923 dev_dbg(epn->udc->dev, "ep%u send short\n", epn->id);
924 usbf_ep_reg_writel(epn, USBF_REG_EPN_STATUS,
926 usbf_ep_reg_bitset(epn, USBF_REG_EPN_CONTROL,
946 dev_dbg(epn->udc->dev, "ep%u send null\n", epn->id);
947 usbf_epn_send_null(epn);
952 if (!(epn->status & USBF_EPN_IN_INT)) {
953 dev_dbg(epn->udc->dev, "ep%u end not done\n", epn->id);
956 dev_dbg(epn->udc->dev, "ep%u send done %u/%u\n", epn->id,
965 static void usbf_epn_recv_residue(struct usbf_ep *epn, void *buf,
970 last = usbf_ep_reg_readl(epn, USBF_REG_EPN_READ);
974 static int usbf_epn_pio_out(struct usbf_ep *epn, struct usbf_req *req)
983 if (epn->status & USBF_EPN_OUT_INT) {
985 usbf_ep_reg_readl(epn, USBF_REG_EPN_LEN_DCNT));
993 dev_dbg(epn->udc->dev, "ep%u recv %u, left %u, mpkt %u\n", epn->id,
994 recv, left, epn->ep.maxpacket);
996 if (left > epn->ep.maxpacket)
997 left = epn->ep.maxpacket;
1007 usbf_ep_reg_read_rep(epn, USBF_REG_EPN_READ,
1014 usbf_epn_recv_residue(epn, buf, count);
1018 dev_dbg(epn->udc->dev, "ep%u recv %u/%u\n", epn->id,
1022 dev_dbg(epn->udc->dev, "ep%u req.status=%d\n", epn->id,
1028 if (recv < epn->ep.maxpacket) {
1029 dev_dbg(epn->udc->dev, "ep%u short packet\n", epn->id);
1042 if (epn->status & USBF_EPN_OUT_NULL_INT) {
1044 dev_dbg(epn->udc->dev, "ep%u null packet\n", epn->id);
1057 static void usbf_epn_enable_out_end_int(struct usbf_ep *epn)
1059 usbf_ep_reg_bitset(epn, USBF_REG_EPN_INT_ENA, USBF_EPN_OUT_END_EN);
1062 static void usbf_epn_process_queue(struct usbf_ep *epn);
1064 static void usbf_epn_dma_out_send_dma(struct usbf_ep *epn, dma_addr_t addr, u32 npkt, bool is_short)
1066 usbf_ep_dma_reg_writel(epn, USBF_REG_DMA_EPN_DCR2, USBF_SYS_EPN_MPKT(epn->ep.maxpacket));
1067 usbf_ep_dma_reg_writel(epn, USBF_REG_DMA_EPN_TADR, addr);
1070 usbf_ep_dma_reg_writel(epn, USBF_REG_DMA_EPN_DCR1,
1072 usbf_ep_dma_reg_bitset(epn, USBF_REG_DMA_EPN_DCR1,
1075 usbf_ep_reg_writel(epn, USBF_REG_EPN_LEN_DCNT,
1085 usbf_ep_reg_bitclr(epn, USBF_REG_EPN_INT_ENA,
1087 epn->bridge_on_dma_end = usbf_epn_enable_out_end_int;
1090 usbf_ep_reg_writel(epn, USBF_REG_EPN_STATUS,
1093 usbf_ep_reg_writel(epn, USBF_REG_EPN_DMA_CTRL,
1095 usbf_ep_reg_bitset(epn, USBF_REG_EPN_DMA_CTRL,
1100 usbf_ep_dma_reg_writel(epn, USBF_REG_DMA_EPN_DCR1,
1102 usbf_ep_dma_reg_bitset(epn, USBF_REG_DMA_EPN_DCR1,
1105 usbf_ep_reg_writel(epn, USBF_REG_EPN_LEN_DCNT,
1113 usbf_ep_reg_clrset(epn, USBF_REG_EPN_INT_ENA,
1118 usbf_reg_bitclr(epn->udc, USBF_REG_AHBBINTEN,
1119 USBF_SYS_DMA_ENDINTEN_EPN(epn->id));
1122 usbf_reg_writel(epn->udc, USBF_REG_AHBBINT,
1123 USBF_SYS_DMA_ENDINT_EPN(epn->id));
1126 usbf_ep_reg_writel(epn, USBF_REG_EPN_STATUS,
1129 usbf_ep_reg_writel(epn, USBF_REG_EPN_DMA_CTRL,
1131 usbf_ep_reg_bitset(epn, USBF_REG_EPN_DMA_CTRL,
1135 static size_t usbf_epn_dma_out_complete_dma(struct usbf_ep *epn, bool is_short)
1142 usbf_ep_reg_clrset(epn, USBF_REG_EPN_INT_ENA,
1152 usbf_reg_bitset(epn->udc, USBF_REG_AHBBINTEN,
1153 USBF_SYS_DMA_ENDINTEN_EPN(epn->id));
1155 tmp = usbf_ep_reg_readl(epn, USBF_REG_EPN_LEN_DCNT);
1165 epn->dma_regs + USBF_REG_DMA_EPN_DCR1,
1169 dev_err(epn->udc->dev, "ep%u wait bridge timed out\n",
1170 epn->id);
1173 usbf_ep_dma_reg_bitclr(epn, USBF_REG_DMA_EPN_DCR1,
1180 return dmacnt * epn->ep.maxpacket;
1186 static int usbf_epn_dma_out(struct usbf_ep *epn, struct usbf_req *req)
1196 dev_dbg(epn->udc->dev, "ep%u buf unaligned -> fallback pio\n",
1197 epn->id);
1198 return usbf_epn_pio_out(epn, req);
1204 if (epn->status & USBF_EPN_OUT_NULL_INT) {
1205 dev_dbg(epn->udc->dev, "ep%u null packet\n", epn->id);
1215 if (!(epn->status & USBF_EPN_OUT_INT)) {
1216 dev_dbg(epn->udc->dev, "ep%u OUT_INT not set -> spurious\n",
1217 epn->id);
1222 usbf_ep_reg_readl(epn, USBF_REG_EPN_LEN_DCNT));
1224 dev_dbg(epn->udc->dev, "ep%u recv = 0 -> spurious\n",
1225 epn->id);
1231 dev_dbg(epn->udc->dev, "ep%u recv %u, left %u, mpkt %u\n", epn->id,
1232 recv, left, epn->ep.maxpacket);
1235 dev_err(epn->udc->dev, "ep%u overflow (%u/%u)\n",
1236 epn->id, recv, left);
1241 if (recv < epn->ep.maxpacket) {
1243 dev_dbg(epn->udc->dev, "ep%u short packet\n", epn->id);
1245 usbf_epn_recv_residue(epn,
1249 dev_dbg(epn->udc->dev, "ep%u recv done %u/%u\n",
1250 epn->id, req->req.actual, req->req.length);
1256 ret = usb_gadget_map_request(&epn->udc->gadget, &req->req, 0);
1258 dev_err(epn->udc->dev, "map request failed (%d)\n",
1264 usbf_epn_dma_out_send_dma(epn,
1269 dev_dbg(epn->udc->dev, "ep%u dma short xfer %zu\n", epn->id,
1276 ret = usb_gadget_map_request(&epn->udc->gadget, &req->req, 0);
1278 dev_err(epn->udc->dev, "map request failed (%d)\n",
1289 npkt = left / epn->ep.maxpacket;
1290 usbf_epn_dma_out_send_dma(epn,
1293 req->dma_size = npkt * epn->ep.maxpacket;
1295 dev_dbg(epn->udc->dev, "ep%u dma xfer %zu (%u)\n", epn->id,
1302 if (!(epn->status & USBF_EPN_OUT_END_INT)) {
1303 dev_dbg(epn->udc->dev, "ep%u dma short not done\n", epn->id);
1306 dev_dbg(epn->udc->dev, "ep%u dma short done\n", epn->id);
1308 usbf_epn_dma_out_complete_dma(epn, true);
1310 usb_gadget_unmap_request(&epn->udc->gadget, &req->req, 0);
1316 usbf_ep_reg_readl(epn, USBF_REG_EPN_LEN_DCNT));
1320 dev_dbg(epn->udc->dev, "ep%u recv residue %u\n", epn->id,
1322 usbf_epn_recv_residue(epn,
1327 dev_dbg(epn->udc->dev, "ep%u recv done %u/%u\n", epn->id,
1334 if (!(epn->status & USBF_EPN_OUT_END_INT)) {
1335 dev_dbg(epn->udc->dev, "ep%u dma not done\n", epn->id);
1338 dev_dbg(epn->udc->dev, "ep%u dma done\n", epn->id);
1340 dma_left = usbf_epn_dma_out_complete_dma(epn, false);
1345 dev_dbg(epn->udc->dev, "ep%u dma xfer done %u\n", epn->id,
1350 if (epn->status & USBF_EPN_OUT_NULL_INT) {
1352 dev_dbg(epn->udc->dev, "ep%u dma stopped by null pckt\n",
1353 epn->id);
1354 usb_gadget_unmap_request(&epn->udc->gadget,
1358 usbf_ep_reg_writel(epn, USBF_REG_EPN_STATUS,
1367 dev_dbg(epn->udc->dev, "ep%u recv done %u/%u\n",
1368 epn->id, req->req.actual, req->req.length);
1374 usbf_ep_reg_readl(epn, USBF_REG_EPN_LEN_DCNT));
1377 dev_err(epn->udc->dev,
1378 "ep%u overflow (%u/%u)\n", epn->id,
1381 usb_gadget_unmap_request(&epn->udc->gadget,
1390 usbf_epn_dma_out_send_dma(epn,
1395 dev_dbg(epn->udc->dev, "ep%u dma short xfer %zu\n",
1396 epn->id, req->dma_size);
1402 usb_gadget_unmap_request(&epn->udc->gadget, &req->req, 0);
1407 dev_dbg(epn->udc->dev, "ep%u recv residue %u\n",
1408 epn->id, count);
1409 usbf_epn_recv_residue(epn,
1414 dev_dbg(epn->udc->dev, "ep%u recv done %u/%u\n", epn->id,
1422 usbf_ep_reg_bitclr(epn, USBF_REG_EPN_INT_ENA,
1424 epn->status = 0;
1425 epn->bridge_on_dma_end = usbf_epn_process_queue;
1431 dev_dbg(epn->udc->dev, "ep%u bridge transfers done\n", epn->id);
1434 usbf_ep_reg_clrset(epn, USBF_REG_EPN_INT_ENA,
1438 usb_gadget_unmap_request(&epn->udc->gadget, &req->req, 0);
1447 dev_dbg(epn->udc->dev, "ep%u recv done %u/%u\n", epn->id,
1451 dev_dbg(epn->udc->dev, "ep%u recv done %u/%u, wait more data\n",
1452 epn->id, req->req.actual, req->req.length);
1459 static void usbf_epn_dma_stop(struct usbf_ep *epn)
1461 usbf_ep_dma_reg_bitclr(epn, USBF_REG_DMA_EPN_DCR1, USBF_SYS_EPN_REQEN);
1473 usbf_ep_reg_bitclr(epn, USBF_REG_EPN_DMA_CTRL, USBF_EPN_DMA_EN);
1476 static void usbf_epn_dma_abort(struct usbf_ep *epn, struct usbf_req *req)
1478 dev_dbg(epn->udc->dev, "ep%u %s dma abort\n", epn->id,
1479 epn->is_in ? "in" : "out");
1481 epn->bridge_on_dma_end = NULL;
1483 usbf_epn_dma_stop(epn);
1485 usb_gadget_unmap_request(&epn->udc->gadget, &req->req,
1486 epn->is_in ? 1 : 0);
1489 usbf_ep_reg_bitclr(epn, USBF_REG_EPN_CONTROL, USBF_EPN_AUTO);
1491 if (epn->is_in) {
1492 usbf_ep_reg_clrset(epn, USBF_REG_EPN_INT_ENA,
1496 usbf_ep_reg_clrset(epn, USBF_REG_EPN_INT_ENA,
1502 usbf_ep_reg_writel(epn, USBF_REG_EPN_STATUS,
1505 usbf_reg_writel(epn->udc, USBF_REG_AHBBINT, USBF_SYS_DMA_ENDINT_EPN(epn->id));
1508 usbf_reg_bitset(epn->udc, USBF_REG_AHBBINTEN,
1509 USBF_SYS_DMA_ENDINTEN_EPN(epn->id));
1515 static void usbf_epn_fifo_flush(struct usbf_ep *epn)
1521 dev_dbg(epn->udc->dev, "ep%u %s fifo flush\n", epn->id,
1522 epn->is_in ? "in" : "out");
1524 ctrl = usbf_ep_reg_readl(epn, USBF_REG_EPN_CONTROL);
1525 usbf_ep_reg_writel(epn, USBF_REG_EPN_CONTROL, ctrl | USBF_EPN_BCLR);
1530 ret = readl_poll_timeout_atomic(epn->regs + USBF_REG_EPN_STATUS, sts,
1534 dev_err(epn->udc->dev, "ep%u flush fifo timed out\n", epn->id);
1596 static int usbf_epn_start_queue(struct usbf_ep *epn)
1601 if (usbf_ep_is_stalled(epn))
1604 req = list_first_entry_or_null(&epn->queue, struct usbf_req, queue);
1606 if (epn->is_in) {
1607 if (req && !epn->is_processing) {
1608 ret = epn->dma_regs ?
1609 usbf_epn_dma_in(epn, req) :
1610 usbf_epn_pio_in(epn, req);
1612 dev_err(epn->udc->dev,
1624 usbf_ep_reg_bitclr(epn, USBF_REG_EPN_CONTROL,
1628 usbf_ep_reg_bitset(epn, USBF_REG_EPN_INT_ENA,
1634 usbf_ep_reg_bitset(epn, USBF_REG_EPN_CONTROL,
1636 usbf_ep_reg_bitclr(epn, USBF_REG_EPN_INT_ENA,
1800 static int usbf_epn_enable(struct usbf_ep *epn)
1805 base_addr = usbf_ep_info[epn->id].base_addr;
1806 usbf_ep_reg_writel(epn, USBF_REG_EPN_PCKT_ADRS,
1807 USBF_EPN_BASEAD(base_addr) | USBF_EPN_MPKT(epn->ep.maxpacket));
1810 if (epn->is_in) {
1812 usbf_ep_reg_writel(epn, USBF_REG_EPN_INT_ENA, USBF_EPN_IN_EN);
1819 if (epn->is_in)
1823 usbf_ep_reg_writel(epn, USBF_REG_EPN_CONTROL, ctrl);
1872 static int usbf_epn_disable(struct usbf_ep *epn)
1875 usbf_ep_reg_writel(epn, USBF_REG_EPN_INT_ENA, 0);
1878 usbf_ep_reg_bitclr(epn, USBF_REG_EPN_CONTROL, USBF_EPN_EN);
1881 usbf_ep_nuke(epn, -ESHUTDOWN);
2761 static void usbf_epn_process_queue(struct usbf_ep *epn)
2765 ret = usbf_ep_process_queue(epn);
2768 dev_warn(epn->udc->dev, "ep%u %s, no request available\n",
2769 epn->id, epn->is_in ? "in" : "out");
2779 dev_err(epn->udc->dev, "ep%u %s, process queue failed (%d)\n",
2780 epn->id, epn->is_in ? "in" : "out", ret);
2785 dev_dbg(epn->udc->dev, "ep%u %s failed (%d)\n", epn->id,
2786 epn->is_in ? "in" : "out", ret);
2787 usbf_ep_stall(epn, true);
2788 usbf_ep_nuke(epn, ret);
2792 static void usbf_epn_interrupt(struct usbf_ep *epn)
2797 epn->status = usbf_ep_reg_readl(epn, USBF_REG_EPN_STATUS);
2798 ena = usbf_ep_reg_readl(epn, USBF_REG_EPN_INT_ENA);
2799 usbf_ep_reg_writel(epn, USBF_REG_EPN_STATUS, ~(epn->status & ena));
2801 dev_dbg(epn->udc->dev, "ep%u %s status=0x%08x, enable=%08x\n, ctrl=0x%08x\n",
2802 epn->id, epn->is_in ? "in" : "out", epn->status, ena,
2803 usbf_ep_reg_readl(epn, USBF_REG_EPN_CONTROL));
2805 if (epn->disabled) {
2806 dev_warn(epn->udc->dev, "ep%u %s, interrupt while disabled\n",
2807 epn->id, epn->is_in ? "in" : "out");
2811 sts = epn->status & ena;
2815 dev_dbg(epn->udc->dev, "ep%u %s process queue (in interrupts)\n",
2816 epn->id, epn->is_in ? "in" : "out");
2817 usbf_epn_process_queue(epn);
2822 dev_dbg(epn->udc->dev, "ep%u %s process queue (out interrupts)\n",
2823 epn->id, epn->is_in ? "in" : "out");
2824 usbf_epn_process_queue(epn);
2827 dev_dbg(epn->udc->dev, "ep%u %s done status=0x%08x. next=0x%08x\n",
2828 epn->id, epn->is_in ? "in" : "out",
2829 sts, usbf_ep_reg_readl(epn, USBF_REG_EPN_STATUS));
2974 struct usbf_ep *epn;
2976 void (*ep_action)(struct usbf_ep *epn);
3005 epn = &udc->ep[i];
3006 dev_dbg(epn->udc->dev,
3008 epn->id, epn->bridge_on_dma_end);
3009 ep_action = epn->bridge_on_dma_end;
3011 epn->bridge_on_dma_end = NULL;
3012 ep_action(epn);
3175 static int usbf_epn_check(struct usbf_ep *epn)
3182 ctrl = usbf_ep_reg_readl(epn, USBF_REG_EPN_CONTROL);
3187 if (epn->ep.caps.type_control || epn->ep.caps.type_iso ||
3188 !epn->ep.caps.type_bulk || epn->ep.caps.type_int) {
3189 dev_err(epn->udc->dev,
3190 "ep%u caps mismatch, bulk expected\n", epn->id);
3196 if (epn->ep.caps.type_control || epn->ep.caps.type_iso ||
3197 epn->ep.caps.type_bulk || !epn->ep.caps.type_int) {
3198 dev_err(epn->udc->dev,
3199 "ep%u caps mismatch, int expected\n", epn->id);
3205 if (epn->ep.caps.type_control || !epn->ep.caps.type_iso ||
3206 epn->ep.caps.type_bulk || epn->ep.caps.type_int) {
3207 dev_err(epn->udc->dev,
3208 "ep%u caps mismatch, iso expected\n", epn->id);
3214 dev_err(epn->udc->dev, "ep%u unknown type\n", epn->id);
3221 if (!usbf_ep_info[epn->id].is_double) {
3222 dev_err(epn->udc->dev,
3224 epn->id);
3229 if (usbf_ep_info[epn->id].is_double) {
3230 dev_err(epn->udc->dev,
3232 epn->id);
3237 dev_dbg(epn->udc->dev, "ep%u (%s) %s, %s buffer %u, checked %s\n",
3238 epn->id, epn->ep.name, type_txt, buf_txt,
3239 epn->ep.maxpacket_limit, ret ? "failed" : "ok");