请教USB子系统EHCI控制器驱动关于同步端点调度的问题

myspace21

最近在看EHCI控制器驱动，看到iso_stream_schedule这个函数的时候就看不懂了，在网上也找不到相关的资料，不知道有哪位大神研究过这个函数的实现原理？哎，好多天了，还没想明白，请各位赐教，多谢了！！

myspace21

贴上源代码：

1. 
   
2. /*
   
3. * This scheduler plans almost as far into the future as it has actual
   
4. * periodic schedule slots.  (Affected by TUNE_FLS, which defaults to
   
5. * "as small as possible" to be cache-friendlier.)  That limits the size
   
6. * transfers you can stream reliably; avoid more than 64 msec per urb.
   
7. * Also avoid queue depths of less than ehci's worst irq latency (affected
   
8. * by the per-urb URB_NO_INTERRUPT hint, the log2_irq_thresh module parameter,
   
9. * and other factors); or more than about 230 msec total (for portability,
   
10. * given EHCI_TUNE_FLS and the slop).  Or, write a smarter scheduler!
    
11. */
    
12. 
    
13. static int
    
14. iso_stream_schedule (
    
15.         struct ehci_hcd                *ehci,
    
16.         struct urb                *urb,
    
17.         struct ehci_iso_stream        *stream
    
18. )
    
