Lines Matching refs:ep
79 static void handle_ep(struct pxa_ep *ep);
142 struct pxa_ep *ep;
152 ep = &udc->pxa_ep[i];
153 maxpkt = ep->fifo_size;
155 EPNAME(ep), maxpkt, "pio");
157 if (list_empty(&ep->queue)) {
162 list_for_each_entry(req, &ep->queue, queue) {
177 struct pxa_ep *ep;
185 ep = &udc->pxa_ep[0];
186 tmp = udc_ep_readl(ep, UDCCSR);
196 ep = &udc->pxa_ep[i];
197 tmp = i? udc_ep_readl(ep, UDCCR) : udc_readl(udc, UDCCR);
202 EPNAME(ep),
203 ep->stats.in_bytes, ep->stats.in_ops,
204 ep->stats.out_bytes, ep->stats.out_ops,
205 ep->stats.irqs,
206 tmp, udc_ep_readl(ep, UDCCSR),
207 udc_ep_readl(ep, UDCBCR));
315 * @ep: pxa endpoint
322 static int is_match_usb_pxa(struct udc_usb_ep *udc_usb_ep, struct pxa_ep *ep,
325 if (usb_endpoint_num(&udc_usb_ep->desc) != ep->addr)
327 if (usb_endpoint_dir_in(&udc_usb_ep->desc) != ep->dir_in)
329 if (usb_endpoint_type(&udc_usb_ep->desc) != ep->type)
331 if ((ep->config != config) || (ep->interface != interface)
332 || (ep->alternate != altsetting))
366 struct pxa_ep *ep;
375 ep = &udc->pxa_ep[i];
376 if (is_match_usb_pxa(udc_usb_ep, ep, cfg, iface, alt))
377 return ep;
406 * @ep: udc endpoint
408 static void pio_irq_enable(struct pxa_ep *ep)
410 struct pxa_udc *udc = ep->dev;
411 int index = EPIDX(ep);
423 * @ep: udc endpoint
425 static void pio_irq_disable(struct pxa_ep *ep)
427 struct pxa_udc *udc = ep->dev;
428 int index = EPIDX(ep);
476 static inline void ep_write_UDCCSR(struct pxa_ep *ep, int mask)
478 if (is_ep0(ep))
480 udc_ep_writel(ep, UDCCSR, mask);
485 * @ep: udc endpoint
489 static int ep_count_bytes_remain(struct pxa_ep *ep)
491 if (ep->dir_in)
493 return udc_ep_readl(ep, UDCBCR) & 0x3ff;
497 * ep_is_empty - checks if ep has byte ready for reading
498 * @ep: udc endpoint
504 * Returns 0 if ep not empty, 1 if ep empty, -EOPNOTSUPP if IN endpoint
506 static int ep_is_empty(struct pxa_ep *ep)
510 if (!is_ep0(ep) && ep->dir_in)
512 if (is_ep0(ep))
513 ret = !(udc_ep_readl(ep, UDCCSR) & UDCCSR0_RNE);
515 ret = !(udc_ep_readl(ep, UDCCSR) & UDCCSR_BNE);
520 * ep_is_full - checks if ep has place to write bytes
521 * @ep: udc endpoint
526 * Returns 0 if ep not full, 1 if ep full, -EOPNOTSUPP if OUT endpoint
528 static int ep_is_full(struct pxa_ep *ep)
530 if (is_ep0(ep))
531 return (udc_ep_readl(ep, UDCCSR) & UDCCSR0_IPR);
532 if (!ep->dir_in)
534 return (!(udc_ep_readl(ep, UDCCSR) & UDCCSR_BNF));
539 * @ep: pxa endpoint
541 * Returns 1 if a complete packet is available, 0 if not, -EOPNOTSUPP for IN ep.
543 static int epout_has_pkt(struct pxa_ep *ep)
545 if (!is_ep0(ep) && ep->dir_in)
547 if (is_ep0(ep))
548 return (udc_ep_readl(ep, UDCCSR) & UDCCSR0_OPC);
549 return (udc_ep_readl(ep, UDCCSR) & UDCCSR_PC);
559 struct pxa_ep *ep = &udc->pxa_ep[0];
563 ep_dbg(ep, "state=%s->%s, udccsr0=0x%03x, udcbcr=%d\n", old_stname,
564 EP0_STNAME(udc), udc_ep_readl(ep, UDCCSR),
565 udc_ep_readl(ep, UDCBCR));
578 * inc_ep_stats_reqs - Update ep stats counts
579 * @ep: physical endpoint
581 * @is_in: ep direction (USB_DIR_IN or 0)
584 static void inc_ep_stats_reqs(struct pxa_ep *ep, int is_in)
587 ep->stats.in_ops++;
589 ep->stats.out_ops++;
593 * inc_ep_stats_bytes - Update ep stats counts
594 * @ep: physical endpoint
596 * @is_in: ep direction (USB_DIR_IN or 0)
598 static void inc_ep_stats_bytes(struct pxa_ep *ep, int count, int is_in)
601 ep->stats.in_bytes += count;
603 ep->stats.out_bytes += count;
608 * @ep: pxa27x physical endpoint
610 * Find the physical pxa27x ep, and setup its UDCCR
612 static void pxa_ep_setup(struct pxa_ep *ep)
616 new_udccr = ((ep->config << UDCCONR_CN_S) & UDCCONR_CN)
617 | ((ep->interface << UDCCONR_IN_S) & UDCCONR_IN)
618 | ((ep->alternate << UDCCONR_AISN_S) & UDCCONR_AISN)
619 | ((EPADDR(ep) << UDCCONR_EN_S) & UDCCONR_EN)
620 | ((EPXFERTYPE(ep) << UDCCONR_ET_S) & UDCCONR_ET)
621 | ((ep->dir_in) ? UDCCONR_ED : 0)
622 | ((ep->fifo_size << UDCCONR_MPS_S) & UDCCONR_MPS)
625 udc_ep_writel(ep, UDCCR, new_udccr);
687 * @ep: usb endpoint
690 * Context: ep->lock held
695 static void ep_add_request(struct pxa_ep *ep, struct pxa27x_request *req)
699 ep_vdbg(ep, "req:%p, lg=%d, udccsr=0x%03x\n", req,
700 req->req.length, udc_ep_readl(ep, UDCCSR));
703 list_add_tail(&req->queue, &ep->queue);
704 pio_irq_enable(ep);
709 * @ep: usb endpoint
712 * Context: ep->lock held
718 static void ep_del_request(struct pxa_ep *ep, struct pxa27x_request *req)
722 ep_vdbg(ep, "req:%p, lg=%d, udccsr=0x%03x\n", req,
723 req->req.length, udc_ep_readl(ep, UDCCSR));
727 if (!is_ep0(ep) && list_empty(&ep->queue))
728 pio_irq_disable(ep);
733 * @ep: pxa physical endpoint
738 * Context: ep->lock held if flags not NULL, else ep->lock released
742 static void req_done(struct pxa_ep *ep, struct pxa27x_request *req, int status,
747 ep_del_request(ep, req);
754 ep_dbg(ep, "complete req %p stat %d len %u/%u\n",
759 spin_unlock_irqrestore(&ep->lock, *pflags);
764 spin_lock_irqsave(&ep->lock, *pflags);
769 * @ep: physical endpoint
773 * Context: ep->lock held or released (see req_done())
777 static void ep_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req,
780 inc_ep_stats_reqs(ep, !USB_DIR_IN);
781 req_done(ep, req, 0, pflags);
786 * @ep: physical endpoint
790 * Context: ep->lock held or released (see req_done())
795 static void ep0_end_out_req(struct pxa_ep *ep, struct pxa27x_request *req,
798 set_ep0state(ep->dev, OUT_STATUS_STAGE);
799 ep_end_out_req(ep, req, pflags);
800 ep0_idle(ep->dev);
805 * @ep: physical endpoint
809 * Context: ep->lock held or released (see req_done())
813 static void ep_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req,
816 inc_ep_stats_reqs(ep, USB_DIR_IN);
817 req_done(ep, req, 0, pflags);
822 * @ep: physical endpoint
826 * Context: ep->lock held or released (see req_done())
831 static void ep0_end_in_req(struct pxa_ep *ep, struct pxa27x_request *req,
834 set_ep0state(ep->dev, IN_STATUS_STAGE);
835 ep_end_in_req(ep, req, pflags);
840 * @ep: pxa endpoint
843 * Context: ep->lock released
848 static void nuke(struct pxa_ep *ep, int status)
853 spin_lock_irqsave(&ep->lock, flags);
854 while (!list_empty(&ep->queue)) {
855 req = list_entry(ep->queue.next, struct pxa27x_request, queue);
856 req_done(ep, req, status, &flags);
858 spin_unlock_irqrestore(&ep->lock, flags);
863 * @ep: pxa physical endpoint
872 static int read_packet(struct pxa_ep *ep, struct pxa27x_request *req)
877 bytes_ep = ep_count_bytes_remain(ep);
883 if (likely(!ep_is_empty(ep)))
889 *buf++ = udc_ep_readl(ep, UDCDR);
892 ep_write_UDCCSR(ep, UDCCSR_PC);
899 * @ep: pxa physical endpoint
909 static int write_packet(struct pxa_ep *ep, struct pxa27x_request *req,
925 udc_ep_writel(ep, UDCDR, *buf++);
929 udc_ep_writeb(ep, UDCDR, *buf_8++);
931 ep_vdbg(ep, "length=%d+%d, udccsr=0x%03x\n", count, remain,
932 udc_ep_readl(ep, UDCCSR));
939 * @ep: pxa physical endpoint
951 static int read_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
955 while (epout_has_pkt(ep)) {
956 count = read_packet(ep, req);
957 inc_ep_stats_bytes(ep, count, !USB_DIR_IN);
959 is_short = (count < ep->fifo_size);
960 ep_dbg(ep, "read udccsr:%03x, count:%d bytes%s req %p %d/%d\n",
961 udc_ep_readl(ep, UDCCSR), count, is_short ? "/S" : "",
976 * @ep: pxa physical endpoint
986 static int write_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
992 max = ep->fifo_size;
996 udccsr = udc_ep_readl(ep, UDCCSR);
998 ep_vdbg(ep, "Clearing Transmit Complete, udccsr=%x\n",
1000 ep_write_UDCCSR(ep, UDCCSR_PC);
1003 ep_vdbg(ep, "Clearing Underrun on, udccsr=%x\n",
1005 ep_write_UDCCSR(ep, UDCCSR_TRN);
1008 count = write_packet(ep, req, max);
1009 inc_ep_stats_bytes(ep, count, USB_DIR_IN);
1023 is_short = unlikely(max < ep->fifo_size);
1027 ep_write_UDCCSR(ep, UDCCSR_SP);
1034 } while (!ep_is_full(ep));
1036 ep_dbg(ep, "wrote count:%d bytes%s%s, left:%d req=%p\n",
1045 * @ep: control endpoint
1054 static int read_ep0_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
1058 while (epout_has_pkt(ep)) {
1059 count = read_packet(ep, req);
1060 ep_write_UDCCSR(ep, UDCCSR0_OPC);
1061 inc_ep_stats_bytes(ep, count, !USB_DIR_IN);
1063 is_short = (count < ep->fifo_size);
1064 ep_dbg(ep, "read udccsr:%03x, count:%d bytes%s req %p %d/%d\n",
1065 udc_ep_readl(ep, UDCCSR), count, is_short ? "/S" : "",
1079 * @ep: control endpoint
1092 static int write_ep0_fifo(struct pxa_ep *ep, struct pxa27x_request *req)
1097 count = write_packet(ep, req, EP0_FIFO_SIZE);
1098 inc_ep_stats_bytes(ep, count, USB_DIR_IN);
1105 ep_write_UDCCSR(ep, UDCCSR0_IPR);
1107 ep_dbg(ep, "in %d bytes%s%s, %d left, req=%p, udccsr0=0x%03x\n",
1110 &req->req, udc_ep_readl(ep, UDCCSR));
1131 struct pxa_ep *ep;
1150 ep = udc_usb_ep->pxa_ep;
1151 if (unlikely(!ep))
1154 dev = ep->dev;
1156 ep_dbg(ep, "bogus device state\n");
1163 if (unlikely(EPXFERTYPE_is_ISO(ep)
1164 && req->req.length > ep->fifo_size))
1167 spin_lock_irqsave(&ep->lock, flags);
1168 recursion_detected = ep->in_handle_ep;
1170 is_first_req = list_empty(&ep->queue);
1171 ep_dbg(ep, "queue req %p(first=%s), len %d buf %p\n",
1175 if (!ep->enabled) {
1182 ep_err(ep, "refusing to queue req %p (already queued)\n", req);
1190 ep_add_request(ep, req);
1191 spin_unlock_irqrestore(&ep->lock, flags);
1193 if (is_ep0(ep)) {
1197 ep_end_in_req(ep, req, NULL);
1199 ep_err(ep, "got a request of %d bytes while"
1202 ep_del_request(ep, req);
1205 ep0_idle(ep->dev);
1208 if (!ep_is_full(ep))
1209 if (write_ep0_fifo(ep, req))
1210 ep0_end_in_req(ep, req, NULL);
1213 if ((length == 0) || !epout_has_pkt(ep))
1214 if (read_ep0_fifo(ep, req))
1215 ep0_end_out_req(ep, req, NULL);
1218 ep_err(ep, "odd state %s to send me a request\n",
1219 EP0_STNAME(ep->dev));
1220 ep_del_request(ep, req);
1226 handle_ep(ep);
1232 spin_unlock_irqrestore(&ep->lock, flags);
1245 struct pxa_ep *ep;
1254 ep = udc_usb_ep->pxa_ep;
1255 if (!ep || is_ep0(ep))
1258 spin_lock_irqsave(&ep->lock, flags);
1261 list_for_each_entry(req, &ep->queue, queue) {
1268 spin_unlock_irqrestore(&ep->lock, flags);
1270 req_done(ep, req, -ECONNRESET, NULL);
1283 struct pxa_ep *ep;
1292 ep = udc_usb_ep->pxa_ep;
1293 if (!ep || is_ep0(ep))
1303 ep_dbg(ep, "only host can clear halt\n");
1307 spin_lock_irqsave(&ep->lock, flags);
1310 if (ep->dir_in && (ep_is_full(ep) || !list_empty(&ep->queue)))
1315 ep_write_UDCCSR(ep, UDCCSR_FST | UDCCSR_FEF);
1316 if (is_ep0(ep))
1317 set_ep0state(ep->dev, STALL);
1320 spin_unlock_irqrestore(&ep->lock, flags);
1332 struct pxa_ep *ep;
1338 ep = udc_usb_ep->pxa_ep;
1339 if (!ep || is_ep0(ep))
1342 if (ep->dir_in)
1344 if (ep->dev->gadget.speed == USB_SPEED_UNKNOWN || ep_is_empty(ep))
1347 return ep_count_bytes_remain(ep) + 1;
1358 struct pxa_ep *ep;
1365 ep = udc_usb_ep->pxa_ep;
1366 if (!ep || is_ep0(ep))
1369 spin_lock_irqsave(&ep->lock, flags);
1371 if (unlikely(!list_empty(&ep->queue)))
1372 ep_dbg(ep, "called while queue list not empty\n");
1373 ep_dbg(ep, "called\n");
1376 if (!ep->dir_in) {
1377 while (!ep_is_empty(ep))
1378 udc_ep_readl(ep, UDCDR);
1381 ep_write_UDCCSR(ep,
1383 | (EPXFERTYPE_is_ISO(ep) ? 0 : UDCCSR_SST));
1386 spin_unlock_irqrestore(&ep->lock, flags);
1394 * Nothing much to do here, as ep configuration is done once and for all
1402 struct pxa_ep *ep;
1411 ep = udc_usb_ep->pxa_ep;
1412 ep_warn(ep, "usb_ep %s already enabled, doing nothing\n",
1415 ep = find_pxa_ep(udc_usb_ep->dev, udc_usb_ep);
1418 if (!ep || is_ep0(ep)) {
1420 "unable to match pxa_ep for ep %s\n",
1426 || (ep->type != usb_endpoint_type(desc))) {
1427 ep_err(ep, "type mismatch\n");
1431 if (ep->fifo_size < usb_endpoint_maxp(desc)) {
1432 ep_err(ep, "bad maxpacket\n");
1436 udc_usb_ep->pxa_ep = ep;
1437 udc = ep->dev;
1440 ep_err(ep, "bogus device state\n");
1444 ep->enabled = 1;
1449 ep_dbg(ep, "enabled\n");
1463 struct pxa_ep *ep;
1470 ep = udc_usb_ep->pxa_ep;
1471 if (!ep || is_ep0(ep) || !list_empty(&ep->queue))
1474 ep->enabled = 0;
1475 nuke(ep, -ESHUTDOWN);
1480 ep_dbg(ep, "disabled\n");
1722 struct pxa_ep *ep;
1732 ep = &dev->pxa_ep[i];
1734 ep->enabled = is_ep0(ep);
1735 INIT_LIST_HEAD(&ep->queue);
1736 spin_lock_init(&ep->lock);
1886 struct pxa_ep *ep = &udc->pxa_ep[0];
1895 nuke(ep, -EPROTO);
1896 spin_lock_irqsave(&ep->lock, flags);
1904 if (epout_has_pkt(ep) && (ep_count_bytes_remain(ep) == 0))
1905 ep_write_UDCCSR(ep, UDCCSR0_OPC);
1909 if (unlikely(ep_is_empty(ep)))
1911 u.word[i] = udc_ep_readl(ep, UDCDR);
1914 have_extrabytes = !ep_is_empty(ep);
1915 while (!ep_is_empty(ep)) {
1916 i = udc_ep_readl(ep, UDCDR);
1917 ep_err(ep, "wrong to have extra bytes for setup : 0x%08x\n", i);
1920 ep_dbg(ep, "SETUP %02x.%02x v%04x i%04x l%04x\n",
1933 ep_write_UDCCSR(ep, UDCCSR0_SA | UDCCSR0_OPC);
1935 spin_unlock_irqrestore(&ep->lock, flags);
1937 spin_lock_irqsave(&ep->lock, flags);
1941 spin_unlock_irqrestore(&ep->lock, flags);
1944 ep_dbg(ep, "protocol STALL, udccsr0=%03x err %d\n",
1945 udc_ep_readl(ep, UDCCSR), i);
1946 ep_write_UDCCSR(ep, UDCCSR0_FST | UDCCSR0_FTF);
1957 * Context : when in_interrupt() or with ep->lock held
2002 struct pxa_ep *ep = &udc->pxa_ep[0];
2006 if (!list_empty(&ep->queue))
2007 req = list_entry(ep->queue.next, struct pxa27x_request, queue);
2009 udccsr0 = udc_ep_readl(ep, UDCCSR);
2010 ep_dbg(ep, "state=%s, req=%p, udccsr0=0x%03x, udcbcr=%d, irq_msk=%x\n",
2011 EP0_STNAME(udc), req, udccsr0, udc_ep_readl(ep, UDCBCR),
2015 ep_dbg(ep, "clearing stall status\n");
2016 nuke(ep, -EPIPE);
2017 ep_write_UDCCSR(ep, UDCCSR0_SST);
2022 nuke(ep, 0);
2041 if (epout_has_pkt(ep))
2042 ep_write_UDCCSR(ep, UDCCSR0_OPC);
2043 if (req && !ep_is_full(ep))
2044 completed = write_ep0_fifo(ep, req);
2046 ep0_end_in_req(ep, req, NULL);
2049 if (epout_has_pkt(ep) && req)
2050 completed = read_ep0_fifo(ep, req);
2052 ep0_end_out_req(ep, req, NULL);
2055 ep_write_UDCCSR(ep, UDCCSR0_FST);
2068 ep_warn(ep, "should never get in %s state here!!!\n",
2069 EP0_STNAME(ep->dev));
2077 * @ep: pxa physical endpoint
2082 * Is always called when in_interrupt() and with ep->lock released.
2084 static void handle_ep(struct pxa_ep *ep)
2089 int is_in = ep->dir_in;
2093 spin_lock_irqsave(&ep->lock, flags);
2094 if (ep->in_handle_ep)
2096 ep->in_handle_ep = 1;
2100 udccsr = udc_ep_readl(ep, UDCCSR);
2102 if (likely(!list_empty(&ep->queue)))
2103 req = list_entry(ep->queue.next,
2108 ep_dbg(ep, "req:%p, udccsr 0x%03x loop=%d\n",
2112 udc_ep_writel(ep, UDCCSR,
2118 if (likely(!ep_is_full(ep)))
2119 completed = write_fifo(ep, req);
2121 if (likely(epout_has_pkt(ep)))
2122 completed = read_fifo(ep, req);
2127 ep_end_in_req(ep, req, &flags);
2129 ep_end_out_req(ep, req, &flags);
2133 ep->in_handle_ep = 0;
2135 spin_unlock_irqrestore(&ep->lock, flags);
2206 struct pxa_ep *ep;
2226 ep = &udc->pxa_ep[i];
2227 ep->stats.irqs++;
2228 handle_ep(ep);
2239 ep = &udc->pxa_ep[i];
2240 ep->stats.irqs++;
2241 handle_ep(ep);
2308 struct pxa_ep *ep = &udc->pxa_ep[0];
2321 nuke(ep, -EPROTO);
2322 ep_write_UDCCSR(ep, UDCCSR0_FTF | UDCCSR0_OPC);
2551 struct pxa_ep *ep;
2553 ep = &udc->pxa_ep[0];
2554 udc->udccsr0 = udc_ep_readl(ep, UDCCSR);
2556 ep = &udc->pxa_ep[i];
2557 ep->udccsr_value = udc_ep_readl(ep, UDCCSR);
2558 ep->udccr_value = udc_ep_readl(ep, UDCCR);
2559 ep_dbg(ep, "udccsr:0x%03x, udccr:0x%x\n",
2560 ep->udccsr_value, ep->udccr_value);
2581 struct pxa_ep *ep;
2583 ep = &udc->pxa_ep[0];
2584 udc_ep_writel(ep, UDCCSR, udc->udccsr0 & (UDCCSR0_FST | UDCCSR0_DME));
2586 ep = &udc->pxa_ep[i];
2587 udc_ep_writel(ep, UDCCSR, ep->udccsr_value);
2588 udc_ep_writel(ep, UDCCR, ep->udccr_value);
2589 ep_dbg(ep, "udccsr:0x%03x, udccr:0x%x\n",
2590 ep->udccsr_value, ep->udccr_value);