Lines Matching refs:request
32 static inline void map_dma_buffer(struct musb_request *request,
38 request->map_state = UN_MAPPED;
43 /* Check if DMA engine can handle this request.
44 * DMA code must reject the USB request explicitly.
45 * Default behaviour is to map the request.
49 musb_ep->packet_sz, request->request.buf,
50 request->request.length);
54 if (request->request.dma == DMA_ADDR_INVALID) {
60 request->request.buf,
61 request->request.length,
62 request->tx
69 request->request.dma = dma_addr;
70 request->map_state = MUSB_MAPPED;
73 request->request.dma,
74 request->request.length,
75 request->tx
78 request->map_state = PRE_MAPPED;
83 static inline void unmap_dma_buffer(struct musb_request *request,
86 struct musb_ep *musb_ep = request->ep;
88 if (!is_buffer_mapped(request) || !musb_ep->dma)
91 if (request->request.dma == DMA_ADDR_INVALID) {
96 if (request->map_state == MUSB_MAPPED) {
98 request->request.dma,
99 request->request.length,
100 request->tx
103 request->request.dma = DMA_ADDR_INVALID;
106 request->request.dma,
107 request->request.length,
108 request->tx
112 request->map_state = UN_MAPPED;
116 * Immediately complete a request.
118 * @param request the request to complete
119 * @param status the status to complete the request with
124 struct usb_request *request,
133 req = to_musb_request(request);
136 if (req->request.status == -EINPROGRESS)
137 req->request.status = status;
143 if (!dma_mapping_error(&musb->g.dev, request->dma))
147 usb_gadget_giveback_request(&req->ep->end_point, &req->request);
195 musb_g_giveback(ep, &req->request, status);
218 * the IRQ routine or from ep.queue() to kickstart a request on an
228 struct usb_request *request;
236 musb_dbg(musb, "ep:%s disabled - ignore request",
250 request = &req->request;
252 (int)(request->length - request->actual));
276 request_size = min_t(size_t, request->length - request->actual,
279 use_dma = (request->dma != DMA_ADDR_INVALID && request_size);
292 request->dma + request->actual, request_size);
360 request->dma + request->actual,
372 request->zero,
373 request->dma + request->actual,
386 (u8 *) (request->buf + request->actual));
387 request->actual += fifo_count;
396 request->actual, request->length,
410 struct usb_request *request;
418 request = &req->request;
442 epnum, request);
454 if (request) {
465 request->actual += musb_ep->dma->actual_len;
467 epnum, csr, musb_ep->dma->actual_len, request);
474 if ((request->zero && request->length)
475 && (request->length % musb_ep->packet_sz == 0)
476 && (request->actual == request->length)) {
487 request->zero = 0;
490 if (request->actual == request->length) {
491 musb_g_giveback(musb_ep, request, 0);
521 struct usb_request *request = &req->request;
539 musb_dbg(musb, "ep:%s disabled - ignore request",
567 !request->short_not_ok,
568 request->dma + request->actual,
569 request->length - request->actual)) {
592 if (request->short_not_ok && fifo_count == musb_ep->packet_sz)
597 if (request->actual < request->length) {
615 * in advance. For mass storage class, request->length = what the host
617 * request->length is routinely more than what the host sends. For
648 request->length -
649 request->actual,
659 transfer_size = min(request->length - request->actual,
668 request->dma
669 + request->actual,
677 (request->actual < request->length)) {
689 else if (request->short_not_ok)
691 request->length -
692 request->actual,
696 request->length -
697 request->actual,
718 request->dma
719 + request->actual,
725 len = request->length - request->actual;
736 u32 dma_addr = request->dma + request->actual;
764 request->length - request->actual,
767 (request->buf + request->actual));
768 request->actual += fifo_count;
782 if (request->actual == request->length ||
784 musb_g_giveback(musb_ep, request, 0);
788 * Data ready for a request; called from IRQ
794 struct usb_request *request;
813 request = &req->request;
819 csr, dma ? " (dma)" : "", request);
833 musb_dbg(musb, "%s iso overrun on %p", musb_ep->name, request);
834 if (request->status == -EINPROGRESS)
835 request->status = -EOVERFLOW;
856 request->actual += musb_ep->dma->actual_len;
870 if ((request->actual < request->length)
883 musb_g_giveback(musb_ep, request, 0);
902 /* Analyze request */
1127 * Allocate a request for an endpoint.
1133 struct musb_request *request = NULL;
1135 request = kzalloc(sizeof *request, gfp_flags);
1136 if (!request)
1139 request->request.dma = DMA_ADDR_INVALID;
1140 request->epnum = musb_ep->current_epnum;
1141 request->ep = musb_ep;
1143 trace_musb_req_alloc(request);
1144 return &request->request;
1148 * Free a request
1153 struct musb_request *request = to_musb_request(req);
1155 trace_musb_req_free(request);
1156 kfree(request);
1194 struct musb_request *request;
1207 request = to_musb_request(req);
1208 request->musb = musb;
1210 if (request->ep != musb_ep)
1224 trace_musb_req_enq(request);
1226 /* request is mine now... */
1227 request->request.actual = 0;
1228 request->request.status = -EINPROGRESS;
1229 request->epnum = musb_ep->current_epnum;
1230 request->tx = musb_ep->is_in;
1232 map_dma_buffer(request, musb, musb_ep);
1241 unmap_dma_buffer(request, musb);
1245 /* add request to the list */
1246 list_add_tail(&request->list, &musb_ep->req_list);
1249 if (!musb_ep->busy && &request->list == musb_ep->req_list.next) {
1252 request);
1256 list_del(&request->list);
1268 static int musb_gadget_dequeue(struct usb_ep *ep, struct usb_request *request)
1271 struct musb_request *req = to_musb_request(request);
1277 if (!ep || !request || req->ep != musb_ep)
1289 dev_err(musb->controller, "request %p not queued to %s\n",
1290 request, ep->name);
1295 /* if the hardware doesn't have the request, easy ... */
1297 musb_g_giveback(musb_ep, request, -ECONNRESET);
1309 musb_g_giveback(musb_ep, request, -ECONNRESET);
1314 musb_g_giveback(musb_ep, request, -ECONNRESET);
1337 struct musb_request *request;
1353 request = next_request(musb_ep);
1355 if (request) {
1356 musb_dbg(musb, "request in progress, cannot halt %s",
1400 /* maybe start the first request in the queue */
1401 if (!musb_ep->busy && !value && request) {
1402 musb_dbg(musb, "restarting the request");
1403 musb_ep_restart(musb, request);