?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 6.13-rc6
[linux.git] / drivers / usb / dwc2 / hcd_ddma.c
blob994a78ad084b1c485673ca3c88819d4e752ef2ee
1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
2 /*
3 * hcd_ddma.c - DesignWare HS OTG Controller descriptor DMA routines
4 *
5 * Copyright (C) 2004-2013 Synopsys, Inc.
6 */
7
8 /*
9 * This file contains the Descriptor DMA implementation for Host mode
10 */
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/spinlock.h>
14 #include <linux/interrupt.h>
15 #include <linux/dma-mapping.h>
16 #include <linux/io.h>
17 #include <linux/slab.h>
18 #include <linux/usb.h>
19
20 #include <linux/usb/hcd.h>
21 #include <linux/usb/ch11.h>
22
23 #include "core.h"
24 #include "hcd.h"
25
26 static u16 dwc2_frame_list_idx(u16 frame)
27 {
28 return frame & (FRLISTEN_64_SIZE - 1);
29 }
30
31 static u16 dwc2_desclist_idx_inc(u16 idx, u16 inc, u8 speed)
32 {
33 return (idx + inc) &
34 ((speed == USB_SPEED_HIGH ? MAX_DMA_DESC_NUM_HS_ISOC :
35 MAX_DMA_DESC_NUM_GENERIC) - 1);
36 }
37
38 static u16 dwc2_desclist_idx_dec(u16 idx, u16 inc, u8 speed)
39 {
40 return (idx - inc) &
41 ((speed == USB_SPEED_HIGH ? MAX_DMA_DESC_NUM_HS_ISOC :
42 MAX_DMA_DESC_NUM_GENERIC) - 1);
43 }
44
45 static u16 dwc2_max_desc_num(struct dwc2_qh *qh)
46 {
47 return (qh->ep_type == USB_ENDPOINT_XFER_ISOC &&
48 qh->dev_speed == USB_SPEED_HIGH) ?
49 MAX_DMA_DESC_NUM_HS_ISOC : MAX_DMA_DESC_NUM_GENERIC;
50 }
51
52 static u16 dwc2_frame_incr_val(struct dwc2_qh *qh)
53 {
54 return qh->dev_speed == USB_SPEED_HIGH ?
55 (qh->host_interval + 8 - 1) / 8 : qh->host_interval;
56 }
57
58 static int dwc2_desc_list_alloc(struct dwc2_hsotg *hsotg, struct dwc2_qh *qh,
59 gfp_t flags)
60 {
61 struct kmem_cache *desc_cache;
62
63 if (qh->ep_type == USB_ENDPOINT_XFER_ISOC &&
64 qh->dev_speed == USB_SPEED_HIGH)
65 desc_cache = hsotg->desc_hsisoc_cache;
66 else
67 desc_cache = hsotg->desc_gen_cache;
68
69 qh->desc_list_sz = sizeof(struct dwc2_dma_desc) *
70 dwc2_max_desc_num(qh);
71
72 qh->desc_list = kmem_cache_zalloc(desc_cache, flags | GFP_DMA);
73 if (!qh->desc_list)
74 return -ENOMEM;
75
76 qh->desc_list_dma = dma_map_single(hsotg->dev, qh->desc_list,
77 qh->desc_list_sz,
78 DMA_TO_DEVICE);
79
80 qh->n_bytes = kcalloc(dwc2_max_desc_num(qh), sizeof(u32), flags);
81 if (!qh->n_bytes) {
82 dma_unmap_single(hsotg->dev, qh->desc_list_dma,
83 qh->desc_list_sz,
84 DMA_FROM_DEVICE);
85 kmem_cache_free(desc_cache, qh->desc_list);
86 qh->desc_list = NULL;
87 return -ENOMEM;
88 }
89
90 return 0;
91 }
92
93 static void dwc2_desc_list_free(struct dwc2_hsotg *hsotg, struct dwc2_qh *qh)
94 {
95 struct kmem_cache *desc_cache;
96
97 if (qh->ep_type == USB_ENDPOINT_XFER_ISOC &&
98 qh->dev_speed == USB_SPEED_HIGH)
99 desc_cache = hsotg->desc_hsisoc_cache;
100 else
101 desc_cache = hsotg->desc_gen_cache;
102
103 if (qh->desc_list) {
104 dma_unmap_single(hsotg->dev, qh->desc_list_dma,
105 qh->desc_list_sz, DMA_FROM_DEVICE);
106 kmem_cache_free(desc_cache, qh->desc_list);
107 qh->desc_list = NULL;
108 }
109
110 kfree(qh->n_bytes);
111 qh->n_bytes = NULL;
112 }
113
114 static int dwc2_frame_list_alloc(struct dwc2_hsotg *hsotg, gfp_t mem_flags)
115 {
116 if (hsotg->frame_list)
117 return 0;
118
119 hsotg->frame_list_sz = 4 * FRLISTEN_64_SIZE;
120 hsotg->frame_list = kzalloc(hsotg->frame_list_sz, GFP_ATOMIC | GFP_DMA);
121 if (!hsotg->frame_list)
122 return -ENOMEM;
123
124 hsotg->frame_list_dma = dma_map_single(hsotg->dev, hsotg->frame_list,
125 hsotg->frame_list_sz,
126 DMA_TO_DEVICE);
127
128 return 0;
129 }
130
131 static void dwc2_frame_list_free(struct dwc2_hsotg *hsotg)
132 {
133 unsigned long flags;
134
135 spin_lock_irqsave(&hsotg->lock, flags);
136
137 if (!hsotg->frame_list) {
138 spin_unlock_irqrestore(&hsotg->lock, flags);
139 return;
140 }
141
142 dma_unmap_single(hsotg->dev, hsotg->frame_list_dma,
143 hsotg->frame_list_sz, DMA_FROM_DEVICE);
144
145 kfree(hsotg->frame_list);
146 hsotg->frame_list = NULL;
147
148 spin_unlock_irqrestore(&hsotg->lock, flags);
149 }
150
151 static void dwc2_per_sched_enable(struct dwc2_hsotg *hsotg, u32 fr_list_en)
152 {
153 u32 hcfg;
154 unsigned long flags;
155
156 spin_lock_irqsave(&hsotg->lock, flags);
157
158 hcfg = dwc2_readl(hsotg, HCFG);
159 if (hcfg & HCFG_PERSCHEDENA) {
160 /* already enabled */
161 spin_unlock_irqrestore(&hsotg->lock, flags);
162 return;
163 }
164
165 dwc2_writel(hsotg, hsotg->frame_list_dma, HFLBADDR);
166
167 hcfg &= ~HCFG_FRLISTEN_MASK;
168 hcfg |= fr_list_en | HCFG_PERSCHEDENA;
169 dev_vdbg(hsotg->dev, "Enabling Periodic schedule\n");
170 dwc2_writel(hsotg, hcfg, HCFG);
171
172 spin_unlock_irqrestore(&hsotg->lock, flags);
173 }
174
175 static void dwc2_per_sched_disable(struct dwc2_hsotg *hsotg)
176 {
177 u32 hcfg;
178 unsigned long flags;
179
180 spin_lock_irqsave(&hsotg->lock, flags);
181
182 hcfg = dwc2_readl(hsotg, HCFG);
183 if (!(hcfg & HCFG_PERSCHEDENA)) {
184 /* already disabled */
185 spin_unlock_irqrestore(&hsotg->lock, flags);
186 return;
187 }
188
189 hcfg &= ~HCFG_PERSCHEDENA;
190 dev_vdbg(hsotg->dev, "Disabling Periodic schedule\n");
191 dwc2_writel(hsotg, hcfg, HCFG);
192
193 spin_unlock_irqrestore(&hsotg->lock, flags);
194 }
195
196 /*
197 * Activates/Deactivates FrameList entries for the channel based on endpoint
198 * servicing period
199 */
200 static void dwc2_update_frame_list(struct dwc2_hsotg *hsotg, struct dwc2_qh *qh,
201 int enable)
202 {
203 struct dwc2_host_chan *chan;
204 u16 i, j, inc;
205
206 if (!hsotg) {
207 pr_err("hsotg = %p\n", hsotg);
208 return;
209 }
210
211 if (!qh->channel) {
212 dev_err(hsotg->dev, "qh->channel = %p\n", qh->channel);
213 return;
214 }
215
216 if (!hsotg->frame_list) {
217 dev_err(hsotg->dev, "hsotg->frame_list = %p\n",
218 hsotg->frame_list);
219 return;
220 }
221
222 chan = qh->channel;
223 inc = dwc2_frame_incr_val(qh);
224 if (qh->ep_type == USB_ENDPOINT_XFER_ISOC)
225 i = dwc2_frame_list_idx(qh->next_active_frame);
226 else
227 i = 0;
228
229 j = i;
230 do {
231 if (enable)
232 hsotg->frame_list[j] |= 1 << chan->hc_num;
233 else
234 hsotg->frame_list[j] &= ~(1 << chan->hc_num);
235 j = (j + inc) & (FRLISTEN_64_SIZE - 1);
236 } while (j != i);
237
238 /*
239 * Sync frame list since controller will access it if periodic
240 * channel is currently enabled.
241 */
242 dma_sync_single_for_device(hsotg->dev,
243 hsotg->frame_list_dma,
244 hsotg->frame_list_sz,
245 DMA_TO_DEVICE);
246
247 if (!enable)
248 return;
249
250 chan->schinfo = 0;
251 if (chan->speed == USB_SPEED_HIGH && qh->host_interval) {
252 j = 1;
253 /* TODO - check this */
254 inc = (8 + qh->host_interval - 1) / qh->host_interval;
255 for (i = 0; i < inc; i++) {
256 chan->schinfo |= j;
257 j = j << qh->host_interval;
258 }
259 } else {
260 chan->schinfo = 0xff;
261 }
262 }
263
264 static void dwc2_release_channel_ddma(struct dwc2_hsotg *hsotg,
265 struct dwc2_qh *qh)
266 {
267 struct dwc2_host_chan *chan = qh->channel;
268
269 if (dwc2_qh_is_non_per(qh)) {
270 if (hsotg->params.uframe_sched)
271 hsotg->available_host_channels++;
272 else
273 hsotg->non_periodic_channels--;
274 } else {
275 dwc2_update_frame_list(hsotg, qh, 0);
276 hsotg->available_host_channels++;
277 }
278
279 /*
280 * The condition is added to prevent double cleanup try in case of
281 * device disconnect. See channel cleanup in dwc2_hcd_disconnect().
282 */
283 if (chan->qh) {
284 if (!list_empty(&chan->hc_list_entry))
285 list_del(&chan->hc_list_entry);
286 dwc2_hc_cleanup(hsotg, chan);
287 list_add_tail(&chan->hc_list_entry, &hsotg->free_hc_list);
288 chan->qh = NULL;
289 }
290
291 qh->channel = NULL;
292 qh->ntd = 0;
293
294 if (qh->desc_list)
295 memset(qh->desc_list, 0, sizeof(struct dwc2_dma_desc) *
296 dwc2_max_desc_num(qh));
297 }
298
299 /**
300 * dwc2_hcd_qh_init_ddma() - Initializes a QH structure's Descriptor DMA
301 * related members
302 *
303 * @hsotg: The HCD state structure for the DWC OTG controller
304 * @qh: The QH to init
305 * @mem_flags: Indicates the type of memory allocation
306 *
307 * Return: 0 if successful, negative error code otherwise
308 *
309 * Allocates memory for the descriptor list. For the first periodic QH,
310 * allocates memory for the FrameList and enables periodic scheduling.
311 */
312 int dwc2_hcd_qh_init_ddma(struct dwc2_hsotg *hsotg, struct dwc2_qh *qh,
313 gfp_t mem_flags)
314 {
315 int retval;
316
317 if (qh->do_split) {
318 dev_err(hsotg->dev,
319 "SPLIT Transfers are not supported in Descriptor DMA mode.\n");
320 retval = -EINVAL;
321 goto err0;
322 }
323
324 retval = dwc2_desc_list_alloc(hsotg, qh, mem_flags);
325 if (retval)
326 goto err0;
327
328 if (qh->ep_type == USB_ENDPOINT_XFER_ISOC ||
329 qh->ep_type == USB_ENDPOINT_XFER_INT) {
330 if (!hsotg->frame_list) {
331 retval = dwc2_frame_list_alloc(hsotg, mem_flags);
332 if (retval)
333 goto err1;
334 /* Enable periodic schedule on first periodic QH */
335 dwc2_per_sched_enable(hsotg, HCFG_FRLISTEN_64);
336 }
337 }
338
339 qh->ntd = 0;
340 return 0;
341
342 err1:
343 dwc2_desc_list_free(hsotg, qh);
344 err0:
345 return retval;
346 }
347
348 /**
349 * dwc2_hcd_qh_free_ddma() - Frees a QH structure's Descriptor DMA related
350 * members
351 *
352 * @hsotg: The HCD state structure for the DWC OTG controller
353 * @qh: The QH to free
354 *
355 * Frees descriptor list memory associated with the QH. If QH is periodic and
356 * the last, frees FrameList memory and disables periodic scheduling.
357 */
358 void dwc2_hcd_qh_free_ddma(struct dwc2_hsotg *hsotg, struct dwc2_qh *qh)
359 {
360 unsigned long flags;
361
362 dwc2_desc_list_free(hsotg, qh);
363
364 /*
365 * Channel still assigned due to some reasons.
366 * Seen on Isoc URB dequeue. Channel halted but no subsequent
367 * ChHalted interrupt to release the channel. Afterwards
368 * when it comes here from endpoint disable routine
369 * channel remains assigned.
370 */
371 spin_lock_irqsave(&hsotg->lock, flags);
372 if (qh->channel)
373 dwc2_release_channel_ddma(hsotg, qh);
374 spin_unlock_irqrestore(&hsotg->lock, flags);
375
376 if ((qh->ep_type == USB_ENDPOINT_XFER_ISOC ||
377 qh->ep_type == USB_ENDPOINT_XFER_INT) &&
378 (hsotg->params.uframe_sched ||
379 !hsotg->periodic_channels) && hsotg->frame_list) {
380 dwc2_per_sched_disable(hsotg);
381 dwc2_frame_list_free(hsotg);
382 }
383 }
384
385 static u8 dwc2_frame_to_desc_idx(struct dwc2_qh *qh, u16 frame_idx)
386 {
387 if (qh->dev_speed == USB_SPEED_HIGH)
388 /* Descriptor set (8 descriptors) index which is 8-aligned */
389 return (frame_idx & ((MAX_DMA_DESC_NUM_HS_ISOC / 8) - 1)) * 8;
390 else
391 return frame_idx & (MAX_DMA_DESC_NUM_GENERIC - 1);
392 }
393
394 /*
395 * Determine starting frame for Isochronous transfer.
396 * Few frames skipped to prevent race condition with HC.
397 */
398 static u16 dwc2_calc_starting_frame(struct dwc2_hsotg *hsotg,
399 struct dwc2_qh *qh, u16 *skip_frames)
400 {
401 u16 frame;
402
403 hsotg->frame_number = dwc2_hcd_get_frame_number(hsotg);
404
405 /*
406 * next_active_frame is always frame number (not uFrame) both in FS
407 * and HS!
408 */
409
410 /*
411 * skip_frames is used to limit activated descriptors number
412 * to avoid the situation when HC services the last activated
413 * descriptor firstly.
414 * Example for FS:
415 * Current frame is 1, scheduled frame is 3. Since HC always fetches
416 * the descriptor corresponding to curr_frame+1, the descriptor
417 * corresponding to frame 2 will be fetched. If the number of
418 * descriptors is max=64 (or greather) the list will be fully programmed
419 * with Active descriptors and it is possible case (rare) that the
420 * latest descriptor(considering rollback) corresponding to frame 2 will
421 * be serviced first. HS case is more probable because, in fact, up to
422 * 11 uframes (16 in the code) may be skipped.
423 */
424 if (qh->dev_speed == USB_SPEED_HIGH) {
425 /*
426 * Consider uframe counter also, to start xfer asap. If half of
427 * the frame elapsed skip 2 frames otherwise just 1 frame.
428 * Starting descriptor index must be 8-aligned, so if the
429 * current frame is near to complete the next one is skipped as
430 * well.
431 */
432 if (dwc2_micro_frame_num(hsotg->frame_number) >= 5) {
433 *skip_frames = 2 * 8;
434 frame = dwc2_frame_num_inc(hsotg->frame_number,
435 *skip_frames);
436 } else {
437 *skip_frames = 1 * 8;
438 frame = dwc2_frame_num_inc(hsotg->frame_number,
439 *skip_frames);
440 }
441
442 frame = dwc2_full_frame_num(frame);
443 } else {
444 /*
445 * Two frames are skipped for FS - the current and the next.
446 * But for descriptor programming, 1 frame (descriptor) is
447 * enough, see example above.
448 */
449 *skip_frames = 1;
450 frame = dwc2_frame_num_inc(hsotg->frame_number, 2);
451 }
452
453 return frame;
454 }
455
456 /*
457 * Calculate initial descriptor index for isochronous transfer based on
458 * scheduled frame
459 */
460 static u16 dwc2_recalc_initial_desc_idx(struct dwc2_hsotg *hsotg,
461 struct dwc2_qh *qh)
462 {
463 u16 frame, fr_idx, fr_idx_tmp, skip_frames;
464
465 /*
466 * With current ISOC processing algorithm the channel is being released
467 * when no more QTDs in the list (qh->ntd == 0). Thus this function is
468 * called only when qh->ntd == 0 and qh->channel == 0.
469 *
470 * So qh->channel != NULL branch is not used and just not removed from
471 * the source file. It is required for another possible approach which
472 * is, do not disable and release the channel when ISOC session
473 * completed, just move QH to inactive schedule until new QTD arrives.
474 * On new QTD, the QH moved back to 'ready' schedule, starting frame and
475 * therefore starting desc_index are recalculated. In this case channel
476 * is released only on ep_disable.
477 */
478
479 /*
480 * Calculate starting descriptor index. For INTERRUPT endpoint it is
481 * always 0.
482 */
483 if (qh->channel) {
484 frame = dwc2_calc_starting_frame(hsotg, qh, &skip_frames);
485 /*
486 * Calculate initial descriptor index based on FrameList current
487 * bitmap and servicing period
488 */
489 fr_idx_tmp = dwc2_frame_list_idx(frame);
490 fr_idx = (FRLISTEN_64_SIZE +
491 dwc2_frame_list_idx(qh->next_active_frame) -
492 fr_idx_tmp) % dwc2_frame_incr_val(qh);
493 fr_idx = (fr_idx + fr_idx_tmp) % FRLISTEN_64_SIZE;
494 } else {
495 qh->next_active_frame = dwc2_calc_starting_frame(hsotg, qh,
496 &skip_frames);
497 fr_idx = dwc2_frame_list_idx(qh->next_active_frame);
498 }
499
500 qh->td_first = qh->td_last = dwc2_frame_to_desc_idx(qh, fr_idx);
501
502 return skip_frames;
503 }
504
505 #define ISOC_URB_GIVEBACK_ASAP
506
507 #define MAX_ISOC_XFER_SIZE_FS 1023
508 #define MAX_ISOC_XFER_SIZE_HS 3072
509 #define DESCNUM_THRESHOLD 4
510
511 static void dwc2_fill_host_isoc_dma_desc(struct dwc2_hsotg *hsotg,
512 struct dwc2_qtd *qtd,
513 struct dwc2_qh *qh, u32 max_xfer_size,
514 u16 idx)
515 {
516 struct dwc2_dma_desc *dma_desc = &qh->desc_list[idx];
517 struct dwc2_hcd_iso_packet_desc *frame_desc;
518
519 memset(dma_desc, 0, sizeof(*dma_desc));
520 frame_desc = &qtd->urb->iso_descs[qtd->isoc_frame_index_last];
521
522 if (frame_desc->length > max_xfer_size)
523 qh->n_bytes[idx] = max_xfer_size;
524 else
525 qh->n_bytes[idx] = frame_desc->length;
526
527 dma_desc->buf = (u32)(qtd->urb->dma + frame_desc->offset);
528 dma_desc->status = qh->n_bytes[idx] << HOST_DMA_ISOC_NBYTES_SHIFT &
529 HOST_DMA_ISOC_NBYTES_MASK;
530
531 /* Set active bit */
532 dma_desc->status |= HOST_DMA_A;
533
534 qh->ntd++;
535 qtd->isoc_frame_index_last++;
536
537 #ifdef ISOC_URB_GIVEBACK_ASAP
538 /* Set IOC for each descriptor corresponding to last frame of URB */
539 if (qtd->isoc_frame_index_last == qtd->urb->packet_count)
540 dma_desc->status |= HOST_DMA_IOC;
541 #endif
542
543 dma_sync_single_for_device(hsotg->dev,
544 qh->desc_list_dma +
545 (idx * sizeof(struct dwc2_dma_desc)),
546 sizeof(struct dwc2_dma_desc),
547 DMA_TO_DEVICE);
548 }
549
550 static void dwc2_init_isoc_dma_desc(struct dwc2_hsotg *hsotg,
551 struct dwc2_qh *qh, u16 skip_frames)
552 {
553 struct dwc2_qtd *qtd;
554 u32 max_xfer_size;
555 u16 idx, inc, n_desc = 0, ntd_max = 0;
556 u16 cur_idx;
557 u16 next_idx;
558
559 idx = qh->td_last;
560 inc = qh->host_interval;
561 hsotg->frame_number = dwc2_hcd_get_frame_number(hsotg);
562 cur_idx = idx;
563 next_idx = dwc2_desclist_idx_inc(qh->td_last, inc, qh->dev_speed);
564
565 /*
566 * Ensure current frame number didn't overstep last scheduled
567 * descriptor. If it happens, the only way to recover is to move
568 * qh->td_last to current frame number + 1.
569 * So that next isoc descriptor will be scheduled on frame number + 1
570 * and not on a past frame.
571 */
572 if (dwc2_frame_idx_num_gt(cur_idx, next_idx) || (cur_idx == next_idx)) {
573 if (inc < 32) {
574 dev_vdbg(hsotg->dev,
575 "current frame number overstep last descriptor\n");
576 qh->td_last = dwc2_desclist_idx_inc(cur_idx, inc,
577 qh->dev_speed);
578 idx = qh->td_last;
579 }
580 }
581
582 if (qh->host_interval) {
583 ntd_max = (dwc2_max_desc_num(qh) + qh->host_interval - 1) /
584 qh->host_interval;
585 if (skip_frames && !qh->channel)
586 ntd_max -= skip_frames / qh->host_interval;
587 }
588
589 max_xfer_size = qh->dev_speed == USB_SPEED_HIGH ?
590 MAX_ISOC_XFER_SIZE_HS : MAX_ISOC_XFER_SIZE_FS;
591
592 list_for_each_entry(qtd, &qh->qtd_list, qtd_list_entry) {
593 if (qtd->in_process &&
594 qtd->isoc_frame_index_last ==
595 qtd->urb->packet_count)
596 continue;
597
598 qtd->isoc_td_first = idx;
599 while (qh->ntd < ntd_max && qtd->isoc_frame_index_last <
600 qtd->urb->packet_count) {
601 dwc2_fill_host_isoc_dma_desc(hsotg, qtd, qh,
602 max_xfer_size, idx);
603 idx = dwc2_desclist_idx_inc(idx, inc, qh->dev_speed);
604 n_desc++;
605 }
606 qtd->isoc_td_last = idx;
607 qtd->in_process = 1;
608 }
609
610 qh->td_last = idx;
611
612 #ifdef ISOC_URB_GIVEBACK_ASAP
613 /* Set IOC for last descriptor if descriptor list is full */
614 if (qh->ntd == ntd_max) {
615 idx = dwc2_desclist_idx_dec(qh->td_last, inc, qh->dev_speed);
616 qh->desc_list[idx].status |= HOST_DMA_IOC;
617 dma_sync_single_for_device(hsotg->dev,
618 qh->desc_list_dma + (idx *
619 sizeof(struct dwc2_dma_desc)),
620 sizeof(struct dwc2_dma_desc),
621 DMA_TO_DEVICE);
622 }
623 #else
624 /*
625 * Set IOC bit only for one descriptor. Always try to be ahead of HW
626 * processing, i.e. on IOC generation driver activates next descriptor
627 * but core continues to process descriptors following the one with IOC
628 * set.
629 */
630
631 if (n_desc > DESCNUM_THRESHOLD)
632 /*
633 * Move IOC "up". Required even if there is only one QTD
634 * in the list, because QTDs might continue to be queued,
635 * but during the activation it was only one queued.
636 * Actually more than one QTD might be in the list if this
637 * function called from XferCompletion - QTDs was queued during
638 * HW processing of the previous descriptor chunk.
639 */
640 idx = dwc2_desclist_idx_dec(idx, inc * ((qh->ntd + 1) / 2),
641 qh->dev_speed);
642 else
643 /*
644 * Set the IOC for the latest descriptor if either number of
645 * descriptors is not greater than threshold or no more new
646 * descriptors activated
647 */
648 idx = dwc2_desclist_idx_dec(qh->td_last, inc, qh->dev_speed);
649
650 qh->desc_list[idx].status |= HOST_DMA_IOC;
651 dma_sync_single_for_device(hsotg->dev,
652 qh->desc_list_dma +
653 (idx * sizeof(struct dwc2_dma_desc)),
654 sizeof(struct dwc2_dma_desc),
655 DMA_TO_DEVICE);
656 #endif
657 }
658
659 static void dwc2_fill_host_dma_desc(struct dwc2_hsotg *hsotg,
660 struct dwc2_host_chan *chan,
661 struct dwc2_qtd *qtd, struct dwc2_qh *qh,
662 int n_desc)
663 {
664 struct dwc2_dma_desc *dma_desc = &qh->desc_list[n_desc];
665 int len = chan->xfer_len;
666
667 if (len > HOST_DMA_NBYTES_LIMIT - (chan->max_packet - 1))
668 len = HOST_DMA_NBYTES_LIMIT - (chan->max_packet - 1);
669
670 if (chan->ep_is_in) {
671 int num_packets;
672
673 if (len > 0 && chan->max_packet)
674 num_packets = (len + chan->max_packet - 1)
675 / chan->max_packet;
676 else
677 /* Need 1 packet for transfer length of 0 */
678 num_packets = 1;
679
680 /* Always program an integral # of packets for IN transfers */
681 len = num_packets * chan->max_packet;
682 }
683
684 dma_desc->status = len << HOST_DMA_NBYTES_SHIFT & HOST_DMA_NBYTES_MASK;
685 qh->n_bytes[n_desc] = len;
686
687 if (qh->ep_type == USB_ENDPOINT_XFER_CONTROL &&
688 qtd->control_phase == DWC2_CONTROL_SETUP)
689 dma_desc->status |= HOST_DMA_SUP;
690
691 dma_desc->buf = (u32)chan->xfer_dma;
692
693 dma_sync_single_for_device(hsotg->dev,
694 qh->desc_list_dma +
695 (n_desc * sizeof(struct dwc2_dma_desc)),
696 sizeof(struct dwc2_dma_desc),
697 DMA_TO_DEVICE);
698
699 /*
700 * Last (or only) descriptor of IN transfer with actual size less
701 * than MaxPacket
702 */
703 if (len > chan->xfer_len) {
704 chan->xfer_len = 0;
705 } else {
706 chan->xfer_dma += len;
707 chan->xfer_len -= len;
708 }
709 }
710
711 static void dwc2_init_non_isoc_dma_desc(struct dwc2_hsotg *hsotg,
712 struct dwc2_qh *qh)
713 {
714 struct dwc2_qtd *qtd;
715 struct dwc2_host_chan *chan = qh->channel;
716 int n_desc = 0;
717
718 dev_vdbg(hsotg->dev, "%s(): qh=%p dma=%08lx len=%d\n", __func__, qh,
719 (unsigned long)chan->xfer_dma, chan->xfer_len);
720
721 /*
722 * Start with chan->xfer_dma initialized in assign_and_init_hc(), then
723 * if SG transfer consists of multiple URBs, this pointer is re-assigned
724 * to the buffer of the currently processed QTD. For non-SG request
725 * there is always one QTD active.
726 */
727
728 list_for_each_entry(qtd, &qh->qtd_list, qtd_list_entry) {
729 dev_vdbg(hsotg->dev, "qtd=%p\n", qtd);
730
731 if (n_desc) {
732 /* SG request - more than 1 QTD */
733 chan->xfer_dma = qtd->urb->dma +
734 qtd->urb->actual_length;
735 chan->xfer_len = qtd->urb->length -
736 qtd->urb->actual_length;
737 dev_vdbg(hsotg->dev, "buf=%08lx len=%d\n",
738 (unsigned long)chan->xfer_dma, chan->xfer_len);
739 }
740
741 qtd->n_desc = 0;
742 do {
743 if (n_desc > 1) {
744 qh->desc_list[n_desc - 1].status |= HOST_DMA_A;
745 dev_vdbg(hsotg->dev,
746 "set A bit in desc %d (%p)\n",
747 n_desc - 1,
748 &qh->desc_list[n_desc - 1]);
749 dma_sync_single_for_device(hsotg->dev,
750 qh->desc_list_dma +
751 ((n_desc - 1) *
752 sizeof(struct dwc2_dma_desc)),
753 sizeof(struct dwc2_dma_desc),
754 DMA_TO_DEVICE);
755 }
756 dwc2_fill_host_dma_desc(hsotg, chan, qtd, qh, n_desc);
757 dev_vdbg(hsotg->dev,
758 "desc %d (%p) buf=%08x status=%08x\n",
759 n_desc, &qh->desc_list[n_desc],
760 qh->desc_list[n_desc].buf,
761 qh->desc_list[n_desc].status);
762 qtd->n_desc++;
763 n_desc++;
764 } while (chan->xfer_len > 0 &&
765 n_desc != MAX_DMA_DESC_NUM_GENERIC);
766
767 dev_vdbg(hsotg->dev, "n_desc=%d\n", n_desc);
768 qtd->in_process = 1;
769 if (qh->ep_type == USB_ENDPOINT_XFER_CONTROL)
770 break;
771 if (n_desc == MAX_DMA_DESC_NUM_GENERIC)
772 break;
773 }
774
775 if (n_desc) {
776 qh->desc_list[n_desc - 1].status |=
777 HOST_DMA_IOC | HOST_DMA_EOL | HOST_DMA_A;
778 dev_vdbg(hsotg->dev, "set IOC/EOL/A bits in desc %d (%p)\n",
779 n_desc - 1, &qh->desc_list[n_desc - 1]);
780 dma_sync_single_for_device(hsotg->dev,
781 qh->desc_list_dma + (n_desc - 1) *
782 sizeof(struct dwc2_dma_desc),
783 sizeof(struct dwc2_dma_desc),
784 DMA_TO_DEVICE);
785 if (n_desc > 1) {
786 qh->desc_list[0].status |= HOST_DMA_A;
787 dev_vdbg(hsotg->dev, "set A bit in desc 0 (%p)\n",
788 &qh->desc_list[0]);
789 dma_sync_single_for_device(hsotg->dev,
790 qh->desc_list_dma,
791 sizeof(struct dwc2_dma_desc),
792 DMA_TO_DEVICE);
793 }
794 chan->ntd = n_desc;
795 }
796 }
797
798 /**
799 * dwc2_hcd_start_xfer_ddma() - Starts a transfer in Descriptor DMA mode
800 *
801 * @hsotg: The HCD state structure for the DWC OTG controller
802 * @qh: The QH to init
803 *
804 * Return: 0 if successful, negative error code otherwise
805 *
806 * For Control and Bulk endpoints, initializes descriptor list and starts the
807 * transfer. For Interrupt and Isochronous endpoints, initializes descriptor
808 * list then updates FrameList, marking appropriate entries as active.
809 *
810 * For Isochronous endpoints the starting descriptor index is calculated based
811 * on the scheduled frame, but only on the first transfer descriptor within a
812 * session. Then the transfer is started via enabling the channel.
813 *
814 * For Isochronous endpoints the channel is not halted on XferComplete
815 * interrupt so remains assigned to the endpoint(QH) until session is done.
816 */
817 void dwc2_hcd_start_xfer_ddma(struct dwc2_hsotg *hsotg, struct dwc2_qh *qh)
818 {
819 /* Channel is already assigned */
820 struct dwc2_host_chan *chan = qh->channel;
821 u16 skip_frames = 0;
822
823 switch (chan->ep_type) {
824 case USB_ENDPOINT_XFER_CONTROL:
825 case USB_ENDPOINT_XFER_BULK:
826 dwc2_init_non_isoc_dma_desc(hsotg, qh);
827 dwc2_hc_start_transfer_ddma(hsotg, chan);
828 break;
829 case USB_ENDPOINT_XFER_INT:
830 dwc2_init_non_isoc_dma_desc(hsotg, qh);
831 dwc2_update_frame_list(hsotg, qh, 1);
832 dwc2_hc_start_transfer_ddma(hsotg, chan);
833 break;
834 case USB_ENDPOINT_XFER_ISOC:
835 if (!qh->ntd)
836 skip_frames = dwc2_recalc_initial_desc_idx(hsotg, qh);
837 dwc2_init_isoc_dma_desc(hsotg, qh, skip_frames);
838
839 if (!chan->xfer_started) {
840 dwc2_update_frame_list(hsotg, qh, 1);
841
842 /*
843 * Always set to max, instead of actual size. Otherwise
844 * ntd will be changed with channel being enabled. Not
845 * recommended.
846 */
847 chan->ntd = dwc2_max_desc_num(qh);
848
849 /* Enable channel only once for ISOC */
850 dwc2_hc_start_transfer_ddma(hsotg, chan);
851 }
852
853 break;
854 default:
855 break;
856 }
857 }
858
859 #define DWC2_CMPL_DONE 1
860 #define DWC2_CMPL_STOP 2
861
862 static int dwc2_cmpl_host_isoc_dma_desc(struct dwc2_hsotg *hsotg,
863 struct dwc2_host_chan *chan,
864 struct dwc2_qtd *qtd,
865 struct dwc2_qh *qh, u16 idx)
866 {
867 struct dwc2_dma_desc *dma_desc;
868 struct dwc2_hcd_iso_packet_desc *frame_desc;
869 u16 frame_desc_idx;
870 struct urb *usb_urb;
871 u16 remain = 0;
872 int rc = 0;
873
874 if (!qtd->urb)
875 return -EINVAL;
876
877 usb_urb = qtd->urb->priv;
878
879 dma_sync_single_for_cpu(hsotg->dev, qh->desc_list_dma + (idx *
880 sizeof(struct dwc2_dma_desc)),
881 sizeof(struct dwc2_dma_desc),
882 DMA_FROM_DEVICE);
883
884 dma_desc = &qh->desc_list[idx];
885 frame_desc_idx = (idx - qtd->isoc_td_first) & (usb_urb->number_of_packets - 1);
886
887 frame_desc = &qtd->urb->iso_descs[frame_desc_idx];
888 if (idx == qtd->isoc_td_first)
889 usb_urb->start_frame = dwc2_hcd_get_frame_number(hsotg);
890 dma_desc->buf = (u32)(qtd->urb->dma + frame_desc->offset);
891 if (chan->ep_is_in)
892 remain = (dma_desc->status & HOST_DMA_ISOC_NBYTES_MASK) >>
893 HOST_DMA_ISOC_NBYTES_SHIFT;
894
895 if ((dma_desc->status & HOST_DMA_STS_MASK) == HOST_DMA_STS_PKTERR) {
896 /*
897 * XactError, or unable to complete all the transactions
898 * in the scheduled micro-frame/frame, both indicated by
899 * HOST_DMA_STS_PKTERR
900 */
901 qtd->urb->error_count++;
902 frame_desc->actual_length = qh->n_bytes[idx] - remain;
903 frame_desc->status = -EPROTO;
904 } else {
905 /* Success */
906 frame_desc->actual_length = qh->n_bytes[idx] - remain;
907 frame_desc->status = 0;
908 }
909
910 if (++qtd->isoc_frame_index == usb_urb->number_of_packets) {
911 /*
912 * urb->status is not used for isoc transfers here. The
913 * individual frame_desc status are used instead.
914 */
915 dwc2_host_complete(hsotg, qtd, 0);
916 dwc2_hcd_qtd_unlink_and_free(hsotg, qtd, qh);
917
918 /*
919 * This check is necessary because urb_dequeue can be called
920 * from urb complete callback (sound driver for example). All
921 * pending URBs are dequeued there, so no need for further
922 * processing.
923 */
924 if (chan->halt_status == DWC2_HC_XFER_URB_DEQUEUE)
925 return -1;
926 rc = DWC2_CMPL_DONE;
927 }
928
929 qh->ntd--;
930
931 /* Stop if IOC requested descriptor reached */
932 if (dma_desc->status & HOST_DMA_IOC)
933 rc = DWC2_CMPL_STOP;
934
935 return rc;
936 }
937
938 static void dwc2_complete_isoc_xfer_ddma(struct dwc2_hsotg *hsotg,
939 struct dwc2_host_chan *chan,
940 enum dwc2_halt_status halt_status)
941 {
942 struct dwc2_hcd_iso_packet_desc *frame_desc;
943 struct dwc2_qtd *qtd, *qtd_tmp;
944 struct dwc2_qh *qh;
945 u16 idx;
946 int rc;
947
948 qh = chan->qh;
949 idx = qh->td_first;
950
951 if (chan->halt_status == DWC2_HC_XFER_URB_DEQUEUE) {
952 list_for_each_entry(qtd, &qh->qtd_list, qtd_list_entry)
953 qtd->in_process = 0;
954 return;
955 }
956
957 if (halt_status == DWC2_HC_XFER_AHB_ERR ||
958 halt_status == DWC2_HC_XFER_BABBLE_ERR) {
959 /*
960 * Channel is halted in these error cases, considered as serious
961 * issues.
962 * Complete all URBs marking all frames as failed, irrespective
963 * whether some of the descriptors (frames) succeeded or not.
964 * Pass error code to completion routine as well, to update
965 * urb->status, some of class drivers might use it to stop
966 * queing transfer requests.
967 */
968 int err = halt_status == DWC2_HC_XFER_AHB_ERR ?
969 -EIO : -EOVERFLOW;
970
971 list_for_each_entry_safe(qtd, qtd_tmp, &qh->qtd_list,
972 qtd_list_entry) {
973 if (qtd->urb) {
974 for (idx = 0; idx < qtd->urb->packet_count;
975 idx++) {
976 frame_desc = &qtd->urb->iso_descs[idx];
977 frame_desc->status = err;
978 }
979
980 dwc2_host_complete(hsotg, qtd, err);
981 }
982
983 dwc2_hcd_qtd_unlink_and_free(hsotg, qtd, qh);
984 }
985
986 return;
987 }
988
989 list_for_each_entry_safe(qtd, qtd_tmp, &qh->qtd_list, qtd_list_entry) {
990 if (!qtd->in_process)
991 break;
992
993 /*
994 * Ensure idx corresponds to descriptor where first urb of this
995 * qtd was added. In fact, during isoc desc init, dwc2 may skip
996 * an index if current frame number is already over this index.
997 */
998 if (idx != qtd->isoc_td_first) {
999 dev_vdbg(hsotg->dev,
1000 "try to complete %d instead of %d\n",
1001 idx, qtd->isoc_td_first);
1002 idx = qtd->isoc_td_first;
1003 }
1004
1005 do {
1006 struct dwc2_qtd *qtd_next;
1007 u16 cur_idx;
1008
1009 rc = dwc2_cmpl_host_isoc_dma_desc(hsotg, chan, qtd, qh,
1010 idx);
1011 if (rc < 0)
1012 return;
1013 idx = dwc2_desclist_idx_inc(idx, qh->host_interval,
1014 chan->speed);
1015 if (rc == 0)
1016 continue;
1017
1018 if (rc == DWC2_CMPL_DONE || rc == DWC2_CMPL_STOP)
1019 goto stop_scan;
1020
1021 /* rc == DWC2_CMPL_STOP */
1022
1023 if (qh->host_interval >= 32)
1024 goto stop_scan;
1025
1026 qh->td_first = idx;
1027 cur_idx = dwc2_frame_list_idx(hsotg->frame_number);
1028 qtd_next = list_first_entry(&qh->qtd_list,
1029 struct dwc2_qtd,
1030 qtd_list_entry);
1031 if (dwc2_frame_idx_num_gt(cur_idx,
1032 qtd_next->isoc_td_last))
1033 break;
1034
1035 goto stop_scan;
1036
1037 } while (idx != qh->td_first);
1038 }
1039
1040 stop_scan:
1041 qh->td_first = idx;
1042 }
1043
1044 static int dwc2_update_non_isoc_urb_state_ddma(struct dwc2_hsotg *hsotg,
1045 struct dwc2_host_chan *chan,
1046 struct dwc2_qtd *qtd,
1047 struct dwc2_dma_desc *dma_desc,
1048 enum dwc2_halt_status halt_status,
1049 u32 n_bytes, int *xfer_done)
1050 {
1051 struct dwc2_hcd_urb *urb = qtd->urb;
1052 u16 remain = 0;
1053
1054 if (chan->ep_is_in)
1055 remain = (dma_desc->status & HOST_DMA_NBYTES_MASK) >>
1056 HOST_DMA_NBYTES_SHIFT;
1057
1058 dev_vdbg(hsotg->dev, "remain=%d dwc2_urb=%p\n", remain, urb);
1059
1060 if (halt_status == DWC2_HC_XFER_AHB_ERR) {
1061 dev_err(hsotg->dev, "EIO\n");
1062 urb->status = -EIO;
1063 return 1;
1064 }
1065
1066 if ((dma_desc->status & HOST_DMA_STS_MASK) == HOST_DMA_STS_PKTERR) {
1067 switch (halt_status) {
1068 case DWC2_HC_XFER_STALL:
1069 dev_vdbg(hsotg->dev, "Stall\n");
1070 urb->status = -EPIPE;
1071 break;
1072 case DWC2_HC_XFER_BABBLE_ERR:
1073 dev_err(hsotg->dev, "Babble\n");
1074 urb->status = -EOVERFLOW;
1075 break;
1076 case DWC2_HC_XFER_XACT_ERR:
1077 dev_err(hsotg->dev, "XactErr\n");
1078 urb->status = -EPROTO;
1079 break;
1080 default:
1081 dev_err(hsotg->dev,
1082 "%s: Unhandled descriptor error status (%d)\n",
1083 __func__, halt_status);
1084 break;
1085 }
1086 return 1;
1087 }
1088
1089 if (dma_desc->status & HOST_DMA_A) {
1090 dev_vdbg(hsotg->dev,
1091 "Active descriptor encountered on channel %d\n",
1092 chan->hc_num);
1093 return 0;
1094 }
1095
1096 if (chan->ep_type == USB_ENDPOINT_XFER_CONTROL) {
1097 if (qtd->control_phase == DWC2_CONTROL_DATA) {
1098 urb->actual_length += n_bytes - remain;
1099 if (remain || urb->actual_length >= urb->length) {
1100 /*
1101 * For Control Data stage do not set urb->status
1102 * to 0, to prevent URB callback. Set it when
1103 * Status phase is done. See below.
1104 */
1105 *xfer_done = 1;
1106 }
1107 } else if (qtd->control_phase == DWC2_CONTROL_STATUS) {
1108 urb->status = 0;
1109 *xfer_done = 1;
1110 }
1111 /* No handling for SETUP stage */
1112 } else {
1113 /* BULK and INTR */
1114 urb->actual_length += n_bytes - remain;
1115 dev_vdbg(hsotg->dev, "length=%d actual=%d\n", urb->length,
1116 urb->actual_length);
1117 if (remain || urb->actual_length >= urb->length) {
1118 urb->status = 0;
1119 *xfer_done = 1;
1120 }
1121 }
1122
1123 return 0;
1124 }
1125
1126 static int dwc2_process_non_isoc_desc(struct dwc2_hsotg *hsotg,
1127 struct dwc2_host_chan *chan,
1128 int chnum, struct dwc2_qtd *qtd,
1129 int desc_num,
1130 enum dwc2_halt_status halt_status,
1131 int *xfer_done)
1132 {
1133 struct dwc2_qh *qh = chan->qh;
1134 struct dwc2_hcd_urb *urb = qtd->urb;
1135 struct dwc2_dma_desc *dma_desc;
1136 u32 n_bytes;
1137 int failed;
1138
1139 dev_vdbg(hsotg->dev, "%s()\n", __func__);
1140
1141 if (!urb)
1142 return -EINVAL;
1143
1144 dma_sync_single_for_cpu(hsotg->dev,
1145 qh->desc_list_dma + (desc_num *
1146 sizeof(struct dwc2_dma_desc)),
1147 sizeof(struct dwc2_dma_desc),
1148 DMA_FROM_DEVICE);
1149
1150 dma_desc = &qh->desc_list[desc_num];
1151 n_bytes = qh->n_bytes[desc_num];
1152 dev_vdbg(hsotg->dev,
1153 "qtd=%p dwc2_urb=%p desc_num=%d desc=%p n_bytes=%d\n",
1154 qtd, urb, desc_num, dma_desc, n_bytes);
1155 failed = dwc2_update_non_isoc_urb_state_ddma(hsotg, chan, qtd, dma_desc,
1156 halt_status, n_bytes,
1157 xfer_done);
1158 if (failed || (*xfer_done && urb->status != -EINPROGRESS)) {
1159 dwc2_host_complete(hsotg, qtd, urb->status);
1160 dwc2_hcd_qtd_unlink_and_free(hsotg, qtd, qh);
1161 dev_vdbg(hsotg->dev, "failed=%1x xfer_done=%1x\n",
1162 failed, *xfer_done);
1163 return failed;
1164 }
1165
1166 if (qh->ep_type == USB_ENDPOINT_XFER_CONTROL) {
1167 switch (qtd->control_phase) {
1168 case DWC2_CONTROL_SETUP:
1169 if (urb->length > 0)
1170 qtd->control_phase = DWC2_CONTROL_DATA;
1171 else
1172 qtd->control_phase = DWC2_CONTROL_STATUS;
1173 dev_vdbg(hsotg->dev,
1174 " Control setup transaction done\n");
1175 break;
1176 case DWC2_CONTROL_DATA:
1177 if (*xfer_done) {
1178 qtd->control_phase = DWC2_CONTROL_STATUS;
1179 dev_vdbg(hsotg->dev,
1180 " Control data transfer done\n");
1181 } else if (desc_num + 1 == qtd->n_desc) {
1182 /*
1183 * Last descriptor for Control data stage which
1184 * is not completed yet
1185 */
1186 dwc2_hcd_save_data_toggle(hsotg, chan, chnum,
1187 qtd);
1188 }
1189 break;
1190 default:
1191 break;
1192 }
1193 }
1194
1195 return 0;
1196 }
1197
1198 static void dwc2_complete_non_isoc_xfer_ddma(struct dwc2_hsotg *hsotg,
1199 struct dwc2_host_chan *chan,
1200 int chnum,
1201 enum dwc2_halt_status halt_status)
1202 {
1203 struct list_head *qtd_item, *qtd_tmp;
1204 struct dwc2_qh *qh = chan->qh;
1205 struct dwc2_qtd *qtd = NULL;
1206 int xfer_done;
1207 int desc_num = 0;
1208
1209 if (chan->halt_status == DWC2_HC_XFER_URB_DEQUEUE) {
1210 list_for_each_entry(qtd, &qh->qtd_list, qtd_list_entry)
1211 qtd->in_process = 0;
1212 return;
1213 }
1214
1215 list_for_each_safe(qtd_item, qtd_tmp, &qh->qtd_list) {
1216 int i;
1217 int qtd_desc_count;
1218
1219 qtd = list_entry(qtd_item, struct dwc2_qtd, qtd_list_entry);
1220 xfer_done = 0;
1221 qtd_desc_count = qtd->n_desc;
1222
1223 for (i = 0; i < qtd_desc_count; i++) {
1224 if (dwc2_process_non_isoc_desc(hsotg, chan, chnum, qtd,
1225 desc_num, halt_status,
1226 &xfer_done)) {
1227 qtd = NULL;
1228 goto stop_scan;
1229 }
1230
1231 desc_num++;
1232 }
1233 }
1234
1235 stop_scan:
1236 if (qh->ep_type != USB_ENDPOINT_XFER_CONTROL) {
1237 /*
1238 * Resetting the data toggle for bulk and interrupt endpoints
1239 * in case of stall. See handle_hc_stall_intr().
1240 */
1241 if (halt_status == DWC2_HC_XFER_STALL)
1242 qh->data_toggle = DWC2_HC_PID_DATA0;
1243 else
1244 dwc2_hcd_save_data_toggle(hsotg, chan, chnum, NULL);
1245 }
1246
1247 if (halt_status == DWC2_HC_XFER_COMPLETE) {
1248 if (chan->hcint & HCINTMSK_NYET) {
1249 /*
1250 * Got a NYET on the last transaction of the transfer.
1251 * It means that the endpoint should be in the PING
1252 * state at the beginning of the next transfer.
1253 */
1254 qh->ping_state = 1;
1255 }
1256 }
1257 }
1258
1259 /**
1260 * dwc2_hcd_complete_xfer_ddma() - Scans the descriptor list, updates URB's
1261 * status and calls completion routine for the URB if it's done. Called from
1262 * interrupt handlers.
1263 *
1264 * @hsotg: The HCD state structure for the DWC OTG controller
1265 * @chan: Host channel the transfer is completed on
1266 * @chnum: Index of Host channel registers
1267 * @halt_status: Reason the channel is being halted or just XferComplete
1268 * for isochronous transfers
1269 *
1270 * Releases the channel to be used by other transfers.
1271 * In case of Isochronous endpoint the channel is not halted until the end of
1272 * the session, i.e. QTD list is empty.
1273 * If periodic channel released the FrameList is updated accordingly.
1274 * Calls transaction selection routines to activate pending transfers.
1275 */
1276 void dwc2_hcd_complete_xfer_ddma(struct dwc2_hsotg *hsotg,
1277 struct dwc2_host_chan *chan, int chnum,
1278 enum dwc2_halt_status halt_status)
1279 {
1280 struct dwc2_qh *qh = chan->qh;
1281 int continue_isoc_xfer = 0;
1282 enum dwc2_transaction_type tr_type;
1283
1284 if (chan->ep_type == USB_ENDPOINT_XFER_ISOC) {
1285 dwc2_complete_isoc_xfer_ddma(hsotg, chan, halt_status);
1286
1287 /* Release the channel if halted or session completed */
1288 if (halt_status != DWC2_HC_XFER_COMPLETE ||
1289 list_empty(&qh->qtd_list)) {
1290 struct dwc2_qtd *qtd, *qtd_tmp;
1291
1292 /*
1293 * Kill all remainings QTDs since channel has been
1294 * halted.
1295 */
1296 list_for_each_entry_safe(qtd, qtd_tmp,
1297 &qh->qtd_list,
1298 qtd_list_entry) {
1299 dwc2_host_complete(hsotg, qtd,
1300 -ECONNRESET);
1301 dwc2_hcd_qtd_unlink_and_free(hsotg,
1302 qtd, qh);
1303 }
1304
1305 /* Halt the channel if session completed */
1306 if (halt_status == DWC2_HC_XFER_COMPLETE)
1307 dwc2_hc_halt(hsotg, chan, halt_status);
1308 dwc2_release_channel_ddma(hsotg, qh);
1309 dwc2_hcd_qh_unlink(hsotg, qh);
1310 } else {
1311 /* Keep in assigned schedule to continue transfer */
1312 list_move_tail(&qh->qh_list_entry,
1313 &hsotg->periodic_sched_assigned);
1314 /*
1315 * If channel has been halted during giveback of urb
1316 * then prevent any new scheduling.
1317 */
1318 if (!chan->halt_status)
1319 continue_isoc_xfer = 1;
1320 }
1321 /*
1322 * Todo: Consider the case when period exceeds FrameList size.
1323 * Frame Rollover interrupt should be used.
1324 */
1325 } else {
1326 /*
1327 * Scan descriptor list to complete the URB(s), then release
1328 * the channel
1329 */
1330 dwc2_complete_non_isoc_xfer_ddma(hsotg, chan, chnum,
1331 halt_status);
1332 dwc2_release_channel_ddma(hsotg, qh);
1333 dwc2_hcd_qh_unlink(hsotg, qh);
1334
1335 if (!list_empty(&qh->qtd_list)) {
1336 /*
1337 * Add back to inactive non-periodic schedule on normal
1338 * completion
1339 */
1340 dwc2_hcd_qh_add(hsotg, qh);
1341 }
1342 }
1343
1344 tr_type = dwc2_hcd_select_transactions(hsotg);
1345 if (tr_type != DWC2_TRANSACTION_NONE || continue_isoc_xfer) {
1346 if (continue_isoc_xfer) {
1347 if (tr_type == DWC2_TRANSACTION_NONE)
1348 tr_type = DWC2_TRANSACTION_PERIODIC;
1349 else if (tr_type == DWC2_TRANSACTION_NON_PERIODIC)
1350 tr_type = DWC2_TRANSACTION_ALL;
1351 }
1352 dwc2_hcd_queue_transactions(hsotg, tr_type);
1353 }
1354 }
Linux Kernel