Lines Matching refs:ep
14 * - Endpoint numbering is fixed: ep{1,2,3}-bulk
15 * - Gadget drivers can choose ep maxpacket (8/16/32/64)
94 struct goku_ep *ep;
99 ep = container_of(_ep, struct goku_ep, ep);
103 dev = ep->dev;
104 if (ep == &dev->ep[0])
108 if (ep->num != usb_endpoint_num(desc))
119 if ((readl(ep->reg_status) & EPxSTATUS_EP_MASK)
147 ep->is_in = usb_endpoint_dir_in(desc);
148 if (ep->is_in) {
150 ep->dma = (use_dma != 0) && (ep->num == UDC_MSTRD_ENDPOINT);
152 ep->dma = (use_dma == 2) && (ep->num == UDC_MSTWR_ENDPOINT);
153 if (ep->dma)
155 ep->ep.name);
158 spin_lock_irqsave(&ep->dev->lock, flags);
161 if (ep->num < 3) {
162 struct goku_udc_regs __iomem *regs = ep->dev->regs;
166 tmp = ((ep->dma || !ep->is_in)
169 ) << ep->num;
173 tmp = (ep->dma ? 0x10/*dma*/ : 0x11/*pio*/) << ep->num;
177 writel(mode, ep->reg_mode);
178 command(ep->dev->regs, COMMAND_RESET, ep->num);
179 ep->ep.maxpacket = max;
180 ep->stopped = 0;
181 ep->ep.desc = desc;
182 spin_unlock_irqrestore(&ep->dev->lock, flags);
184 DBG(dev, "enable %s %s %s maxpacket %u\n", ep->ep.name,
185 ep->is_in ? "IN" : "OUT",
186 ep->dma ? "dma" : "pio",
192 static void ep_reset(struct goku_udc_regs __iomem *regs, struct goku_ep *ep)
194 struct goku_udc *dev = ep->dev;
197 command(regs, COMMAND_INVALID, ep->num);
198 if (ep->num) {
199 if (ep->num == UDC_MSTWR_ENDPOINT)
202 else if (ep->num == UDC_MSTRD_ENDPOINT)
204 dev->int_enable &= ~INT_EPxDATASET (ep->num);
209 if (ep->num < 3) {
210 struct goku_udc_regs __iomem *r = ep->dev->regs;
214 tmp &= ~(0x11 << ep->num);
218 tmp &= ~(0x11 << ep->num);
222 if (ep->dma) {
226 if (ep->num == UDC_MSTWR_ENDPOINT) {
237 usb_ep_set_maxpacket_limit(&ep->ep, MAX_FIFO_SIZE);
238 ep->ep.desc = NULL;
239 ep->stopped = 1;
240 ep->irqs = 0;
241 ep->dma = 0;
246 struct goku_ep *ep;
250 ep = container_of(_ep, struct goku_ep, ep);
251 if (!_ep || !ep->ep.desc)
253 dev = ep->dev;
260 nuke(ep, -ESHUTDOWN);
261 ep_reset(dev->regs, ep);
300 done(struct goku_ep *ep, struct goku_request *req, int status)
303 unsigned stopped = ep->stopped;
312 dev = ep->dev;
314 if (ep->dma)
315 usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
321 ep->ep.name, &req->req, status,
325 ep->stopped = 1;
327 usb_gadget_giveback_request(&ep->ep, &req->req);
329 ep->stopped = stopped;
349 static int write_fifo(struct goku_ep *ep, struct goku_request *req)
351 struct goku_udc *dev = ep->dev;
361 dev = ep->dev;
362 if (unlikely(ep->num == 0 && dev->ep0state != EP0_IN))
366 if (unlikely((tmp & DATASET_A(ep->num)) != 0))
370 if (ep->num != 0)
371 writel(~INT_EPxDATASET(ep->num), &dev->regs->int_status);
373 count = write_packet(ep->reg_fifo, buf, req, ep->ep.maxpacket);
376 if (unlikely(count != ep->ep.maxpacket)) {
377 writel(~(1<<ep->num), &dev->regs->EOP);
378 if (ep->num == 0) {
379 dev->ep[0].stopped = 1;
393 ep->ep.name, count, is_last ? "/last" : "",
401 done(ep, req, 0);
408 static int read_fifo(struct goku_ep *ep, struct goku_request *req)
415 regs = ep->dev->regs;
420 if (unlikely(ep->num == 0 && ep->dev->ep0state != EP0_OUT))
423 dbuff = (ep->num == 1 || ep->num == 2);
426 if (ep->num != 0)
427 writel(~INT_EPxDATASET(ep->num), ®s->int_status);
429 set = readl(®s->DataSet) & DATASET_AB(ep->num);
430 size = readl(®s->EPxSizeLA[ep->num]);
434 if (likely(ep->num != 0 || bufferspace != 0)) {
439 size = readl(®s->EPxSizeLB[ep->num]);
450 is_short = (size < ep->ep.maxpacket);
452 VDBG(ep->dev, "read %s %u bytes%s OUT req %p %u/%u\n",
453 ep->ep.name, size, is_short ? "/S" : "",
457 u8 byte = (u8) readl(ep->reg_fifo);
465 DBG(ep->dev, "%s overflow %u\n",
466 ep->ep.name, size);
476 if (unlikely(ep->num == 0)) {
478 if (ep->dev->req_config)
479 writel(ep->dev->configured
485 ep->stopped = 1;
486 ep->dev->ep0state = EP0_STATUS;
488 done(ep, req, 0);
491 if (dbuff && !list_empty(&ep->queue)) {
492 req = list_entry(ep->queue.next,
521 pio_advance(struct goku_ep *ep)
525 if (unlikely(list_empty (&ep->queue)))
527 req = list_entry(ep->queue.next, struct goku_request, queue);
528 (ep->is_in ? write_fifo : read_fifo)(ep, req);
535 static int start_dma(struct goku_ep *ep, struct goku_request *req)
537 struct goku_udc_regs __iomem *regs = ep->dev->regs;
545 if (likely(ep->is_in)) {
547 DBG (ep->dev, "start, IN active dma %03x!!\n",
557 else if ((req->req.length % ep->ep.maxpacket) != 0
563 ep->dev->int_enable |= INT_MSTRDEND;
572 DBG (ep->dev, "start, OUT active dma %03x!!\n",
582 ep->dev->int_enable |= INT_MSTWREND|INT_MSTWRTMOUT;
586 writel(ep->dev->int_enable, ®s->int_enable);
590 static void dma_advance(struct goku_udc *dev, struct goku_ep *ep)
593 struct goku_udc_regs __iomem *regs = ep->dev->regs;
598 if (unlikely(list_empty(&ep->queue))) {
600 if (ep->is_in)
607 req = list_entry(ep->queue.next, struct goku_request, queue);
610 if (likely(ep->is_in)) {
628 ep->ep.name, ep->is_in ? "IN" : "OUT",
631 done(ep, req, 0);
632 if (list_empty(&ep->queue))
634 req = list_entry(ep->queue.next, struct goku_request, queue);
635 (void) start_dma(ep, req);
638 static void abort_dma(struct goku_ep *ep, int status)
640 struct goku_udc_regs __iomem *regs = ep->dev->regs;
651 command(regs, COMMAND_FIFO_DISABLE, ep->num);
652 req = list_entry(ep->queue.next, struct goku_request, queue);
660 if (ep->is_in) {
673 DBG(ep->dev, "IN dma active after reset!\n");
688 DBG(ep->dev, "OUT dma active after reset!\n");
693 VDBG(ep->dev, "%s %s %s %d/%d\n", __func__, ep->ep.name,
694 ep->is_in ? "IN" : "OUT",
697 command(regs, COMMAND_FIFO_ENABLE, ep->num);
703 command(regs, COMMAND_FIFO_ENABLE, ep->num);
714 struct goku_ep *ep;
724 ep = container_of(_ep, struct goku_ep, ep);
725 if (unlikely(!_ep || (!ep->ep.desc && ep->num != 0)))
727 dev = ep->dev;
736 if (ep->dma) {
738 ep->is_in);
756 if (unlikely(ep->num == 0 && ep->is_in))
761 if (list_empty(&ep->queue) && likely(!ep->stopped)) {
765 if (ep->dma)
766 status = start_dma(ep, req);
768 status = (ep->is_in ? write_fifo : read_fifo)(ep, req);
779 list_add_tail(&req->queue, &ep->queue);
781 if (likely(!list_empty(&ep->queue))
782 && likely(ep->num != 0)
783 && !ep->dma
784 && !(dev->int_enable & INT_EPxDATASET (ep->num)))
785 pio_irq_enable(dev, dev->regs, ep->num);
794 static void nuke(struct goku_ep *ep, int status)
798 ep->stopped = 1;
799 if (list_empty(&ep->queue))
801 if (ep->dma)
802 abort_dma(ep, status);
803 while (!list_empty(&ep->queue)) {
804 req = list_entry(ep->queue.next, struct goku_request, queue);
805 done(ep, req, status);
813 struct goku_ep *ep;
817 ep = container_of(_ep, struct goku_ep, ep);
818 if (!_ep || !_req || (!ep->ep.desc && ep->num != 0))
820 dev = ep->dev;
829 ep->is_in ? "IN" : "OUT",
830 ep->dma ? "dma" : "pio",
836 list_for_each_entry(iter, &ep->queue, queue) {
847 if (ep->dma && ep->queue.next == &req->queue && !ep->stopped) {
848 abort_dma(ep, -ECONNRESET);
849 done(ep, req, -ECONNRESET);
850 dma_advance(dev, ep);
852 done(ep, req, -ECONNRESET);
862 static void goku_clear_halt(struct goku_ep *ep)
864 // assert (ep->num !=0)
865 VDBG(ep->dev, "%s clear halt\n", ep->ep.name);
866 command(ep->dev->regs, COMMAND_SETDATA0, ep->num);
867 command(ep->dev->regs, COMMAND_STALL_CLEAR, ep->num);
868 if (ep->stopped) {
869 ep->stopped = 0;
870 if (ep->dma) {
873 if (list_empty(&ep->queue))
875 req = list_entry(ep->queue.next, struct goku_request,
877 (void) start_dma(ep, req);
879 pio_advance(ep);
885 struct goku_ep *ep;
891 ep = container_of (_ep, struct goku_ep, ep);
893 if (ep->num == 0) {
895 ep->dev->ep0state = EP0_STALL;
896 ep->dev->ep[0].stopped = 1;
901 } else if (!ep->ep.desc) {
902 DBG(ep->dev, "%s %s inactive?\n", __func__, ep->ep.name);
906 spin_lock_irqsave(&ep->dev->lock, flags);
907 if (!list_empty(&ep->queue))
909 else if (ep->is_in && value
911 && (readl(&ep->dev->regs->DataSet)
912 & DATASET_AB(ep->num)))
915 goku_clear_halt(ep);
917 ep->stopped = 1;
918 VDBG(ep->dev, "%s set halt\n", ep->ep.name);
919 command(ep->dev->regs, COMMAND_STALL, ep->num);
920 readl(ep->reg_status);
922 spin_unlock_irqrestore(&ep->dev->lock, flags);
928 struct goku_ep *ep;
934 ep = container_of(_ep, struct goku_ep, ep);
937 if (ep->is_in)
941 regs = ep->dev->regs;
942 size = readl(®s->EPxSizeLA[ep->num]) & DATASIZE;
943 size += readl(®s->EPxSizeLB[ep->num]) & DATASIZE;
944 VDBG(ep->dev, "%s %s %u\n", __func__, ep->ep.name, size);
950 struct goku_ep *ep;
956 ep = container_of(_ep, struct goku_ep, ep);
957 VDBG(ep->dev, "%s %s\n", __func__, ep->ep.name);
960 if (!ep->ep.desc && ep->num != 0) {
961 DBG(ep->dev, "%s %s inactive?\n", __func__, ep->ep.name);
965 regs = ep->dev->regs;
966 size = readl(®s->EPxSizeLA[ep->num]);
971 * the bytes out (PIO, if !ep->dma); for in, no choice.
974 command(regs, COMMAND_FIFO_CLEAR, ep->num);
1004 struct usb_ep *ep;
1009 ep = &dev->ep[3].ep;
1010 if (usb_gadget_ep_match_desc(g, ep, desc, ep_comp))
1011 return ep;
1016 ep = &dev->ep[2].ep;
1017 if (usb_gadget_ep_match_desc(g, ep, desc, ep_comp))
1018 return ep;
1199 struct goku_ep *ep = &dev->ep [i];
1202 if (i && !ep->ep.desc)
1205 tmp = readl(ep->reg_status);
1207 ep->ep.name,
1208 ep->is_in ? "in" : "out",
1209 ep->ep.maxpacket,
1210 ep->dma ? "dma" : "pio",
1211 ep->irqs,
1220 if (list_empty(&ep->queue)) {
1226 list_for_each_entry(req, &ep->queue, queue) {
1227 if (ep->dma && req->queue.prev == &ep->queue) {
1260 dev->gadget.ep0 = &dev->ep [0].ep;
1266 struct goku_ep *ep = &dev->ep[i];
1268 ep->num = i;
1269 ep->ep.name = names[i];
1270 ep->reg_fifo = &dev->regs->ep_fifo [i];
1271 ep->reg_status = &dev->regs->ep_status [i];
1272 ep->reg_mode = &dev->regs->ep_mode[i];
1274 ep->ep.ops = &goku_ep_ops;
1275 list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
1276 ep->dev = dev;
1277 INIT_LIST_HEAD (&ep->queue);
1279 ep_reset(NULL, ep);
1282 ep->ep.caps.type_control = true;
1284 ep->ep.caps.type_bulk = true;
1286 ep->ep.caps.dir_in = true;
1287 ep->ep.caps.dir_out = true;
1290 dev->ep[0].reg_mode = NULL;
1291 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, MAX_EP0_SIZE);
1292 list_del_init (&dev->ep[0].ep.ep_list);
1331 dev->ep[i].irqs = 0;
1398 nuke(&dev->ep [i], -ESHUTDOWN);
1436 nuke(&dev->ep[0], 0);
1437 dev->ep[0].stopped = 0;
1439 dev->ep[0].is_in = 1;
1444 dev->ep[0].is_in = 0;
1458 (!dev->ep[tmp].ep.desc && tmp != 0))
1462 if (!dev->ep[tmp].is_in)
1465 if (dev->ep[tmp].is_in)
1472 goku_clear_halt(&dev->ep[tmp]);
1476 dev->ep[0].stopped = 1;
1522 dev->ep[0].stopped = 1;
1539 struct goku_ep *ep;
1629 dev->ep[0].irqs++;
1635 ep = &dev->ep[0];
1636 ep->irqs++;
1637 nuke(ep, 0);
1644 ep = &dev->ep[0];
1645 ep->irqs++;
1646 pio_advance(ep);
1652 ep = &dev->ep[UDC_MSTRD_ENDPOINT];
1653 ep->irqs++;
1654 dma_advance(dev, ep);
1658 ep = &dev->ep[UDC_MSTWR_ENDPOINT];
1659 ep->irqs++;
1660 dma_advance(dev, ep);
1664 ep = &dev->ep[UDC_MSTWR_ENDPOINT];
1665 ep->irqs++;
1666 ERROR(dev, "%s write timeout ?\n", ep->ep.name);
1676 ep = &dev->ep[i];
1677 pio_advance(ep);
1678 if (list_empty (&ep->queue))
1682 ep->irqs++;