Lines Matching refs:ep
78 static void handle_ep(struct pxa_ep *ep);
138 struct pxa_ep *ep;
147 ep = &udc->pxa_ep[i];
148 maxpkt = ep->fifo_size;
150 EPNAME(ep), maxpkt, "pio");
152 if (list_empty(&ep->queue)) {
157 list_for_each_entry(req, &ep->queue, queue) {
171 struct pxa_ep *ep;
178 ep = &udc->pxa_ep[0];
179 tmp = udc_ep_readl(ep, UDCCSR);
190 ep = &udc->pxa_ep[i];
191 tmp = i? udc_ep_readl(ep, UDCCR) : udc_readl(udc, UDCCR);
193 EPNAME(ep),
194 ep->stats.in_bytes, ep->stats.in_ops,
195 ep->stats.out_bytes, ep->stats.out_ops,
196 ep->stats.irqs,
197 tmp, udc_ep_readl(ep, UDCCSR),
198 udc_ep_readl(ep, UDCBCR));
233 * @ep: pxa endpoint
240 static int is_match_usb_pxa(struct udc_usb_ep *udc_usb_ep, struct pxa_ep *ep,
243 if (usb_endpoint_num(&udc_usb_ep->desc) != ep->addr)
245 if (usb_endpoint_dir_in(&udc_usb_ep->desc) != ep->dir_in)
247 if (usb_endpoint_type(&udc_usb_ep->desc) != ep->type)
249 if ((ep->config != config) || (ep->interface != interface)
250 || (ep->alternate != altsetting))
284 struct pxa_ep *ep;
293 ep = &udc->pxa_ep[i];
294 if (is_match_usb_pxa(udc_usb_ep, ep, cfg, iface, alt))
295 return ep;
324 * @ep: udc endpoint
326 static void pio_irq_enable(struct pxa_ep *ep)
328 struct pxa_udc *udc = ep->dev;
329 int index = EPIDX(ep);
341 * @ep: udc endpoint
343 static void pio_irq_disable(struct pxa_ep *ep)
345 struct pxa_udc *udc = ep->dev;
346 int index = EPIDX(ep);
386 * @ep: udc endpoint
394 static inline void ep_write_UDCCSR(struct pxa_ep *ep, int mask)
396 if (is_ep0(ep))
398 udc_ep_writel(ep, UDCCSR, mask);
403 * @ep: udc endpoint
407 static int ep_count_bytes_remain(struct pxa_ep *ep)
409 if (ep->dir_in)
411 return udc_ep_readl(ep, UDCBCR) & 0x3ff;
415 * ep_is_empty - checks if ep has byte ready for reading
416 * @ep: udc endpoint
422 * Returns 0 if ep not empty, 1 if ep empty, -EOPNOTSUPP if IN endpoint
424 static int ep_is_empty(struct pxa_ep *ep)
428 if (!is_ep0(ep) && ep->dir_in)
430 if (is_ep0(ep))
431 ret = !(udc_ep_readl(ep, UDCCSR) & UDCCSR0_RNE);
433 ret = !(udc_ep_readl(ep, UDCCSR) & UDCCSR_BNE);
438 * ep_is_full - checks if ep has place to write bytes
439 * @ep: udc endpoint
444 * Returns 0 if ep not full, 1 if ep full, -EOPNOTSUPP if OUT endpoint
446 static int ep_is_full(struct pxa_ep *ep)
448 if (is_ep0(ep))
449 return (udc_ep_readl(ep, UDCCSR) & UDCCSR0_IPR);
450 if (!ep->dir_in)
452 return (!(udc_ep_readl(ep, UDCCSR) & UDCCSR_BNF));
457 * @ep: pxa endpoint
459 * Returns 1 if a complete packet is available, 0 if not, -EOPNOTSUPP for IN ep.
461 static int epout_has_pkt(struct pxa_ep *ep)
463 if (!is_ep0(ep) && ep->dir_in)
465 if (is_ep0(ep))
466 return (udc_ep_readl(ep, UDCCSR) & UDCCSR0_OPC);
467 return (udc_ep_readl(ep, UDCCSR) & UDCCSR_PC);
477 struct pxa_ep *ep = &udc->pxa_ep[0];
481 ep_dbg(ep, "state=%s->%s, udccsr0=0x%03x, udcbcr=%d\n", old_stname,
482 EP0_STNAME(udc), udc_ep_readl(ep, UDCCSR),
483 udc_ep_readl(ep, UDCBCR));
496 * inc_ep_stats_reqs - Update ep stats counts
497 * @ep: physical endpoint
498 * @is_in: ep direction (USB_DIR_IN or 0)
501 static void inc_ep_stats_reqs(struct pxa_ep *ep, int is_in)
504 ep->stats.in_ops++;
506 ep->stats.out_ops++;
510 * inc_ep_stats_bytes - Update ep stats counts
511 * @ep: physical endpoint
513 * @is_in: ep direction (USB_DIR_IN or 0)
515 static void inc_ep_stats_bytes(struct pxa_ep *ep, int count, int is_in)
518 ep->stats.in_bytes += count;
520 ep->stats.out_bytes += count;
525 * @ep: pxa27x physical endpoint
527 * Find the physical pxa27x ep, and setup its UDCCR
529 static void pxa_ep_setup(struct pxa_ep *ep)
533 new_udccr = ((ep->config << UDCCONR_CN_S) & UDCCONR_CN)
534 | ((ep->interface << UDCCONR_IN_S) & UDCCONR_IN)
535 | ((ep->alternate << UDCCONR_AISN_S) & UDCCONR_AISN)
536 | ((EPADDR(ep) << UDCCONR_EN_S) & UDCCONR_EN)
537 | ((EPXFERTYPE(ep) << UDCCONR_ET_S) & UDCCONR_ET)
538 | ((ep->dir_in) ? UDCCONR_ED : 0)
539 | ((ep->fifo_size << UDCCONR_MPS_S) & UDCCONR_MPS)
542 udc_ep_writel(ep, UDCCR, new_udccr);
604 * @ep: usb endpoint
607 * Context: ep->lock held
612 static void ep_add_request(struct pxa_ep *ep, struct pxa27x_request *req)
616 ep_vdbg(ep, "req:%p, lg=%d, udccsr=0x%03x\n", req,
617 req->req.length, udc_ep_readl(ep, UDCCSR));
620 list_add_tail(&req->queue, &ep->queue);
621 pio_irq_enable(ep);
626 * @ep: usb endpoint
629 * Context: ep->lock held
635 static void ep_del_request(struct pxa_ep *ep, struct pxa27x_request *req)
639 ep_vdbg(ep, "req:%p, lg=%d, udccsr=0x%03x\n", req,
640 req->req.length, udc_ep_readl(ep, UDCCSR));
644 if (!is_ep0(ep) && list_empty(&ep->queue))
645 pio_irq_disable(ep);
650 * @ep: pxa physical endpoint
655 * Context: ep->lock held if flags not NULL, else ep->lock released
659 static void req_done(struct pxa_ep *ep, struct pxa27x_request *req, int status,
664 ep_del_request(ep, req);
671 ep_dbg(ep, "complete req %p stat %d len %u/%u\n",
676 spin_unlock_irqrestore(&ep->lock, *pflags);
681 spin_lock_irqsave(&ep->lock, *pflags);
686 * @ep: physical endpoint
690 * Context: ep->lock held or released (see req_done())
694 static void ep_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req,
697 inc_ep_stats_reqs(ep, !USB_DIR_IN);
698 req_done(ep, req, 0, pflags);
703 * @ep: physical endpoint
707 * Context: ep->lock held or released (see req_done())
712 static void ep0_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req,
715 set_ep0state(ep->dev, OUT_STATUS_STAGE);
716 ep_end_out_req(ep, req, pflags);
717 ep0_idle(ep->dev);
722 * @ep: physical endpoint
726 * Context: ep->lock held or released (see req_done())
730 static void ep_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req,
733 inc_ep_stats_reqs(ep, USB_DIR_IN);
734 req_done(ep, req, 0, pflags);
739 * @ep: physical endpoint
743 * Context: ep->lock held or released (see req_done())
748 static void ep0_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req,
751 set_ep0state(ep->dev, IN_STATUS_STAGE);
752 ep_end_in_req(ep, req, pflags);
757 * @ep: pxa endpoint
760 * Context: ep->lock released
765 static void nuke(struct pxa_ep *ep, int status)
770 spin_lock_irqsave(&ep->lock, flags);
771 while (!list_empty(&ep->queue)) {
772 req = list_entry(ep->queue.next, struct pxa27x_request, queue);
773 req_done(ep, req, status, &flags);
775 spin_unlock_irqrestore(&ep->lock, flags);
780 * @ep: pxa physical endpoint
789 static int read_packet(struct pxa_ep *ep, struct pxa27x_request *req)
794 bytes_ep = ep_count_bytes_remain(ep);
800 if (likely(!ep_is_empty(ep)))
806 *buf++ = udc_ep_readl(ep, UDCDR);
809 ep_write_UDCCSR(ep, UDCCSR_PC);
816 * @ep: pxa physical endpoint
826 static int write_packet(struct pxa_ep *ep, struct pxa27x_request *req,
842 udc_ep_writel(ep, UDCDR, *buf++);
846 udc_ep_writeb(ep, UDCDR, *buf_8++);
848 ep_vdbg(ep, "length=%d+%d, udccsr=0x%03x\n", count, remain,
849 udc_ep_readl(ep, UDCCSR));
856 * @ep: pxa physical endpoint
868 static int read_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
872 while (epout_has_pkt(ep)) {
873 count = read_packet(ep, req);
874 inc_ep_stats_bytes(ep, count, !USB_DIR_IN);
876 is_short = (count < ep->fifo_size);
877 ep_dbg(ep, "read udccsr:%03x, count:%d bytes%s req %p %d/%d\n",
878 udc_ep_readl(ep, UDCCSR), count, is_short ? "/S" : "",
893 * @ep: pxa physical endpoint
903 static int write_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
909 max = ep->fifo_size;
911 udccsr = udc_ep_readl(ep, UDCCSR);
913 ep_vdbg(ep, "Clearing Transmit Complete, udccsr=%x\n",
915 ep_write_UDCCSR(ep, UDCCSR_PC);
918 ep_vdbg(ep, "Clearing Underrun on, udccsr=%x\n",
920 ep_write_UDCCSR(ep, UDCCSR_TRN);
923 count = write_packet(ep, req, max);
924 inc_ep_stats_bytes(ep, count, USB_DIR_IN);
938 is_short = unlikely(max < ep->fifo_size);
942 ep_write_UDCCSR(ep, UDCCSR_SP);
949 } while (!ep_is_full(ep));
951 ep_dbg(ep, "wrote count:%d bytes%s%s, left:%d req=%p\n",
960 * @ep: control endpoint
969 static int read_ep0_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
973 while (epout_has_pkt(ep)) {
974 count = read_packet(ep, req);
975 ep_write_UDCCSR(ep, UDCCSR0_OPC);
976 inc_ep_stats_bytes(ep, count, !USB_DIR_IN);
978 is_short = (count < ep->fifo_size);
979 ep_dbg(ep, "read udccsr:%03x, count:%d bytes%s req %p %d/%d\n",
980 udc_ep_readl(ep, UDCCSR), count, is_short ? "/S" : "",
994 * @ep: control endpoint
1007 static int write_ep0_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
1012 count = write_packet(ep, req, EP0_FIFO_SIZE);
1013 inc_ep_stats_bytes(ep, count, USB_DIR_IN);
1020 ep_write_UDCCSR(ep, UDCCSR0_IPR);
1022 ep_dbg(ep, "in %d bytes%s%s, %d left, req=%p, udccsr0=0x%03x\n",
1025 &req->req, udc_ep_readl(ep, UDCCSR));
1046 struct pxa_ep *ep;
1064 ep = udc_usb_ep->pxa_ep;
1065 if (unlikely(!ep))
1068 dev = ep->dev;
1070 ep_dbg(ep, "bogus device state\n");
1077 if (unlikely(EPXFERTYPE_is_ISO(ep)
1078 && req->req.length > ep->fifo_size))
1081 spin_lock_irqsave(&ep->lock, flags);
1082 recursion_detected = ep->in_handle_ep;
1084 is_first_req = list_empty(&ep->queue);
1085 ep_dbg(ep, "queue req %p(first=%s), len %d buf %p\n",
1089 if (!ep->enabled) {
1096 ep_err(ep, "refusing to queue req %p (already queued)\n", req);
1104 ep_add_request(ep, req);
1105 spin_unlock_irqrestore(&ep->lock, flags);
1107 if (is_ep0(ep)) {
1111 ep_end_in_req(ep, req, NULL);
1113 ep_err(ep, "got a request of %d bytes while"
1116 ep_del_request(ep, req);
1119 ep0_idle(ep->dev);
1122 if (!ep_is_full(ep))
1123 if (write_ep0_fifo(ep, req))
1124 ep0_end_in_req(ep, req, NULL);
1127 if ((length == 0) || !epout_has_pkt(ep))
1128 if (read_ep0_fifo(ep, req))
1129 ep0_end_out_req(ep, req, NULL);
1132 ep_err(ep, "odd state %s to send me a request\n",
1133 EP0_STNAME(ep->dev));
1134 ep_del_request(ep, req);
1140 handle_ep(ep);
1146 spin_unlock_irqrestore(&ep->lock, flags);
1159 struct pxa_ep *ep;
1168 ep = udc_usb_ep->pxa_ep;
1169 if (!ep || is_ep0(ep))
1172 spin_lock_irqsave(&ep->lock, flags);
1175 list_for_each_entry(iter, &ep->queue, queue) {
1183 spin_unlock_irqrestore(&ep->lock, flags);
1185 req_done(ep, req, -ECONNRESET, NULL);
1198 struct pxa_ep *ep;
1207 ep = udc_usb_ep->pxa_ep;
1208 if (!ep || is_ep0(ep))
1218 ep_dbg(ep, "only host can clear halt\n");
1222 spin_lock_irqsave(&ep->lock, flags);
1225 if (ep->dir_in && (ep_is_full(ep) || !list_empty(&ep->queue)))
1230 ep_write_UDCCSR(ep, UDCCSR_FST | UDCCSR_FEF);
1231 if (is_ep0(ep))
1232 set_ep0state(ep->dev, STALL);
1235 spin_unlock_irqrestore(&ep->lock, flags);
1247 struct pxa_ep *ep;
1253 ep = udc_usb_ep->pxa_ep;
1254 if (!ep || is_ep0(ep))
1257 if (ep->dir_in)
1259 if (ep->dev->gadget.speed == USB_SPEED_UNKNOWN || ep_is_empty(ep))
1262 return ep_count_bytes_remain(ep) + 1;
1273 struct pxa_ep *ep;
1280 ep = udc_usb_ep->pxa_ep;
1281 if (!ep || is_ep0(ep))
1284 spin_lock_irqsave(&ep->lock, flags);
1286 if (unlikely(!list_empty(&ep->queue)))
1287 ep_dbg(ep, "called while queue list not empty\n");
1288 ep_dbg(ep, "called\n");
1291 if (!ep->dir_in) {
1292 while (!ep_is_empty(ep))
1293 udc_ep_readl(ep, UDCDR);
1296 ep_write_UDCCSR(ep,
1298 | (EPXFERTYPE_is_ISO(ep) ? 0 : UDCCSR_SST));
1301 spin_unlock_irqrestore(&ep->lock, flags);
1309 * Nothing much to do here, as ep configuration is done once and for all
1317 struct pxa_ep *ep;
1326 ep = udc_usb_ep->pxa_ep;
1327 ep_warn(ep, "usb_ep %s already enabled, doing nothing\n",
1330 ep = find_pxa_ep(udc_usb_ep->dev, udc_usb_ep);
1333 if (!ep || is_ep0(ep)) {
1335 "unable to match pxa_ep for ep %s\n",
1341 || (ep->type != usb_endpoint_type(desc))) {
1342 ep_err(ep, "type mismatch\n");
1346 if (ep->fifo_size < usb_endpoint_maxp(desc)) {
1347 ep_err(ep, "bad maxpacket\n");
1351 udc_usb_ep->pxa_ep = ep;
1352 udc = ep->dev;
1355 ep_err(ep, "bogus device state\n");
1359 ep->enabled = 1;
1364 ep_dbg(ep, "enabled\n");
1378 struct pxa_ep *ep;
1385 ep = udc_usb_ep->pxa_ep;
1386 if (!ep || is_ep0(ep) || !list_empty(&ep->queue))
1389 ep->enabled = 0;
1390 nuke(ep, -ESHUTDOWN);
1395 ep_dbg(ep, "disabled\n");
1659 struct pxa_ep *ep;
1670 ep = &dev->pxa_ep[i];
1672 ep->enabled = is_ep0(ep);
1673 INIT_LIST_HEAD(&ep->queue);
1674 spin_lock_init(&ep->lock);
1817 struct pxa_ep *ep = &udc->pxa_ep[0];
1826 nuke(ep, -EPROTO);
1827 spin_lock_irqsave(&ep->lock, flags);
1835 if (epout_has_pkt(ep) && (ep_count_bytes_remain(ep) == 0))
1836 ep_write_UDCCSR(ep, UDCCSR0_OPC);
1840 if (unlikely(ep_is_empty(ep)))
1842 u.word[i] = udc_ep_readl(ep, UDCDR);
1845 have_extrabytes = !ep_is_empty(ep);
1846 while (!ep_is_empty(ep)) {
1847 i = udc_ep_readl(ep, UDCDR);
1848 ep_err(ep, "wrong to have extra bytes for setup : 0x%08x\n", i);
1851 ep_dbg(ep, "SETUP %02x.%02x v%04x i%04x l%04x\n",
1864 ep_write_UDCCSR(ep, UDCCSR0_SA | UDCCSR0_OPC);
1866 spin_unlock_irqrestore(&ep->lock, flags);
1868 spin_lock_irqsave(&ep->lock, flags);
1872 spin_unlock_irqrestore(&ep->lock, flags);
1875 ep_dbg(ep, "protocol STALL, udccsr0=%03x err %d\n",
1876 udc_ep_readl(ep, UDCCSR), i);
1877 ep_write_UDCCSR(ep, UDCCSR0_FST | UDCCSR0_FTF);
1933 struct pxa_ep *ep = &udc->pxa_ep[0];
1937 if (!list_empty(&ep->queue))
1938 req = list_entry(ep->queue.next, struct pxa27x_request, queue);
1940 udccsr0 = udc_ep_readl(ep, UDCCSR);
1941 ep_dbg(ep, "state=%s, req=%p, udccsr0=0x%03x, udcbcr=%d, irq_msk=%x\n",
1942 EP0_STNAME(udc), req, udccsr0, udc_ep_readl(ep, UDCBCR),
1946 ep_dbg(ep, "clearing stall status\n");
1947 nuke(ep, -EPIPE);
1948 ep_write_UDCCSR(ep, UDCCSR0_SST);
1953 nuke(ep, 0);
1972 if (epout_has_pkt(ep))
1973 ep_write_UDCCSR(ep, UDCCSR0_OPC);
1974 if (req && !ep_is_full(ep))
1975 completed = write_ep0_fifo(ep, req);
1977 ep0_end_in_req(ep, req, NULL);
1980 if (epout_has_pkt(ep) && req)
1981 completed = read_ep0_fifo(ep, req);
1983 ep0_end_out_req(ep, req, NULL);
1986 ep_write_UDCCSR(ep, UDCCSR0_FST);
1999 ep_warn(ep, "should never get in %s state here!!!\n",
2000 EP0_STNAME(ep->dev));
2008 * @ep: pxa physical endpoint
2013 * Is always called from the interrupt handler. ep->lock must not be held.
2015 static void handle_ep(struct pxa_ep *ep)
2020 int is_in = ep->dir_in;
2024 spin_lock_irqsave(&ep->lock, flags);
2025 if (ep->in_handle_ep)
2027 ep->in_handle_ep = 1;
2031 udccsr = udc_ep_readl(ep, UDCCSR);
2033 if (likely(!list_empty(&ep->queue)))
2034 req = list_entry(ep->queue.next,
2039 ep_dbg(ep, "req:%p, udccsr 0x%03x loop=%d\n",
2043 udc_ep_writel(ep, UDCCSR,
2049 if (likely(!ep_is_full(ep)))
2050 completed = write_fifo(ep, req);
2052 if (likely(epout_has_pkt(ep)))
2053 completed = read_fifo(ep, req);
2058 ep_end_in_req(ep, req, &flags);
2060 ep_end_out_req(ep, req, &flags);
2064 ep->in_handle_ep = 0;
2066 spin_unlock_irqrestore(&ep->lock, flags);
2137 struct pxa_ep *ep;
2157 ep = &udc->pxa_ep[i];
2158 ep->stats.irqs++;
2159 handle_ep(ep);
2170 ep = &udc->pxa_ep[i];
2171 ep->stats.irqs++;
2172 handle_ep(ep);
2239 struct pxa_ep *ep = &udc->pxa_ep[0];
2252 nuke(ep, -EPROTO);
2253 ep_write_UDCCSR(ep, UDCCSR0_FTF | UDCCSR0_OPC);
2484 struct pxa_ep *ep;
2486 ep = &udc->pxa_ep[0];
2487 udc->udccsr0 = udc_ep_readl(ep, UDCCSR);
2509 struct pxa_ep *ep;
2511 ep = &udc->pxa_ep[0];
2512 udc_ep_writel(ep, UDCCSR, udc->udccsr0 & (UDCCSR0_FST | UDCCSR0_DME));