Lines Matching defs:musb_ep
62 struct musb_ep *ep,
119 static void nuke(struct musb_ep *ep, const int status)
169 static inline int max_ep_writesize(struct musb *musb, struct musb_ep *ep)
222 struct musb_ep *musb_ep;
228 musb_ep = req->ep;
231 if (dma_channel_status(musb_ep->dma) == MUSB_DMA_STATUS_BUSY) {
240 fifo_count = min(max_ep_writesize(musb, musb_ep),
245 musb_ep->end_point.name, csr);
251 musb_ep->end_point.name, csr);
256 epnum, musb_ep->packet_sz, fifo_count,
260 if (is_dma_capable() && musb_ep->dma) {
266 musb_ep->dma->max_len);
274 if (request_size < musb_ep->packet_sz)
275 musb_ep->dma->desired_mode = 0;
277 musb_ep->dma->desired_mode = 1;
280 musb_ep->dma, musb_ep->packet_sz,
281 musb_ep->dma->desired_mode,
284 if (musb_ep->dma->desired_mode == 0) {
333 musb_ep->dma, musb_ep->packet_sz,
338 c->channel_release(musb_ep->dma);
339 musb_ep->dma = NULL;
346 musb_ep->dma, musb_ep->packet_sz,
355 musb_write_fifo(musb_ep->hw_ep, fifo_count,
365 musb_ep->end_point.name, use_dma ? "dma" : "pio",
381 struct musb_ep *musb_ep = &musb->endpoints[epnum].ep_in;
386 request = next_request(musb_ep);
389 DBG(4, "<== %s, txcsr %04x\n", musb_ep->end_point.name, csr);
391 dma = is_dma_capable() ? musb_ep->dma : NULL;
417 DBG(5, "%s dma still busy?\n", musb_ep->end_point.name);
432 request->actual += musb_ep->dma->actual_len;
434 epnum, csr, musb_ep->dma->actual_len, request);
443 && request->length % musb_ep->packet_sz == 0)
447 (musb_ep->packet_sz - 1))))
464 musb_g_giveback(musb_ep, request, 0);
465 request = musb_ep->desc ? next_request(musb_ep) : NULL;
468 musb_ep->end_point.name);
518 struct musb_ep *musb_ep;
526 musb_ep = &hw_ep->ep_in;
528 musb_ep = &hw_ep->ep_out;
530 len = musb_ep->packet_sz;
533 if (dma_channel_status(musb_ep->dma) == MUSB_DMA_STATUS_BUSY) {
540 musb_ep->end_point.name, csr);
544 if (is_cppi_enabled() && musb_ep->dma) {
546 struct dma_channel *channel = musb_ep->dma;
554 musb_ep->packet_sz,
575 if (is_dma_capable() && musb_ep->dma) {
581 channel = musb_ep->dma;
627 if (transfer_size <= musb_ep->packet_sz)
628 musb_ep->dma->desired_mode = 0;
630 musb_ep->dma->desired_mode = 1;
634 musb_ep->packet_sz,
648 musb_ep->end_point.name,
650 musb_ep->packet_sz);
655 if (tusb_dma_omap() && musb_ep->dma) {
657 struct dma_channel *channel = musb_ep->dma;
662 musb_ep->packet_sz,
671 musb_read_fifo(musb_ep->hw_ep, fifo_count, (u8 *)
687 if (request->actual == request->length || len < musb_ep->packet_sz)
688 musb_g_giveback(musb_ep, request, 0);
699 struct musb_ep *musb_ep;
705 musb_ep = &hw_ep->ep_in;
707 musb_ep = &hw_ep->ep_out;
711 request = next_request(musb_ep);
716 dma = is_dma_capable() ? musb_ep->dma : NULL;
718 DBG(4, "<== %s, rxcsr %04x%s %p\n", musb_ep->end_point.name,
733 DBG(3, "%s iso overrun on %p\n", musb_ep->name, request);
739 DBG(4, "%s, incomprx\n", musb_ep->end_point.name);
746 musb_ep->end_point.name, csr);
757 request->actual += musb_ep->dma->actual_len;
762 musb_ep->dma->actual_len, request);
768 & (musb_ep->packet_sz - 1))) {
776 && (musb_ep->dma->actual_len
777 == musb_ep->packet_sz))
780 musb_g_giveback(musb_ep, request, 0);
782 request = next_request(musb_ep);
792 musb_ep->desc ? "" : "inactive ",
793 musb_ep->end_point.name);
803 struct musb_ep *musb_ep;
816 musb_ep = to_musb_ep(ep);
817 hw_ep = musb_ep->hw_ep;
819 musb = musb_ep->musb;
821 epnum = musb_ep->current_epnum;
825 if (musb_ep->desc) {
829 musb_ep->type = usb_endpoint_type(desc);
839 musb_ep->packet_sz = tmp;
849 musb_ep->is_in = 1;
850 if (!musb_ep->is_in)
874 if (musb_ep->type == USB_ENDPOINT_XFER_ISOC)
886 musb_ep->is_in = 0;
887 if (musb_ep->is_in)
914 if (musb_ep->type == USB_ENDPOINT_XFER_ISOC)
916 else if (musb_ep->type == USB_ENDPOINT_XFER_INT)
930 musb_ep->dma = c->channel_alloc(c, hw_ep,
933 musb_ep->dma = NULL;
935 musb_ep->desc = desc;
936 musb_ep->busy = 0;
937 musb_ep->wedged = 0;
941 musb_driver_name, musb_ep->end_point.name,
942 ({ char *s; switch (musb_ep->type) {
947 musb_ep->is_in ? "IN" : "OUT",
948 musb_ep->dma ? "dma, " : "",
949 musb_ep->packet_sz);
966 struct musb_ep *musb_ep;
970 musb_ep = to_musb_ep(ep);
971 musb = musb_ep->musb;
972 epnum = musb_ep->current_epnum;
979 if (musb_ep->is_in) {
991 musb_ep->desc = NULL;
994 nuke(musb_ep, -ESHUTDOWN);
1000 DBG(2, "%s\n", musb_ep->end_point.name);
1011 struct musb_ep *musb_ep = to_musb_ep(ep);
1018 request->epnum = musb_ep->current_epnum;
1019 request->ep = musb_ep;
1062 struct musb_ep *musb_ep;
1073 musb_ep = to_musb_ep(ep);
1074 musb = musb_ep->musb;
1079 if (request->ep != musb_ep)
1087 request->epnum = musb_ep->current_epnum;
1088 request->tx = musb_ep->is_in;
1090 if (is_dma_capable() && musb_ep->dma) {
1117 if (!musb_ep->desc) {
1125 list_add_tail(&(request->request.list), &(musb_ep->req_list));
1128 if (!musb_ep->busy && &request->request.list == musb_ep->req_list.next)
1138 struct musb_ep *musb_ep = to_musb_ep(ep);
1142 struct musb *musb = musb_ep->musb;
1144 if (!ep || !request || to_musb_request(request)->ep != musb_ep)
1149 list_for_each_entry(r, &musb_ep->req_list, list) {
1160 if (musb_ep->req_list.next != &request->list || musb_ep->busy)
1161 musb_g_giveback(musb_ep, request, -ECONNRESET);
1164 else if (is_dma_capable() && musb_ep->dma) {
1167 musb_ep_select(musb->mregs, musb_ep->current_epnum);
1169 status = c->channel_abort(musb_ep->dma);
1173 musb_g_giveback(musb_ep, request, -ECONNRESET);
1178 musb_g_giveback(musb_ep, request, -ECONNRESET);
1194 struct musb_ep *musb_ep = to_musb_ep(ep);
1195 u8 epnum = musb_ep->current_epnum;
1196 struct musb *musb = musb_ep->musb;
1210 if ((USB_ENDPOINT_XFER_ISOC == musb_ep->type)) {
1217 request = to_musb_request(next_request(musb_ep));
1226 if (musb_ep->is_in) {
1235 musb_ep->wedged = 0;
1239 if (musb_ep->is_in) {
1264 if (!musb_ep->busy && !value && request) {
1279 struct musb_ep *musb_ep = to_musb_ep(ep);
1284 musb_ep->wedged = 1;
1291 struct musb_ep *musb_ep = to_musb_ep(ep);
1292 void __iomem *epio = musb_ep->hw_ep->regs;
1295 if (musb_ep->desc && !musb_ep->is_in) {
1296 struct musb *musb = musb_ep->musb;
1297 int epnum = musb_ep->current_epnum;
1313 struct musb_ep *musb_ep = to_musb_ep(ep);
1314 struct musb *musb = musb_ep->musb;
1315 u8 epnum = musb_ep->current_epnum;
1330 if (musb_ep->is_in) {
1521 init_peripheral_ep(struct musb *musb, struct musb_ep *ep, u8 epnum, int is_in)