19. {
    
20.         u32                        now, base, next, start, period, span, now2;
    
21.         u32                        wrap = 0, skip = 0;
    
22.         int                        status = 0;
    
23.         unsigned                mod = ehci->periodic_size << 3;        /* ehci->periodic_size can be 1024/512/256 */
    
24.         struct ehci_iso_sched        *sched = urb->hcpriv;
    
25.         bool                        empty = list_empty(&stream->td_list);
    
26.         bool                        new_stream = false;
    
27. 
    
28.         period = stream->uperiod;        /* urb->interval */
    
29.         span = sched->span;        /* urb->number_of_packets * (urb->interval >> 3) */
    
30.         if (!stream->highspeed)
    
31.                 span <<= 3;
    
32. 
    
33.         /* Start a new isochronous stream? */
    
34.         if (unlikely(empty && !hcd_periodic_completion_in_progress(
    
35.                         ehci_to_hcd(ehci), urb->ep))) {
    
36. 
    
37.                 /* Schedule the endpoint */
    
38.                 if (stream->ps.phase == NO_FRAME) {
    
39.                         int                done = 0;
    
40.                         struct ehci_tt        *tt = find_tt(stream->ps.udev);/* check where we attach */
    
41. 
    
42.                         if (IS_ERR(tt)) {
    
43.                                 status = PTR_ERR(tt);
    
44.                                 goto fail;
    
45.                         }
    
46.                         compute_tt_budget(ehci->tt_budget, tt);
    
47. 
    
48.                         start = ((-(++ehci->random_frame)) << 3) & (period - 1);
    
49. 
    
50.                         /* find a uframe slot with enough bandwidth.
    
51.                          * Early uframes are more precious because full-speed
    
52.                          * iso IN transfers can't use late uframes,
    
53.                          * and therefore they should be allocated last.
    
54.                          */
    
55.                         next = start;
    
56.                         start += period;
    
57.                         do {
    
58.                                 start--;
    
59.                                 /* check schedule: enough space? */
    
60.                                 if (stream->highspeed) {
    
61.                                         if (itd_slot_ok(ehci, stream, start))
    
62.                                                 done = 1;
    
63.                                 } else {
    
64.                                         if ((start % 8) >= 6)
    
65.                                                 continue;
    
66.                                         if (sitd_slot_ok(ehci, stream, start,
    
67.                                                         sched, tt))
    
68.                                                 done = 1;
    
69.                                 }
    
70.                         } while (start > next && !done);
    
71. 
    
72.                         /* no room in the schedule */
    
73.                         if (!done) {
    
74.                                 ehci_dbg(ehci, "iso sched full %p", urb);
    
75.                                 status = -ENOSPC;
    
76.                                 goto fail;
    
77.                         }
    
78.                         stream->ps.phase = (start >> 3) &
    
79.                                         (stream->ps.period - 1);
    
80.                         stream->ps.bw_phase = stream->ps.phase &
    
81.                                         (stream->ps.bw_period - 1);
    
82.                         stream->ps.phase_uf = start & 7;
    
83.                         reserve_release_iso_bandwidth(ehci, stream, 1);
    
84.                 }
    
85. 
    
86.                 /* New stream is already scheduled; use the upcoming slot */
    
87.                 else {
    
88.                         start = (stream->ps.phase << 3) + stream->ps.phase_uf;
    
89.                 }
    
90. 
    
91.                 stream->next_uframe = start;
    
92.                 new_stream = true;
    
93.         }
    
94. 
    
95.         now = ehci_read_frame_index(ehci) & (mod - 1);
    
96. 
    
97.         /* Take the isochronous scheduling threshold into account */
    
98.         if (ehci->i_thresh)
    
99.                 next = now + ehci->i_thresh;        /* uframe cache */
    
100.         else
     
101.                 next = (now + 2 + 7) & ~0x07;        /* full frame cache */
     
102. 
     
103.         /*
     
104.          * Use ehci->last_iso_frame as the base.  There can't be any
     
105.          * TDs scheduled for earlier than that.
     
106.          */
     
107.         base = ehci->last_iso_frame << 3;
     
108.         next = (next - base) & (mod - 1);
     
109.         start = (stream->next_uframe - base) & (mod - 1);
     
110. 
     
111.         if (unlikely(new_stream))
     
112.                 goto do_ASAP;
     
113. 
     
114.         /*
     
115.          * Typical case: reuse current schedule, stream may still be active.
     
116.          * Hopefully there are no gaps from the host falling behind
     
117.          * (irq delays etc).  If there are, the behavior depends on
     
118.          * whether URB_ISO_ASAP is set.
     
119.          */
     
120.         now2 = (now - base) & (mod - 1);
     
121. 
     
122.         /* Is the schedule already full? */
     
123.         if (unlikely(!empty && start < period)) {
     
124.                 ehci_dbg(ehci, "iso sched full %p (%u-%u < %u mod %u)\n",
     
125.                                 urb, stream->next_uframe, base, period, mod);
     
126.                 status = -ENOSPC;
     
127.                 goto fail;
     
128.         }
     
129. 
     
130.         /* Is the next packet scheduled after the base time? */
     
131.         if (likely(!empty || start <= now2 + period)) {
     
132. 
     
133.                 /* URB_ISO_ASAP: make sure that start >= next */
     
134.                 if (unlikely(start < next &&
     
135.                                 (urb->transfer_flags & URB_ISO_ASAP)))
     
136.                         goto do_ASAP;
     
137. 
     
138.                 /* Otherwise use start, if it's not in the past */
     
139.                 if (likely(start >= now2))
     
140.                         goto use_start;
     
141. 
     
142.         /* Otherwise we got an underrun while the queue was empty */
     
143.         } else {
     
144.                 if (urb->transfer_flags & URB_ISO_ASAP)
     
145.                         goto do_ASAP;
     
146.                 wrap = mod;
     
147.                 now2 += mod;
     
148.         }
     
149. 
     
150.         /* How many uframes and packets do we need to skip? */
     
151.         skip = (now2 - start + period - 1) & -period;
     
152.         if (skip >= span) {                /* Entirely in the past? */
     
153.                 ehci_dbg(ehci, "iso underrun %p (%u+%u < %u) [%u]\n",
     
154.                                 urb, start + base, span - period, now2 + base,
     
155.                                 base);
     
156. 
     
157.                 /* Try to keep the last TD intact for scanning later */
     
158.                 skip = span - period;
     
159. 
     
160.                 /* Will it come before the current scan position? */
     
161.                 if (empty) {
     
162.                         skip = span;        /* Skip the entire URB */
     
163.                         status = 1;        /* and give it back immediately */
     
164.                         iso_sched_free(stream, sched);
     
165.                         sched = NULL;
     
166.                 }
     
167.         }
     
168.         urb->error_count = skip / period;
     
169.         if (sched)
     
170.                 sched->first_packet = urb->error_count;
     
171.         goto use_start;
     
172. 
     
173. do_ASAP:
     
174.         /* Use the first slot after "next" */
     
175.         start = next + ((start - next) & (period - 1));
     
176. 
     
177. use_start:
     
178.         /* Tried to schedule too far into the future? */
     
179.         if (unlikely(start + span - period >= mod + wrap)) {
     
180.                 ehci_dbg(ehci, "request %p would overflow (%u+%u >= %u)\n",
     
181.                                 urb, start, span - period, mod + wrap);
     
182.                 status = -EFBIG;
     
183.                 goto fail;
     
184.         }
     
185. 
     
186.         start += base;
     
187.         stream->next_uframe = (start + skip) & (mod - 1);
     
188. 
     
189.         /* report high speed start in uframes; full speed, in frames */
     
190.         urb->start_frame = start & (mod - 1);
     
191.         if (!stream->highspeed)
     
192.                 urb->start_frame >>= 3;
     
193. 
     
194.         /* Make sure scan_isoc() sees these */
     
195.         if (ehci->isoc_count == 0)
     
196.                 ehci->last_iso_frame = now >> 3;
     
197.         return status;
     
198. 
     
199. fail:
     
200.         iso_sched_free(stream, sched);
     
201.         urb->hcpriv = NULL;
     
202.         return status;
     
203. }

复制代码

myspace21

顶一下，哪位大神研习过？