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 (req, &ep->queue, queue) {
845 if (ep->dma && ep->queue.next == &req->queue && !ep->stopped) {
846 abort_dma(ep, -ECONNRESET);
847 done(ep, req, -ECONNRESET);
848 dma_advance(dev, ep);
850 done(ep, req, -ECONNRESET);
860 static void goku_clear_halt(struct goku_ep *ep)
862 // assert (ep->num !=0)
863 VDBG(ep->dev, "%s clear halt\n", ep->ep.name);
864 command(ep->dev->regs, COMMAND_SETDATA0, ep->num);
865 command(ep->dev->regs, COMMAND_STALL_CLEAR, ep->num);
866 if (ep->stopped) {
867 ep->stopped = 0;
868 if (ep->dma) {
871 if (list_empty(&ep->queue))
873 req = list_entry(ep->queue.next, struct goku_request,
875 (void) start_dma(ep, req);
877 pio_advance(ep);
883 struct goku_ep *ep;
889 ep = container_of (_ep, struct goku_ep, ep);
891 if (ep->num == 0) {
893 ep->dev->ep0state = EP0_STALL;
894 ep->dev->ep[0].stopped = 1;
899 } else if (!ep->ep.desc) {
900 DBG(ep->dev, "%s %s inactive?\n", __func__, ep->ep.name);
904 spin_lock_irqsave(&ep->dev->lock, flags);
905 if (!list_empty(&ep->queue))
907 else if (ep->is_in && value
909 && (readl(&ep->dev->regs->DataSet)
910 & DATASET_AB(ep->num)))
913 goku_clear_halt(ep);
915 ep->stopped = 1;
916 VDBG(ep->dev, "%s set halt\n", ep->ep.name);
917 command(ep->dev->regs, COMMAND_STALL, ep->num);
918 readl(ep->reg_status);
920 spin_unlock_irqrestore(&ep->dev->lock, flags);
926 struct goku_ep *ep;
932 ep = container_of(_ep, struct goku_ep, ep);
935 if (ep->is_in)
939 regs = ep->dev->regs;
940 size = readl(®s->EPxSizeLA[ep->num]) & DATASIZE;
941 size += readl(®s->EPxSizeLB[ep->num]) & DATASIZE;
942 VDBG(ep->dev, "%s %s %u\n", __func__, ep->ep.name, size);
948 struct goku_ep *ep;
954 ep = container_of(_ep, struct goku_ep, ep);
955 VDBG(ep->dev, "%s %s\n", __func__, ep->ep.name);
958 if (!ep->ep.desc && ep->num != 0) {
959 DBG(ep->dev, "%s %s inactive?\n", __func__, ep->ep.name);
963 regs = ep->dev->regs;
964 size = readl(®s->EPxSizeLA[ep->num]);
969 * the bytes out (PIO, if !ep->dma); for in, no choice.
972 command(regs, COMMAND_FIFO_CLEAR, ep->num);
1002 struct usb_ep *ep;
1007 ep = &dev->ep[3].ep;
1008 if (usb_gadget_ep_match_desc(g, ep, desc, ep_comp))
1009 return ep;
1014 ep = &dev->ep[2].ep;
1015 if (usb_gadget_ep_match_desc(g, ep, desc, ep_comp))
1016 return ep;
1197 struct goku_ep *ep = &dev->ep [i];
1200 if (i && !ep->ep.desc)
1203 tmp = readl(ep->reg_status);
1205 ep->ep.name,
1206 ep->is_in ? "in" : "out",
1207 ep->ep.maxpacket,
1208 ep->dma ? "dma" : "pio",
1209 ep->irqs,
1218 if (list_empty(&ep->queue)) {
1224 list_for_each_entry(req, &ep->queue, queue) {
1225 if (ep->dma && req->queue.prev == &ep->queue) {
1258 dev->gadget.ep0 = &dev->ep [0].ep;
1264 struct goku_ep *ep = &dev->ep[i];
1266 ep->num = i;
1267 ep->ep.name = names[i];
1268 ep->reg_fifo = &dev->regs->ep_fifo [i];
1269 ep->reg_status = &dev->regs->ep_status [i];
1270 ep->reg_mode = &dev->regs->ep_mode[i];
1272 ep->ep.ops = &goku_ep_ops;
1273 list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
1274 ep->dev = dev;
1275 INIT_LIST_HEAD (&ep->queue);
1277 ep_reset(NULL, ep);
1280 ep->ep.caps.type_control = true;
1282 ep->ep.caps.type_bulk = true;
1284 ep->ep.caps.dir_in = true;
1285 ep->ep.caps.dir_out = true;
1288 dev->ep[0].reg_mode = NULL;
1289 usb_ep_set_maxpacket_limit(&dev->ep[0].ep, MAX_EP0_SIZE);
1290 list_del_init (&dev->ep[0].ep.ep_list);
1329 dev->ep[i].irqs = 0;
1397 nuke(&dev->ep [i], -ESHUTDOWN);
1435 nuke(&dev->ep[0], 0);
1436 dev->ep[0].stopped = 0;
1438 dev->ep[0].is_in = 1;
1443 dev->ep[0].is_in = 0;
1457 (!dev->ep[tmp].ep.desc && tmp != 0))
1461 if (!dev->ep[tmp].is_in)
1464 if (dev->ep[tmp].is_in)
1471 goku_clear_halt(&dev->ep[tmp]);
1475 dev->ep[0].stopped = 1;
1521 dev->ep[0].stopped = 1;
1538 struct goku_ep *ep;
1628 dev->ep[0].irqs++;
1634 ep = &dev->ep[0];
1635 ep->irqs++;
1636 nuke(ep, 0);
1643 ep = &dev->ep[0];
1644 ep->irqs++;
1645 pio_advance(ep);
1651 ep = &dev->ep[UDC_MSTRD_ENDPOINT];
1652 ep->irqs++;
1653 dma_advance(dev, ep);
1657 ep = &dev->ep[UDC_MSTWR_ENDPOINT];
1658 ep->irqs++;
1659 dma_advance(dev, ep);
1663 ep = &dev->ep[UDC_MSTWR_ENDPOINT];
1664 ep->irqs++;
1665 ERROR(dev, "%s write timeout ?\n", ep->ep.name);
1675 ep = &dev->ep[i];
1676 pio_advance(ep);
1677 if (list_empty (&ep->queue))
1681 ep->irqs++;