M480 BSP  V3.05.001
The Board Support Package for M480 Series
ehci_iso.c
Go to the documentation of this file.
1 /**************************************************************************/
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13 
14 #include "NuMicro.h"
15 
16 #include "usb.h"
17 #include "hub.h"
18 
19 
21 
22 uint32_t g_flr_cnt; /* frame list rollover counter */
23 
24 ISO_EP_T *iso_ep_list; /* list of activated isochronous pipes */
25 
26 extern uint32_t _PFList[FL_SIZE]; /* Periodic frame list */
27 
28 static const uint16_t sitd_OUT_Smask [] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f };
29 
30 static int ehci_iso_split_xfer(UTR_T *utr, ISO_EP_T *iso_ep);
31 
32 /*
33  * Inspect the iTD can be reclaimed or not. If yes, collect the transaction results.
34  * Return: 1 - reclaimed
35  * 0 - not completed
36  */
37 static int review_itd(iTD_T *itd)
38 {
39  UTR_T *utr;
40  uint32_t frnidx = itd->sched_frnidx;
41  uint32_t now_frame = (_ehci->UFINDR >> 3) & 0x3FF;
42  int i, fidx;
43 
44  // printf("R - %d %d, 0x%x\n", now_frame, frnidx, itd->Transaction[0]);
45 
46  if (now_frame == frnidx)
47  {
48  for (i = 0; i < 8; i++)
49  {
50  if (itd->Transaction[i] & ITD_STATUS_ACTIVE)
51  return 0; /* have any not completed frames */
52  }
53  }
54  else if (now_frame > frnidx)
55  {
56  if ((now_frame - frnidx) > EHCI_ISO_RCLM_RANGE)
57  return 0; /* don't touch it */
58  }
59  else
60  {
61  if (now_frame + FL_SIZE - frnidx > EHCI_ISO_RCLM_RANGE)
62  return 0; /* don't touch it */
63  }
64 
65  /*
66  * Reclaim this iTD
67  */
68  utr = itd->utr;
69  fidx = itd->fidx;
70  for (i = 0; i < 8; i++)
71  {
72  if (!(itd->trans_mask & (0x1<<i)))
73  continue; /* not scheduled micro-frame */
74 
75  if (ITD_STATUS(itd->Transaction[i]))
76  {
77  if (itd->Transaction[i] & ITD_STATUS_ACTIVE)
78  {
79  utr->iso_status[fidx] = USBH_ERR_NOT_ACCESS0;
80  utr->status = USBH_ERR_NOT_ACCESS0;
81  }
82  else if (itd->Transaction[i] & ITD_STATUS_BABBLE)
83  {
84  utr->iso_status[fidx] = USBH_ERR_BABBLE_DETECTED;
85  utr->status = USBH_ERR_TRANSFER;
86  }
87  else if (itd->Transaction[i] & ITD_STATUS_BUFF_ERR)
88  {
89  utr->iso_status[fidx] = USBH_ERR_DATA_BUFF;
90  utr->status = USBH_ERR_TRANSFER;
91  }
92  else
93  {
94  utr->iso_status[fidx] = USBH_ERR_TRANSACTION;
95  utr->status = USBH_ERR_TRANSFER;
96  }
97  }
98  else
99  {
100  utr->iso_status[fidx] = 0;
101  utr->iso_xlen[fidx] = ITD_XFER_LEN(itd->Transaction[i]);
102  }
103  fidx++;
104  }
105  utr->td_cnt--;
106 
107  if (utr->td_cnt == 0) /* All iTD of this UTR done */
108  {
109  utr->bIsTransferDone = 1;
110  if (utr->func)
111  utr->func(utr);
112  }
113 
114  return 1; /* to be reclaimed */
115 }
116 
117 /*
118  * Inspect the siTD can be reclaimed or not. If yes, collect the transaction results.
119  * Return: 1 - reclaimed
120  * 0 - not completed
121  */
122 static int review_sitd(siTD_T *sitd)
123 {
124  UTR_T *utr;
125  uint32_t frnidx = sitd->sched_frnidx;
126  uint32_t now_frame = (_ehci->UFINDR >> 3) & 0x3FF;
127  int fidx;
128  uint32_t TotalBytesToTransfer;
129 
130  if (now_frame == frnidx)
131  {
132  if (SITD_STATUS(sitd->StsCtrl) == SITD_STATUS_ACTIVE)
133  return 0;
134  }
135  else if (now_frame > frnidx)
136  {
137  if ((now_frame - frnidx) > EHCI_ISO_RCLM_RANGE)
138  return 0; /* don't touch it */
139  }
140  else
141  {
142  if (now_frame + FL_SIZE - frnidx > EHCI_ISO_RCLM_RANGE)
143  return 0; /* don't touch it */
144  }
145 
146  /*
147  * Reclaim this siTD
148  */
149  utr = sitd->utr;
150  fidx = sitd->fidx;
151 
152  if (SITD_STATUS(sitd->StsCtrl))
153  {
154  if (sitd->StsCtrl & SITD_STATUS_ACTIVE)
155  {
156  utr->iso_status[fidx] = USBH_ERR_NOT_ACCESS0;
157  }
158  else if (sitd->StsCtrl & SITD_BABBLE_DETECTED)
159  {
160  utr->iso_status[fidx] = USBH_ERR_BABBLE_DETECTED;
161  utr->status = USBH_ERR_TRANSFER;
162  }
163  else if (sitd->StsCtrl & SITD_STATUS_BUFF_ERR)
164  {
165  utr->iso_status[fidx] = USBH_ERR_DATA_BUFF;
166  utr->status = USBH_ERR_TRANSFER;
167  }
168  else
169  {
170  utr->iso_status[fidx] = USBH_ERR_TRANSACTION;
171  utr->status = USBH_ERR_TRANSFER;
172  }
173  }
174  else
175  {
176  TotalBytesToTransfer = (sitd->StsCtrl & SITD_XFER_CNT_Msk) >> SITD_XFER_CNT_Pos;
177  utr->iso_xlen[fidx] = utr->iso_xlen[fidx] - TotalBytesToTransfer;
178  utr->iso_status[fidx] = 0;
179  }
180  utr->td_cnt--;
181 
182  if (utr->td_cnt == 0) /* All iTD of this UTR done */
183  {
184  utr->bIsTransferDone = 1;
185  if (utr->func)
186  utr->func(utr);
187  }
188  return 1; /* to be reclaimed */
189 }
190 
191 /*
192  * Some iTD/siTD may be scheduled but not serviced due to time missed.
193  * This function scan several earlier frames and drop unserviced iTD/siTD if found.
194  */
195 void scan_isochronous_list(void)
196 {
197  ISO_EP_T *iso_ep = iso_ep_list;
198  iTD_T *itd, *itd_pre, *p;
199  siTD_T *sitd, *sitd_pre, *sp;
200  uint32_t frnidx;
201 
202  DISABLE_EHCI_IRQ();
203 
204  while (iso_ep != NULL) /* Search all activated iso endpoints */
205  {
206  /*--------------------------------------------------------------------------------*/
207  /* Scan all iTDs */
208  /*--------------------------------------------------------------------------------*/
209  itd = iso_ep->itd_list; /* get the first iTD from iso_ep's iTD list */
210  itd_pre = NULL;
211  while (itd != NULL) /* traverse all iTDs of itd list */
212  {
213  if (review_itd(itd)) /* inspect and reclaim iTD */
214  {
215  /*------------------------------------------------------------------------*/
216  /* Remove this iTD from period frame list */
217  /*------------------------------------------------------------------------*/
218  frnidx = itd->sched_frnidx;
219  if (_PFList[frnidx] == ITD_HLNK_ITD(itd))
220  {
221  /* is the first entry, just change to next */
222  _PFList[frnidx] = itd->Next_Link;
223  }
224  else
225  {
226  p = ITD_PTR(_PFList[frnidx]); /* find the preceding iTD */
227  while ((ITD_PTR(p->Next_Link) != itd) && (p != NULL))
228  {
229  p = ITD_PTR(p->Next_Link);
230  }
231 
232  if (p == NULL) /* link list out of control! */
233  {
234  USB_error("An iTD lost refernece to periodic frame list! 0x%x -> %d\n", (int)itd, frnidx);
235  }
236  else /* remove iTD from list */
237  {
238  p->Next_Link = itd->Next_Link;
239  }
240  }
241 
242  /*------------------------------------------------------------------------*/
243  /* Remove this iTD from iso_ep's iTD list */
244  /*------------------------------------------------------------------------*/
245  if (itd_pre == NULL)
246  {
247  iso_ep->itd_list = itd->next;
248  }
249  else
250  {
251  itd_pre->next = itd->next;
252  }
253  p = itd->next;
254  free_ehci_iTD(itd);
255  itd = p;
256  }
257  else
258  {
259  itd_pre = itd;
260  itd = itd->next; /* traverse to the next iTD of iTD list */
261  }
262  }
263 
264  /*--------------------------------------------------------------------------------*/
265  /* Scan all siTDs */
266  /*--------------------------------------------------------------------------------*/
267  sitd = iso_ep->sitd_list; /* get the first siTD from iso_ep's siTD list */
268  sitd_pre = NULL;
269  while (sitd != NULL) /* traverse all siTDs of sitd list */
270  {
271  if (review_sitd(sitd)) /* inspect and reclaim siTD */
272  {
273  /*------------------------------------------------------------------------*/
274  /* Remove this siTD from period frame list */
275  /*------------------------------------------------------------------------*/
276  frnidx = sitd->sched_frnidx;
277  if (_PFList[frnidx] == SITD_HLNK_SITD(sitd))
278  {
279  /* is the first entry, just change to next */
280  _PFList[frnidx] = sitd->Next_Link;
281  }
282  else
283  {
284  sp = SITD_PTR(_PFList[frnidx]); /* find the preceding siTD */
285  while ((SITD_PTR(sp->Next_Link) != sitd) && (sp != NULL))
286  {
287  sp = SITD_PTR(sp->Next_Link);
288  }
289 
290  if (sp == NULL) /* link list out of control! */
291  {
292  USB_error("An siTD lost reference to periodic frame list! 0x%x -> %d\n", (int)sitd, frnidx);
293  }
294  else /* remove iTD from list */
295  {
296  sp->Next_Link = sitd->Next_Link;
297  }
298  }
299 
300  /*------------------------------------------------------------------------*/
301  /* Remove this siTD from iso_ep's siTD list */
302  /*------------------------------------------------------------------------*/
303  if (sitd_pre == NULL)
304  {
305  iso_ep->sitd_list = sitd->next;
306  }
307  else
308  {
309  sitd_pre->next = sitd->next;
310  }
311  sp = sitd->next;
312  free_ehci_siTD(sitd);
313  sitd = sp;
314  }
315  else
316  {
317  sitd_pre = sitd;
318  sitd = sitd->next; /* traverse to the next siTD of siTD list */
319  }
320  }
321 
322  iso_ep = iso_ep->next;
323  }
324 
325  ENABLE_EHCI_IRQ();
326 }
327 
328 
329 static void write_itd_info(UTR_T *utr, iTD_T *itd)
330 {
331  UDEV_T *udev = utr->udev;
332  EP_INFO_T *ep = utr->ep; /* reference to isochronous endpoint */
333  uint32_t buff_page_addr;
334  int i;
335 
336  buff_page_addr = itd->buff_base & 0xFFFFF000; /* 4K page */
337 
338  for (i = 0; i < 7; i++)
339  {
340  itd->Bptr[i] = buff_page_addr + (0x1000 * i);
341  }
342  /* EndPtr R Device Address */
343  itd->Bptr[0] |= (udev->dev_num) | ((ep->bEndpointAddress & 0xF) << ITD_EP_NUM_Pos);
344  itd->Bptr[1] |= ep->wMaxPacketSize; /* Maximum Packet Size */
345 
346  if ((ep->bEndpointAddress & EP_ADDR_DIR_MASK) == EP_ADDR_DIR_IN) /* I/O */
347  itd->Bptr[1] |= ITD_DIR_IN;
348  else
349  itd->Bptr[1] |= ITD_DIR_OUT;
350 
351  itd->Bptr[2] |= (ep->wMaxPacketSize + 1023)/1024; /* Mult */
352 }
353 
354 static void write_itd_micro_frame(UTR_T *utr, int fidx, iTD_T *itd, int mf)
355 {
356  uint32_t buff_addr;
357 
358  buff_addr = (uint32_t)(utr->iso_buff[fidx]); /* xfer buffer start address of this frame */
359 
360  itd->Transaction[mf] = ITD_STATUS_ACTIVE | /* Status */
361  ((utr->iso_xlen[fidx] & 0xFFF) << ITD_XLEN_Pos) | /* Transaction Length */
362  ((buff_addr & 0xFFFFF000) - (itd->buff_base & 0xFFFFF000)) | /* PG */
363  (buff_addr & 0xFFF); /* Transaction offset */
364 }
365 
366 
367 static void remove_iso_ep_from_list(ISO_EP_T *iso_ep)
368 {
369  ISO_EP_T *p;
370 
371  if (iso_ep_list == iso_ep)
372  {
373  iso_ep_list = iso_ep->next; /* it's the first entry, remove it */
374  return;
375  }
376 
377  p = iso_ep_list; /* find the previous entry of iso_ep */
378  while (p->next != NULL)
379  {
380  if (p->next == iso_ep)
381  {
382  break;
383  }
384  p = p->next;
385  }
386 
387  if (p->next == NULL)
388  {
389  return; /* not found */
390  }
391  p->next = iso_ep->next; /* remove iso_ep from list */
392 }
393 
394 
395 static __inline void add_itd_to_iso_ep(ISO_EP_T *iso_ep, iTD_T *itd)
396 {
397  iTD_T *p;
398 
399  itd->next = NULL;
400 
401  if (iso_ep->itd_list == NULL)
402  {
403  iso_ep->itd_list = itd;
404  return;
405  }
406 
407  /*
408  * Find the tail entry of iso_ep->itd_list
409  */
410  p = iso_ep->itd_list;
411  while (p->next != NULL)
412  {
413  p = p->next;
414  }
415  p->next = itd;
416 }
417 
418 int ehci_iso_xfer(UTR_T *utr)
419 {
420  EP_INFO_T *ep = utr->ep; /* reference to isochronous endpoint */
421  ISO_EP_T *iso_ep; /* software iso endpoint descriptor */
422  iTD_T *itd, *itd_next, *itd_list = NULL;
423  int i, itd_cnt;
424  int trans_mask; /* bit mask of used xfer in an iTD */
425  int fidx; /* index to the 8 iso frames of UTR */
426  int interval; /* frame interval of iTD */
427 
428  if (ep->hw_pipe != NULL)
429  {
430  iso_ep = (ISO_EP_T *)ep->hw_pipe; /* get reference of the isochronous endpoint */
431 
432  if (utr->bIsoNewSched)
433  iso_ep->next_frame = (((_ehci->UFINDR + (EHCI_ISO_DELAY * 8)) & HSUSBH_UFINDR_FI_Msk) >> 3) & 0x3FF;
434  }
435  else
436  {
437  /* first time transfer of this iso endpoint */
438  iso_ep = usbh_alloc_mem(sizeof(*iso_ep));
439  if (iso_ep == NULL)
440  return USBH_ERR_MEMORY_OUT;
441 
442  memset(iso_ep, 0, sizeof(*iso_ep));
443  iso_ep->ep = ep;
444  iso_ep->next_frame = (((_ehci->UFINDR + (EHCI_ISO_DELAY * 8)) & HSUSBH_UFINDR_FI_Msk) >> 3) & 0x3FF;
445 
446  ep->hw_pipe = iso_ep;
447 
448  /*
449  * Add this iso_ep into iso_ep_list
450  */
451  DISABLE_EHCI_IRQ();
452  iso_ep->next = iso_ep_list;
453  iso_ep_list = iso_ep;
454  ENABLE_EHCI_IRQ();
455  }
456 
457  if (utr->udev->speed == SPEED_FULL)
458  return ehci_iso_split_xfer(utr, iso_ep);
459 
460  /*------------------------------------------------------------------------------------*/
461  /* Allocate iTDs */
462  /*------------------------------------------------------------------------------------*/
463 
464  if (ep->bInterval < 2) /* transfer interval is 1 micro-frame */
465  {
466  trans_mask = 0xFF;
467  itd_cnt = 1; /* required 1 iTD for one UTR */
468  interval = 1; /* iTD frame interval of this endpoint */
469  }
470  else if (ep->bInterval < 4) /* transfer interval is 2 micro-frames */
471  {
472  trans_mask = 0x55;
473  itd_cnt = 2; /* required 2 iTDs for one UTR */
474  interval = 1; /* iTD frame interval of this endpoint */
475  }
476  else if (ep->bInterval < 8) /* transfer interval is 4 micro-frames */
477  {
478  trans_mask = 0x44;
479  itd_cnt = 4; /* required 4 iTDs for one UTR */
480  interval = 1; /* iTD frame interval of this endpoint */
481  }
482  else if (ep->bInterval < 16) /* transfer interval is 8 micro-frames */
483  {
484  trans_mask = 0x08; /* there's 1 transfer in one iTD */
485  itd_cnt = 8; /* required 8 iTDs for one UTR */
486  interval = 1; /* iTD frame interval of this endpoint */
487  }
488  else if (ep->bInterval < 32) /* transfer interval is 16 micro-frames */
489  {
490  trans_mask = 0x10; /* there's 1 transfer in one iTD */
491  itd_cnt = 8; /* required 8 iTDs for one UTR */
492  interval = 2; /* iTD frame interval of this endpoint */
493  }
494  else if (ep->bInterval < 64) /* transfer interval is 32 micro-frames */
495  {
496  trans_mask = 0x02; /* there's 1 transfer in one iTD */
497  itd_cnt = 8; /* required 8 iTDs for one UTR */
498  interval = 4; /* iTD frame interval of this endpoint */
499  }
500  else /* transfer interval is 64 micro-frames */
501  {
502  trans_mask = 0x04; /* there's 1 transfer in one iTD */
503  itd_cnt = 8; /* required 8 iTDs for one UTR */
504  interval = 8; /* iTD frame interval of this endpoint */
505  }
506 
507  for (i = 0; i < itd_cnt; i++) /* allocate all iTDs required by UTR */
508  {
509  itd = alloc_ehci_iTD();
510  if (itd == NULL)
511  goto malloc_failed;
512 
513  if (itd_list == NULL) /* link all iTDs */
514  {
515  itd_list = itd;
516  }
517  else
518  {
519  itd->next = itd_list;
520  itd_list = itd;
521  }
522  }
523 
524  utr->td_cnt = itd_cnt;
525 
526  /*------------------------------------------------------------------------------------*/
527  /* Fill and link all iTDs */
528  /*------------------------------------------------------------------------------------*/
529 
530  utr->iso_sf = iso_ep->next_frame;
531  fidx = 0; /* index to UTR iso frmes (total IF_PER_UTR) */
532 
533  for (itd = itd_list; (itd != NULL); )
534  {
535  if (fidx >= IF_PER_UTR) /* unlikely */
536  {
537  USB_error("EHCI driver ITD bug!?\n");
538  goto malloc_failed;
539  }
540 
541  itd->utr = utr;
542  itd->fidx = fidx; /* index to UTR's n'th IF_PER_UTR frame */
543  itd->buff_base = (uint32_t)(utr->iso_buff[fidx]); /* iTD buffer base is buffer of the first UTR iso frame serviced by this iTD */
544  itd->trans_mask = trans_mask;
545 
546  write_itd_info(utr, itd);
547 
548  for (i = 0; i < 8; i++) /* settle xfer into micro-frames */
549  {
550  if (!(trans_mask & (0x1<<i)))
551  {
552  itd->Transaction[i] = 0; /* not accesed */
553  continue; /* not scheduled micro-frame */
554  }
555 
556  write_itd_micro_frame(utr, fidx, itd, i);
557 
558  fidx++; /* preceed to next UTR iso frame */
559 
560  if (fidx == IF_PER_UTR) /* is the last scheduled micro-frame? */
561  {
562  /* raise interrupt on completed */
563  itd->Transaction[i] |= ITD_IOC;
564  break;
565  }
566  }
567 
568  itd_next = itd->next; /* remember the next itd */
569 
570  // USB_debug("Link iTD 0x%x, %d\n", (int)itd, iso_ep->next_frame);
571  /*
572  * Link iTD to period frame list
573  */
574  DISABLE_EHCI_IRQ();
575  itd->sched_frnidx = iso_ep->next_frame; /* remember it for reclamation scan */
576  add_itd_to_iso_ep(iso_ep, itd); /* add to software itd list */
577  itd->Next_Link = _PFList[itd->sched_frnidx]; /* keep the next link */
578  _PFList[itd->sched_frnidx] = ITD_HLNK_ITD(itd);
579  iso_ep->next_frame = (iso_ep->next_frame + interval) % FL_SIZE;
580  ENABLE_EHCI_IRQ();
581 
582  itd = itd_next;
583  }
584 
585  _ehci->UCMDR |= HSUSBH_UCMDR_PSEN_Msk; /* periodic list enable */
586  return 0;
587 
588 malloc_failed:
589 
590  while (itd_list != NULL)
591  {
592  itd = itd_list;
593  itd_list = itd->next;
594  free_ehci_iTD(itd);
595  }
596  return USBH_ERR_MEMORY_OUT;
597 }
598 
599 static __inline void add_sitd_to_iso_ep(ISO_EP_T *iso_ep, siTD_T *sitd)
600 {
601  siTD_T *p;
602 
603  sitd->next = NULL;
604 
605  if (iso_ep->sitd_list == NULL)
606  {
607  iso_ep->sitd_list = sitd;
608  return;
609  }
610 
611  /*
612  * Find the tail entry of iso_ep->itd_list
613  */
614  p = iso_ep->sitd_list;
615  while (p->next != NULL)
616  {
617  p = p->next;
618  }
619  p->next = sitd;
620 }
621 
622 static void write_sitd_info(UTR_T *utr, siTD_T *sitd)
623 {
624  UDEV_T *udev = utr->udev;
625  EP_INFO_T *ep = utr->ep; /* reference to isochronous endpoint */
626  uint32_t buff_page_addr;
627  int xlen = utr->iso_xlen[sitd->fidx];
628  int scnt;
629 
630  sitd->Chrst = (udev->port_num << SITD_PORT_NUM_Pos) |
631  (udev->parent->iface->udev->dev_num << SITD_HUB_ADDR_Pos) |
632  ((ep->bEndpointAddress & 0xF) << SITD_EP_NUM_Pos) |
633  (udev->dev_num << SITD_DEV_ADDR_Pos);
634 
635  buff_page_addr = ((uint32_t)utr->iso_buff[sitd->fidx]) & 0xFFFFF000;
636  sitd->Bptr[0] = (uint32_t)(utr->iso_buff[sitd->fidx]);
637  sitd->Bptr[1] = buff_page_addr + 0x1000;
638 
639  scnt = (xlen + 187) / 188;
640 
641  if ((ep->bEndpointAddress & EP_ADDR_DIR_MASK) == EP_ADDR_DIR_IN) /* I/O */
642  {
643  sitd->Chrst |= SITD_XFER_IN;
644  sitd->Sched = (1 << (scnt + 2)) - 1;
645  sitd->Sched = (sitd->Sched << 10) | 0x1;
646  //sitd->Sched <<= 1;
647  }
648  else
649  {
650  sitd->Chrst |= SITD_XFER_OUT;
651  sitd->Sched = sitd_OUT_Smask[scnt-1];
652  if (scnt > 1)
653  {
654  sitd->Bptr[1] |= (0x1 << 3); /* Transaction position (TP) 01b: Begin */
655  }
656  sitd->Bptr[1] |= scnt; /* Transaction count (T-Count) */
657  }
658 
659  if (sitd->fidx == IF_PER_UTR)
660  {
661  sitd->Sched |= SITD_IOC;
662  }
663 
664  sitd->StsCtrl = (xlen << SITD_XFER_CNT_Pos) | SITD_STATUS_ACTIVE;
665 
666  sitd->BackLink = SITD_LIST_END;
667 }
668 
669 
670 static void ehci_sitd_adjust_schedule(siTD_T *sitd)
671 {
672  siTD_T *hlink = (siTD_T *)_PFList[sitd->sched_frnidx];
673  uint32_t uframe_mask = 0x00;
674 
675  while (hlink && !HLINK_IS_TERMINATED(hlink) && HLINK_IS_SITD(hlink))
676  {
677  hlink = SITD_PTR(hlink);
678  if (hlink != sitd)
679  {
680  if ((hlink->Chrst & SITD_XFER_IO_Msk) == SITD_XFER_IN)
681  {
682  uframe_mask |= (hlink->Sched & 0xFF); /* mark micro-frames used by IN S-mask */
683  uframe_mask |= ((hlink->Sched >> 8) & 0xFF); /* mark micro-frames used by IN C-mask */
684  }
685  else
686  {
687  uframe_mask |= (hlink->Sched & 0xFF); /* mark micro-frames used by OUT S-mask */
688  }
689  }
690  hlink = SITD_PTR(hlink->Next_Link);
691  }
692 
693  uframe_mask = uframe_mask | (uframe_mask << 8); /* mark both S-mask and C-mask */
694 
695  if (uframe_mask)
696  {
697  /*
698  * Shift afterward one micro-frame until no conflicts.
699  */
700  while (1)
701  {
702  if (sitd->Sched & uframe_mask)
703  {
704  sitd->Sched = (sitd->Sched & 0xFFFF0000) | ((sitd->Sched << 1) & 0xFFFF);
705  }
706  else
707  {
708  break; /* no conflit, done. */
709  }
710  }
711  }
712 }
713 
714 
715 static int ehci_iso_split_xfer(UTR_T *utr, ISO_EP_T *iso_ep)
716 {
717  EP_INFO_T *ep = utr->ep; /* reference to isochronous endpoint */
718  siTD_T *sitd, *sitd_next, *sitd_list = NULL;
719  int i;
720  int fidx; /* index to the 8 iso frames of UTR */
721 
722  if (utr->udev->parent == NULL)
723  {
724  USB_error("siso xfer - parent lost!\n");
725  return USBH_ERR_INVALID_PARAM;
726  }
727 
728  /*------------------------------------------------------------------------------------*/
729  /* Allocate siTDs */
730  /*------------------------------------------------------------------------------------*/
731  for (i = 0; i < IF_PER_UTR; i++) /* allocate all siTDs required by UTR */
732  {
733  sitd = alloc_ehci_siTD();
734  if (sitd == NULL)
735  goto malloc_failed;
736 
737  if (sitd_list == NULL) /* link all siTDs */
738  {
739  sitd_list = sitd;
740  }
741  else
742  {
743  sitd->next = sitd_list;
744  sitd_list = sitd;
745  }
746  }
747 
748  utr->td_cnt = IF_PER_UTR;
749 
750  /*------------------------------------------------------------------------------------*/
751  /* Fill and link all siTDs */
752  /*------------------------------------------------------------------------------------*/
753 
754  utr->iso_sf = iso_ep->next_frame;
755  fidx = 0; /* index to UTR iso frmes (total IF_PER_UTR) */
756 
757  for (sitd = sitd_list; (sitd != NULL); fidx++)
758  {
759  if (fidx >= IF_PER_UTR) /* unlikely */
760  {
761  USB_error("EHCI driver siTD bug!?\n");
762  goto malloc_failed;
763  }
764 
765  sitd->utr = utr;
766  sitd->fidx = fidx; /* index to UTR's n'th IF_PER_UTR frame */
767 
768  write_sitd_info(utr, sitd);
769 
770  sitd_next = sitd->next; /* remember the next itd */
771 
772  // USB_debug("Link iTD 0x%x, %d\n", (int)itd, iso_ep->next_frame);
773  /*
774  * Link iTD to period frame list
775  */
776  sitd->sched_frnidx = iso_ep->next_frame; /* remember it for reclamation scan */
777  DISABLE_EHCI_IRQ();
778  ehci_sitd_adjust_schedule(sitd);
779  add_sitd_to_iso_ep(iso_ep, sitd); /* add to software itd list */
780  sitd->Next_Link = _PFList[sitd->sched_frnidx];/* keep the next link */
781  _PFList[sitd->sched_frnidx] = SITD_HLNK_SITD(sitd);
782  iso_ep->next_frame = (iso_ep->next_frame + ep->bInterval) % FL_SIZE;
783  ENABLE_EHCI_IRQ();
784 
785  sitd = sitd_next;
786  }
787 
788  _ehci->UCMDR |= HSUSBH_UCMDR_PSEN_Msk; /* periodic list enable */
789  return 0;
790 
791 malloc_failed:
792 
793  while (sitd_list != NULL)
794  {
795  sitd = sitd_list;
796  sitd_list = sitd->next;
797  free_ehci_siTD(sitd);
798  }
799  return USBH_ERR_MEMORY_OUT;
800 }
801 
802 /*
803  * If it's an isochronous endpoint, quit current transfer via UTR or hardware EP.
804  */
805 int ehci_quit_iso_xfer(UTR_T *utr, EP_INFO_T *ep)
806 {
807  ISO_EP_T *iso_ep;
808  iTD_T *itd, *itd_next, *p;
809  uint32_t frnidx;
810  uint32_t now_frame;
811 
812  if (ep == NULL)
813  {
814  if (utr == NULL)
815  return USBH_ERR_NOT_FOUND;
816 
817  if (utr->ep == NULL)
818  return USBH_ERR_NOT_FOUND;
819 
820  ep = utr->ep;
821  }
822 
823  if ((ep->bmAttributes & EP_ATTR_TT_MASK) != EP_ATTR_TT_ISO)
824  return USBH_ERR_NOT_FOUND; /* not isochronous endpoint */
825 
826  /*------------------------------------------------------------------------------------*/
827  /* It's an iso endpoint. Remove it as required. */
828  /*------------------------------------------------------------------------------------*/
829  iso_ep = iso_ep_list;
830  while (iso_ep != NULL) /* Search all activated iso endpoints */
831  {
832  if (iso_ep->ep == ep)
833  break;
834  iso_ep = iso_ep->next;
835  }
836  if (iso_ep == NULL)
837  return 0; /* should have been removed */
838 
839  itd = iso_ep->itd_list; /* get the first iTD from iso_ep's iTD list */
840 
841  while (itd != NULL) /* traverse all iTDs of itd list */
842  {
843  itd_next = itd->next; /* remember the next iTD */
844  utr = itd->utr;
845 
846  /*--------------------------------------------------------------------------------*/
847  /* Remove this iTD from period frame list */
848  /*--------------------------------------------------------------------------------*/
849  frnidx = itd->sched_frnidx;
850 
851  /*
852  * Prevent to race with Host Controller. If the iTD to be removed is located in
853  * current or next frame, wait until HC passed through it.
854  */
855  while (1)
856  {
857  now_frame = (_ehci->UFINDR >> 3) & 0x3FF;
858  if ((now_frame == frnidx) || (((now_frame+1)%1024) == frnidx))
859  continue;
860  break;
861  }
862 
863  if (_PFList[frnidx] == ITD_HLNK_ITD(itd))
864  {
865  /* is the first entry, just change to next */
866  _PFList[frnidx] = itd->Next_Link;
867  }
868  else
869  {
870  p = ITD_PTR(_PFList[frnidx]); /* find the preceding iTD */
871  while ((ITD_PTR(p->Next_Link) != itd) && (p != NULL))
872  {
873  p = ITD_PTR(p->Next_Link);
874  }
875 
876  if (p == NULL) /* link list out of control! */
877  {
878  USB_error("ehci_quit_iso_xfer - An iTD lost reference to periodic frame list! 0x%x on %d\n", (int)itd, frnidx);
879  }
880  else /* remove iTD from list */
881  {
882  p->Next_Link = itd->Next_Link;
883  }
884  }
885 
886  utr->td_cnt--;
887 
888  if (utr->td_cnt == 0) /* All iTD of this UTR done */
889  {
890  utr->bIsTransferDone = 1;
891  if (utr->func)
892  utr->func(utr);
893  utr->status = USBH_ERR_ABORT;
894  }
895  free_ehci_iTD(itd);
896  itd = itd_next;
897  }
898 
899  /*
900  * Remove iso_ep from iso_ep_list
901  */
902  remove_iso_ep_from_list(iso_ep);
903  usbh_free_mem(iso_ep, sizeof(*iso_ep)); /* free this iso_ep */
904  ep->hw_pipe = NULL;
905 
906  if (iso_ep_list == NULL)
907  _ehci->UCMDR &= ~HSUSBH_UCMDR_PSEN_Msk;
908 
909  return 0;
910 }
911 
912 
914 
915 /*** (C) COPYRIGHT 2017 Nuvoton Technology Corp. ***/
USBH_ERR_BABBLE_DETECTED
#define USBH_ERR_BABBLE_DETECTED
Definition: usbh_lib.h:53
USBH_ERR_TRANSACTION
#define USBH_ERR_TRANSACTION
Definition: usbh_lib.h:52
USBH_ERR_NOT_FOUND
#define USBH_ERR_NOT_FOUND
Definition: usbh_lib.h:39
USBH_ERR_INVALID_PARAM
#define USBH_ERR_INVALID_PARAM
Definition: usbh_lib.h:38
HSUSBH_UFINDR_FI_Msk
#define HSUSBH_UFINDR_FI_Msk
Definition: hsusbh_reg.h:1095
USBH_ERR_DATA_BUFF
#define USBH_ERR_DATA_BUFF
Definition: usbh_lib.h:54
USBH_ERR_TRANSFER
#define USBH_ERR_TRANSFER
Definition: usbh_lib.h:45
NuMicro.h
NuMicro peripheral access layer header file.
USBH_ERR_NOT_ACCESS0
#define USBH_ERR_NOT_ACCESS0
Definition: usbh_lib.h:68
hub.h
USB Host hub class driver header file.
HSUSBH_UCMDR_PSEN_Msk
#define HSUSBH_UCMDR_PSEN_Msk
Definition: hsusbh_reg.h:1035
USBH_ERR_ABORT
#define USBH_ERR_ABORT
Definition: usbh_lib.h:47
USBH_ERR_MEMORY_OUT
#define USBH_ERR_MEMORY_OUT
Definition: usbh_lib.h:32
uac_dev_t::udev
UDEV_T * udev
Definition: usbh_uac.h:111
usb.h
USB Host library header file.
NULL
#define NULL
NULL pointer.
Definition: M480.h:604
Generated on Wed Oct 7 2020 09:26:14 for M480 BSP by   doxygen 1.8.15