fzct2008
fzct2008

linux usb ehci controller driver

目录(?)[-]

  1. 1 数据结构
    1. 11 queue element transfer descriptorqtd
    2. 12 queue head 结构qh
    3. 13 itd结构
    4. 4 sitd结构
    5. 5 周期调度队列 vs 异步调度队列
  2. 2 操作模型
    1. 21 echi control对异步调度队列的处理过程
    2. 22 echi control对异步调度中的QH的删除算法摘自ehci spec 482
    3. 23 echi的ehci_urb_enqueue过程
      1. 231 for usb bulkcontrol transfrer urb enqueue过程
      2. 232 for PIPE_INTERRUPT urb enqueue过程包括高速中断传输和分裂中断传输
      3. 233 for PIPE_ISOCHRONOUS urb enqueue过程包括高速同步和分裂同步传输
    5. 24 分裂传输过程
      1. 241  同步分裂传输的过程
      2. 242  控制中断分裂传输的过程
      3. 243 分裂传输时的H frame与B frame
    6. 25 urb的重要成员域
  3. 3 参考资料

1 数据结构

这里描述的所有结构的第一个word的结构都是相同的：Next Link Pointer + Type+T,即都是由指向下个结构体的物理地址+结构体类型指示+Terminate来构成。 这样构成有个好处，用c++的基类和派生类来类比非常贴切，这里的第一个word就相当于基类，而这些结构体的其余部分就相当于不同的派生类（在这里就是qtd，itd，qh，sitd...）。诚如c++那样操作，可以不管这些派生类的区别，而直接操作它的基类(Word0)，如果需要，可由基类中的Type类型，从基类转成对应类型的派生类:即可以根据word0中的Type字段，来判断所指向的结构体是qtd、itd、qh、sitd中的哪一个。

1.1 queue element transfer descriptor(qtd)

用于intr、bulk、control传输类型向hc描述要传输的数据，即包含如下信息：hc从哪里取数据（C_Page,Current Offset,Buffer Pointer）,取多长的数据（Total Bytes to Transfer）,传输的状态和结果信息（status）,传输完成后是否产生中断（ioc）,使用何令牌包来发起数据传输（PID Code: IN OUT SETUP...）
linux usb ehci controller driver_第1张图片

该结构在linux ehcd驱动中的表示：

[cpp]  view plain  copy
 
 
  1. /* 
  2.  * EHCI Specification 0.95 Section 3.5 
  3.  * QTD: describe data transfer components (buffer, direction, ...) 
  4.  * See Fig 3-6 "Queue Element Transfer Descriptor Block Diagram". 
  5.  * 
  6.  * These are associated only with "QH" (Queue Head) structures, 
  7.  * used with control, bulk, and interrupt transfers. 
  8.  */  
  9. struct ehci_qtd {  
  10.     /* first part defined by EHCI spec */  
  11.     __hc32          hw_next;    /* see EHCI 3.5.1 */  
  12.     __hc32          hw_alt_next;    /* see EHCI 3.5.2 */  
  13.     __hc32          hw_token;       /* see EHCI 3.5.3 */  
  14. #define QTD_TOGGLE  (1 << 31) /* data toggle */  
  15. #define QTD_LENGTH(tok) (((tok)>>16) & 0x7fff)  
  16. #define QTD_IOC     (1 << 15) /* interrupt on complete */  
  17. #define QTD_CERR(tok)   (((tok)>>10) & 0x3)  
  18. #define QTD_PID(tok)    (((tok)>>8) & 0x3)  
  19. #define QTD_STS_ACTIVE  (1 << 7)  /* HC may execute this */  
  20. #define QTD_STS_HALT    (1 << 6)  /* halted on error */  
  21. #define QTD_STS_DBE (1 << 5)  /* data buffer error (in HC) */  
  22. #define QTD_STS_BABBLE  (1 << 4)  /* device was babbling (qtd halted) */  
  23. #define QTD_STS_XACT    (1 << 3)  /* device gave illegal response */  
  24. #define QTD_STS_MMF (1 << 2)  /* incomplete split transaction */  
  25. #define QTD_STS_STS (1 << 1)  /* split transaction state */  
  26. #define QTD_STS_PING    (1 << 0)  /* issue PING? */  
  27.   
  28. #define ACTIVE_BIT(ehci)    cpu_to_hc32(ehci, QTD_STS_ACTIVE)  
  29. #define HALT_BIT(ehci)      cpu_to_hc32(ehci, QTD_STS_HALT)  
  30. #define STATUS_BIT(ehci)    cpu_to_hc32(ehci, QTD_STS_STS)  
  31.   
  32.     __hc32          hw_buf [5];        /* see EHCI 3.5.4 */  
  33.     __hc32          hw_buf_hi [5];        /* Appendix B */  
  34.   
  35.     /* the rest is HCD-private */  
  36.     dma_addr_t      qtd_dma;        /* qtd address */  
  37.     struct list_head    qtd_list;       /* sw qtd list */  
  38.     struct urb      *urb;           /* qtd's urb */  
  39.     size_t          length;         /* length of buffer */  
  40. } __attribute__ ((aligned (32)));  
该结构是数据传输组件，通过qtd->qtd_list成员挂在qh队列头下面。

1.2 queue head 结构(qh)

一个queue head结构对应一个端点，所以queue head结构中的word1和word2字都是包含些跟端点相关的静态信息：最大包长度（Maximum Packet Length），hub地址(Hub Addr)，hub port号(Port Number)，设备地址(Device Address)，端口号(EndPt)，端口速度（EPS）,是否是控制端点（C），RL（Nakcount的初值），data toggle 控制位（dtc）,倍乘器（Mult）.另外qh是组织成一个循环队列的，而为了hc能够区分在遍历完当前循环队列一圈后，是否有事务传输发生，需要一个队列头，由于是循环队列，所以里每个qh都可以作为队列头，所以需要一个标志位H，用来指是当前哪个QH用来做该循环队列的头。
uFrame C-mask用于指是在哪几个微帧（1<=uframe<=8）会有complete split transsiton,该字段仅对全速中断的分裂传输由效，其他情况下，应该都是0。
uFrame S-mask用于指示在哪几个微帧（1<=uframe<=8）发起中断传输（针对高速的中断端点）或者发起start split传输（针对全速、低速的中断端点）。 
黄色标识的区域是overlay area， 即跟qtd交叠区域，所以里面包含的内容基本跟qtd都相同
queue head结构用来管理用于中断、bulk、control传输的数据。而对于中断传输，qh是挂在周期调度列表中的， 而对于bulk、control传输，qh是挂在异步循环调度列表中。
linux usb ehci controller driver_第2张图片

该结构在linux ehcd驱动中的表示：

[cpp]  view plain  copy
 
 
  1. /* 
  2.  * EHCI Specification 0.95 Section 3.6 
  3.  * QH: describes control/bulk/interrupt endpoints 
  4.  * See Fig 3-7 "Queue Head Structure Layout". 
  5.  * 
  6.  * These appear in both the async and (for interrupt) periodic schedules. 
  7.  */  
  8.   
  9. /* first part defined by EHCI spec */  
  10. struct ehci_qh_hw {  
  11.     __hc32          hw_next;    /* see EHCI 3.6.1 */  
  12.     __hc32          hw_info1;       /* see EHCI 3.6.2 */  
  13. #define QH_HEAD     0x00008000  
  14.     __hc32          hw_info2;        /* see EHCI 3.6.2 */  
  15. #define QH_SMASK    0x000000ff  
  16. #define QH_CMASK    0x0000ff00  
  17. #define QH_HUBADDR  0x007f0000  
  18. #define QH_HUBPORT  0x3f800000  
  19. #define QH_MULT     0xc0000000  
  20.     __hc32          hw_current; /* qtd list - see EHCI 3.6.4 */  
  21.   
  22.     /* qtd overlay (hardware parts of a struct ehci_qtd) */  
  23.     __hc32          hw_qtd_next;  
  24.     __hc32          hw_alt_next;  
  25.     __hc32          hw_token;  
  26.     __hc32          hw_buf [5];  
  27.     __hc32          hw_buf_hi [5];  
  28. } __attribute__ ((aligned(32)));  
实际在程序中，是使用的struct ehci_qh结构体，它跟struct ehci_qh_hw *hw的关系就是：struct ehci_qh结构体的开头部分存储的就是指向struct ehci_qh_hw *hw结构的指针，struct ehci_qh_hw结构是供hc来使用的，而struct ehci_qh结构则供我们的hcd来维护和管理这样的结构的。

1.3 itd结构

word1到word8，表示8个transaction，用于描述同步传输，连入对应的周期列表（periodic list），周期列表含有1024个表项（items），而每个item表示1 ms的时间内usb所进行的周期传输；而对于高速设备，1ms的frame又被分为8个微帧uframe，所以每个微帧对应的时间是125us。如下的8个transaction就各自对应一个微帧uframe的传输。具体到每个微帧字段的含义：
  • status 是由hc在transaction（事务）完成后，自动填充，表示传输的结果
  • Transaction Length，表示该transaction的数据长度
  • ioc表示该transaction完成后，是否产生中断
  • PG用于选择下面的哪个buffer Pointer(指向一个虚拟页面，所以低12位都是0，所以低12位可用作其他用途)
  • Transaction offset表示页内的偏移量
另外itd结构就是表示一个同步端点在periodic list的某个表项（item，对应一个大帧frame）中所要进行的传输，而在这个大帧中，可能还包含了其他同步端点所对应的itd结构，并且还可能包含中断端点的qh结构。而同属于这个表项（）的所有端点的传输，他们都会通过各自结构体的第一个字段（word0）进行连接起来。这样就可以让hc对每个挂在这个列表上的qh，itd都是reachable的，诚如刚才所说，一个itd就表示一个同步端点在某个periodic list节点所需要进行的传输，所以需要在该结构体中包含端点的信息，以便于hc来执行相应的事务传输。即包含如下端点相关信息：endpt（端点号），device address（设备地址）， max package size（最大包长度）， mult（倍乘） , I/O（方向）等。

linux usb ehci controller driver_第3张图片

同步传输的带宽，由以下因素即可计算得出：  最大包长度（mmax package size）、每个微帧中传输的次数（multi）、帧间隔（interval），则就可以算出该高速同步端点对应所需要的带宽，计算代码如下：
[cpp]  view plain  copy
 
 
  1. maxp = usb_maxpacket(dev, pipe, !is_input);  
  2. unsigned multi = hb_mult(maxp);  
  3. maxp = max_packet(maxp)*multi//计算一次同步传输，所包含的最大包的长度  
  4. stream->usecs = HS_USECS_ISO (maxp);//由包长换算成带宽时间  
  5. //bandwidth = stream->usecs * 8;  
  6. //bandwidth /= interval;  


long usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount)函数的功能： 对于给定的usb总线速度（高速、全速、低速），给定传输类型（同步传输、中断传输）和给定传输长度，所需要占用多少总线时间（即带宽）。


Isochronous Transaction Descriptor (iTD) 在linux中的hcd驱动中对应的数据结构体为：struct ehci_itd

[cpp]  view plain  copy
  1. /* 
  2.  * EHCI Specification 0.95 Section 3.3 
  3.  * Fig 3-4 "Isochronous Transaction Descriptor (iTD)" 
  4.  * 
  5.  * Schedule records for high speed iso xfers 
  6.  */  
  7. struct ehci_itd {  
  8.     /* first part defined by EHCI spec */  
  9.     __hc32          hw_next;           /* see EHCI 3.3.1 */  
  10.     __hc32          hw_transaction [8]; /* see EHCI 3.3.2 */  
  11. #define EHCI_ISOC_ACTIVE        (1<<31)        /* activate transfer this slot */  
  12. #define EHCI_ISOC_BUF_ERR       (1<<30)        /* Data buffer error */  
  13. #define EHCI_ISOC_BABBLE        (1<<29)        /* babble detected */  
  14. #define EHCI_ISOC_XACTERR       (1<<28)        /* XactErr - transaction error */  
  15. #define EHCI_ITD_LENGTH(tok)    (((tok)>>16) & 0x0fff)  
  16. #define EHCI_ITD_IOC        (1 << 15) /* interrupt on complete */  
  17.   
  18. #define ITD_ACTIVE(ehci)    cpu_to_hc32(ehci, EHCI_ISOC_ACTIVE)  
  19.   
  20.     __hc32          hw_bufp [7];    /* see EHCI 3.3.3 */  
  21.     __hc32          hw_bufp_hi [7]; /* Appendix B */  
  22.   
  23.     /* the rest is HCD-private */  
  24.     dma_addr_t      itd_dma;    /* for this itd */  
  25.     union ehci_shadow   itd_next;   /* ptr to periodic q entry */  
  26.   
  27.     struct urb      *urb;  
  28.     struct ehci_iso_stream  *stream;    /* endpoint's queue */  
  29.     struct list_head    itd_list;   /* list of stream's itds */  
  30.   
  31.     /* any/all hw_transactions here may be used by that urb */  
  32.     unsigned        frame;      /* where scheduled */  
  33.     unsigned        pg;  
  34.     unsigned        index[8];   /* in urb->iso_frame_desc */  
  35. } __attribute__ ((aligned (32)));  
该结构的前半部分用于hc，后半部分用于hcd来管理这个结构。

1.4 sitd结构

通过带TT（transfer translator）功能的高速hub，可以在高速的ehci controller下挂上full/slow-speed的设备。其中该full/slow-speed的设备又分为中断/控制传输、同步传输。
TT 在 USB HUB 中主要负责从高速到全/低速传输事务的转发，完成速度的匹配。从传输的角度来说，主要就是完成分离事务传输（Split Transaction）。下图为 TT
的基本结构。 

linux usb ehci controller driver_第4张图片
和大部分速度匹配逻辑一样，TT 也采用 Buffer 的方 式 来 完 成 速 度 匹 配 。Buffer 的一端是一个高速Handler ，处理高速数据收发 ； 另 一 端 是 全 速 / 低 速Handler， 处理全速/低速数据的收发。针对传输类型的不同，TT 采用多个 Buffer 来缓存数据。中断传输的 Start-Split（S-Split）阶段和 Complete-Split（C-Split）阶段分别用一个 Buffer，批量传输和中断传输的 S-Split 和 C-Split 不分开存储，但是在一个 TT 中至少有 2 个用于批量传输和中断传输的 Buffer分离传输仅在 HOST 和 HUB 之间发生，对于设备全速/低速设备来说是透明的。一个USB HUB 可以有多个 TT，这在 USB 协议中是允许的按照处理方式的区别，TT 中的分离传输可以分为两类——周期分离传输和非周期分离传输。周期分离传输指的是同步分离传输和中断分离传输，非周期分离传输指的是批量分离传输和控制分离传输。
而针对同步分离传输，设计了一种的新的数据结构sitd来管理这种同步分裂传输。
该结构各字段的内容如下：
其中word0用于连接下一个itd或qh结构，word1用于描述该结构对应的端点信息，word2中c-mask表示在哪些微帧位置发起complete传输，s-mask表示在哪些位置发起start complete传输；word3表示传输长度和传输结构，word4、5表示传输对应的buffer地址。
linux usb ehci controller driver_第5张图片
在linux驱动中的结构表示：
[cpp]  view plain  copy
  1. /* 
  2.  * EHCI Specification 0.95 Section 3.4 
  3.  * siTD, aka split-transaction isochronous Transfer Descriptor 
  4.  *       ... describe full speed iso xfers through TT in hubs 
  5.  * see Figure 3-5 "Split-transaction Isochronous Transaction Descriptor (siTD) 
  6.  */  
  7. struct ehci_sitd {  
  8.     /* first part defined by EHCI spec */  
  9.     __hc32          hw_next;  
  10. /* uses bit field macros above - see EHCI 0.95 Table 3-8 */  
  11.     __hc32          hw_fullspeed_ep;    /* EHCI table 3-9 */  
  12.     __hc32          hw_uframe;      /* EHCI table 3-10 */  
  13.     __hc32          hw_results;     /* EHCI table 3-11 */  
  14. #define SITD_IOC    (1 << 31) /* interrupt on completion */  
  15. #define SITD_PAGE   (1 << 30) /* buffer 0/1 */  
  16. #define SITD_LENGTH(x)  (0x3ff & ((x)>>16))  
  17. #define SITD_STS_ACTIVE (1 << 7)  /* HC may execute this */  
  18. #define SITD_STS_ERR    (1 << 6)  /* error from TT */  
  19. #define SITD_STS_DBE    (1 << 5)  /* data buffer error (in HC) */  
  20. #define SITD_STS_BABBLE (1 << 4)  /* device was babbling */  
  21. #define SITD_STS_XACT   (1 << 3)  /* illegal IN response */  
  22. #define SITD_STS_MMF    (1 << 2)  /* incomplete split transaction */  
  23. #define SITD_STS_STS    (1 << 1)  /* split transaction state */  
  24.   
  25.   
  26. #define SITD_ACTIVE(ehci)   cpu_to_hc32(ehci, SITD_STS_ACTIVE)  
  27.   
  28.   
  29.     __hc32          hw_buf [2];     /* EHCI table 3-12 */  
  30.     __hc32          hw_backpointer;     /* EHCI table 3-13 */  
  31.     __hc32          hw_buf_hi [2];      /* Appendix B */  
  32.   
  33.   
  34.     /* the rest is HCD-private */  
  35.     dma_addr_t      sitd_dma;  
  36.     union ehci_shadow   sitd_next;  /* ptr to periodic q entry */  
  37.   
  38.   
  39.     struct urb      *urb;  
  40.     struct ehci_iso_stream  *stream;    /* endpoint's queue */  
  41.     struct list_head    sitd_list;  /* list of stream's sitds */  
  42.     unsigned        frame;  
  43.     unsigned        index;  
  44. } __attribute__ ((aligned (32)));  
该结构的开始部分是用于host controller来访问的，后面是hcd使用的，其中sitd_list 成员将该sitd结构连入到列表中。这样便于hcd来遍历这个列表（我们称为软件列表）。而该结构的hw_next则是用于连接硬件列表，是专供host controller来访问的。

1.5 周期调度队列 vs 异步调度队列

周期调度队列：
该周期调度帧列表，是传输数据接口（指qtd，qh，itd，sitd等）在内存中的组织结构，这个组织结构将被host controller自动访问。但需要软件（hcd driver）来初始化好，并动态维护他（往这个结构中添加传输数据接口（对应enqueue操作），删除传输数据接口（dequeue操作））
linux usb ehci controller driver_第6张图片
异步调度队列：
该结构用于管理和连接控制、块传输，该队列是单向循环队列，队列的节点就是qh，而每个qh描述一个端点的传输（可能是：高速/全速控制端点，高速/全速块端点），并且属于这个端点的所有待传数据都是通过qtd来描述，挂在qh节点对应的->qtd_list列表下。下图标有H的节点，则是这个循环调度队列的头节点。
linux usb ehci controller driver_第7张图片
需要注意的地方是，hw_next字段连接起来的都是硬件队列，而qtd/itd/sitd_list等成员连接起来的列表都是软件列表，他们有些其实就是同在一个结构体中。其中硬件队列是供host controller使用，软件队列是供hcd驱动来使用的。前者存储的是物理地址，后者存储的是虚拟地址。

2 操作模型

2.1 echi control对异步调度队列的处理过程

详细的请查看ehci规范的4.10节，这个描述的过程，就是host controller对qh、qtd结构的操作和管理过程。
linux usb ehci controller driver_第8张图片

2.2 echi control对异步调度中的QH的删除算法（摘自ehci spec 4.8.2）

下图摘自ehci spec的4.8.2小结，描述怎么删除正在被hc访问的队列中的节点的方法，核心就是要避免hc和hcd对这个队列的节点产生竞争性的访问。该算法会被用于dequeue过程。
linux usb ehci controller driver_第9张图片

2.3 echi的ehci_urb_enqueue过程

2.3.1 for usb bulk、control transfrer urb enqueue过程

linux usb ehci controller driver_第10张图片

/*
 * create a list of filled qtds for this URB; won't link into qh.
* URBs map to sequences of QTDs:  one logical transaction
 */
static struct list_head *qh_urb_transaction (struct ehci_hcd *ehci,struct urb *urb,struct list_head *head,gfp_t flags)
  1. 该函数将一个urb传输映射成若干个qtd结构，并把他们关联起来。他们的关联分为两部分
    1. 一个是将这若干个qtd按他们被执行的顺序，通过qtd->qtd_list域连接到head列表头中，该列表主要用于软件来访问这些qtd
    2. 一个是通过qtd->hw_next指针，将这些qtd连接起来，这个连接是给host constroller使用的，所以->hw_next里存的是物理地址
  2. 该函数根据urb->transfer_buffer_length的长度，来决定分配具体几个qtd，即一个qtd存不下所需传输的内容时，就调用ehci_qtd_alloc函数再分配一个qtd，然后再调用qtd_fill将剩余的数据的长度和buffer开始地址填充到qtd结构中。
  3. 该函数如果发现待传输的数据是控制传输，则为该控制传输，添加setup数据建立阶段所对应的qtd和状态阶段所对应的qtd
[cpp]  view plain  copy
 
 
  1. if (usb_pipecontrol (urb->pipe)) {//为控制的setup数据建立阶段，分配和填充qtd结构，并将它联入到head list列表头中  
  2.     /* SETUP pid */  
  3.     qtd_fill(ehci, qtd, urb->setup_dma,  
  4.             sizeof (struct usb_ctrlrequest),  
  5.             token | (2 /* "setup" */ << 8), 8);  
  6.   
  7.     /* ... and always at least one more pid */  
  8.     token ^= QTD_TOGGLE;  
  9.     qtd_prev = qtd;  
  10.     qtd = ehci_qtd_alloc (ehci, flags);  
  11.     if (unlikely (!qtd))  
  12.         goto cleanup;  
  13.     qtd->urb = urb;  
  14.     qtd_prev->hw_next = QTD_NEXT(ehci, qtd->qtd_dma);  
  15.     list_add_tail (&qtd->qtd_list, head);  
  16.   
  17.     /* for zero length DATA stages, STATUS is always IN */  
  18.     if (len == 0)  
  19.         token |= (1 /* "in" */ << 8);  
  20. }  

如下代码为控制传输的状态阶段和以短包表示结束（URB_ZERO_PACKET）的bulk out传输分配和初始化qtd结构，并连入head list列表中
[cpp]  view plain  copy
 
 
  1. if (one_more) {  
  2.     qtd_prev = qtd;  
  3.     qtd = ehci_qtd_alloc (ehci, flags);  
  4.     if (unlikely (!qtd))  
  5.         goto cleanup;  
  6.     qtd->urb = urb;  
  7.     qtd_prev->hw_next = QTD_NEXT(ehci, qtd->qtd_dma);  
  8.     list_add_tail (&qtd->qtd_list, head);  
  9.   
  10.     /* never any data in such packets */  
  11.     qtd_fill(ehci, qtd, 0, 0, token, 0);  
  12. }  


static struct ehci_qtd *ehci_qtd_alloc (struct ehci_hcd *ehci, gfp_t flags)
分配一个qtd结构

/* fill a qtd, returning how much of the buffer we were able to queue up */
static int qtd_fill(struct ehci_hcd *ehci, struct ehci_qtd *qtd, dma_addr_t buf, size_t len, int token, int maxpacket)
填充一个qtd结构，一个qtd结构最多可以存储16K to 20K的数据，如果urb包含的数据长度大于这个长度，则需要调用ehci_qtd_alloc 另外再分配一个qtd。


static int submit_async (struct ehci_hcd *ehci,struct urb *urb,struct list_head *qtd_list,gfp_t mem_flags)
 该函数将上面的qh_urb_transaction 初始化好的qtd列表链接到异步循环调度列表中。该函数将如下两个重要函数：qh_append_tds， qh_link_async 

/*
 * For control/bulk/interrupt, return QH with these TDs appended.
 * Allocates and initializes the QH if necessary.
 * Returns null if it can't allocate a QH it needs to.
 * If the QH has TDs (urbs) already, that's great.
 */
static struct ehci_qh *qh_append_tds (struct ehci_hcd *ehci,struct urb *urb,struct list_head *qtd_list,int epnum,void **ptr)
该函数的功能就是：将qtd_list添加对应的队列头上，如果没有对应的队列头，则分配初始化一个队列头。
[cpp]  view plain  copy
 
 
  1. static struct ehci_qh *qh_append_tds (  
  2.     struct ehci_hcd     *ehci,  
  3.     struct urb      *urb,  
  4.     struct list_head    *qtd_list,  
  5.     int         epnum,  
  6.     void            **ptr  
  7. )  
  8. {  
  9.     struct ehci_qh      *qh = NULL;  
  10.     __hc32          qh_addr_mask = cpu_to_hc32(ehci, 0x7f);  
  11.   
  12.     qh = (struct ehci_qh *) *ptr;  
  13.     if (unlikely (qh == NULL)) { //如果该端点还没有对应的qh队列头，则就调用qh_make函数分配一个QH队列头  
  14.         /* can't sleep here, we have ehci->lock... */  
  15.         qh = qh_make (ehci, urb, GFP_ATOMIC);  
  16.         *ptr = qh;  
  17.     }  
  18.     if (likely (qh != NULL)) {  
  19.         struct ehci_qtd *qtd;  
  20.   
  21.         if (unlikely (list_empty (qtd_list)))  
  22.             qtd = NULL;  
  23.         else  
  24.             qtd = list_entry (qtd_list->next, struct ehci_qtd,//获得列表节点所在的qtd结构  
  25.                     qtd_list);  
  26.   
  27.         /* control qh may need patching ... */  
  28.         if (unlikely (epnum == 0)) {  
  29.   
  30.                         /* usb_reset_device() briefly reverts to address 0 */  
  31.                         if (usb_pipedevice (urb->pipe) == 0)  
  32.                 qh->hw->hw_info1 &= ~qh_addr_mask;  
  33.         }  
  34.   
  35.         /* just one way to queue requests: swap with the dummy qtd. 
  36.          * only hc or qh_refresh() ever modify the overlay. 
  37.          */  
  38.         if (likely (qtd != NULL)) {  
  39.             struct ehci_qtd     *dummy;  
  40.             dma_addr_t      dma;  
  41.             __hc32          token;  
  42.   
  43.             /* to avoid racing the HC, use the dummy td instead of 
  44.              * the first td of our list (becomes new dummy).  both 
  45.              * tds stay deactivated until we're done, when the 
  46.              * HC is allowed to fetch the old dummy (4.10.2). 
  47.              */  
  48.             token = qtd->hw_token;  
  49.             qtd->hw_token = HALT_BIT(ehci);  
  50.   
  51.             dummy = qh->dummy;  
  52.   
  53.             dma = dummy->qtd_dma;  
  54.             *dummy = *qtd;  
  55.             dummy->qtd_dma = dma;  
  56.   
  57.             list_del (&qtd->qtd_list);//将qtd_list列表中的第一个元素删除，将dummy添加到这个位置，此时dummy->hw_next是指向qtd->hw_next的  
  58.             list_add (&dummy->qtd_list, qtd_list);  
  59.             list_splice_tail(qtd_list, &qh->qtd_list);//将带dummy的qtd list列表添加到qh->qtd_list列表的末尾  
  60.   
  61.             ehci_qtd_init(ehci, qtd, qtd->qtd_dma);  
  62.             qh->dummy = qtd;               //将qh->dummy指向原qtd list列表的第一个元素（已从list删除下来）  
  63.   
  64.             /* hc must see the new dummy at list end */  
  65.             dma = qtd->qtd_dma;  
  66.             qtd = list_entry (qh->qtd_list.prev,  
  67.                     struct ehci_qtd, qtd_list);//  
  68.             qtd->hw_next = QTD_NEXT(ehci, dma);//让qh->qtd_list列表的尾端链上这个新的dummy元素  
  69.   
  70.             /* let the hc process these next qtds */  
  71.             wmb ();  
  72.             dummy->hw_token = token;  
  73.   
  74.             urb->hcpriv = qh_get (qh);  
  75.         }  
  76.     }  
  77.     return qh;  
  78. }  

上面函数涉及的操作说明见如下图列表操作示意：（上半部分，是列表操作前的情况，下半部是列表操作后的情况，从下图可以看出qtd和dummy进行了互换）

linux usb ehci controller driver_第11张图片




/* move qh (and its qtds) onto async queue; maybe enable queue.  */
static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)
[cpp]  view plain  copy
 
 
  1. static void qh_link_async (struct ehci_hcd *ehci, struct ehci_qh *qh)  
  2. {  
  3.     __hc32      dma = QH_NEXT(ehci, qh->qh_dma);  
  4.     struct ehci_qh  *head;  
  5.   
  6.     /* Don't link a QH if there's a Clear-TT-Buffer pending */  
  7.     if (unlikely(qh->clearing_tt))  
  8.         return;  
  9.   
  10.     WARN_ON(qh->qh_state != QH_STATE_IDLE);  
  11.   
  12.     /* (re)start the async schedule? */  
  13.     head = ehci->async;//软件上的异步循环调度队列的头，并不是host controller所标识的队列头  
  14.     timer_action_done (ehci, TIMER_ASYNC_OFF);  
  15.     if (!head->qh_next.qh) {  
  16.         u32 cmd = ehci_readl(ehci, &ehci->regs->command);  
  17.   
  18.         if (!(cmd & CMD_ASE)) {//对cmd寄存器中的cmd_ase位的控制，并不是立即使能的，需要结合status寄存器来最终确定。  
  19.             /* in case a clear of CMD_ASE didn't take yet */  
  20.             (void)handshake(ehci, &ehci->regs->status,  
  21.                     STS_ASS, 0, 150);  
  22.             cmd |= CMD_ASE;  
  23.             ehci_writel(ehci, cmd, &ehci->regs->command);  
  24.             /* posted write need not be known to HC yet ... */  
  25.         }  
  26.     }  
  27.   
  28.     /* clear halt and/or toggle; and maybe recover from silicon quirk */  
  29.     qh_refresh(ehci, qh);  
  30.   
  31.     /* splice right after start */  
  32.     qh->qh_next = head->qh_next;  
  33.     qh->hw->hw_next = head->hw->hw_next;  
  34.     wmb ();  
  35.   
  36.     head->qh_next.qh = qh;  
  37.     head->hw->hw_next = dma;  
  38.   
  39.     qh_get(qh);  
  40.     qh->xacterrs = 0;  
  41.     qh->qh_state = QH_STATE_LINKED;  
  42.     /* qtd completions reported later by interrupt */  
  43. }  
上述函数功能是将qh添加到异步循环调度队列中，必要时使能该异步调度使能位。上述操作见下面的示意图（注意每个QH对应一个端点的传输）：
linux usb ehci controller driver_第12张图片

2.3.2 for PIPE_INTERRUPT urb enqueue过程（包括高速中断传输和分裂中断传输）

中断的分裂IN传输过程：
linux usb ehci controller driver_第13张图片

中断的分裂OUT传输过程：
linux usb ehci controller driver_第14张图片

分裂传输时的frame和microframe的时隙关系

linux usb ehci controller driver_第15张图片
中断传输的enqueue过程的流程图：
linux usb ehci controller driver_第16张图片

该函数的功能：将urb中断传输对应的qtd列表连入到对应的时隙中。
[cpp]  view plain  copy
 
 
  1. static int intr_submit (  
  2.     struct ehci_hcd     *ehci,  
  3.     struct urb      *urb,  
  4.     struct list_head    *qtd_list,  
  5.     gfp_t           mem_flags  
  6. ) {  
  7.     unsigned        epnum;  
  8.     unsigned long       flags;  
  9.     struct ehci_qh      *qh;  
  10.     int         status;  
  11.     struct list_head    empty;  
  12.   
  13.     /* get endpoint and transfer/schedule data */  
  14.     epnum = urb->ep->desc.bEndpointAddress;  
  15.   
  16.     spin_lock_irqsave (&ehci->lock, flags);  
  17.   
  18.     if (unlikely(!HCD_HW_ACCESSIBLE(ehci_to_hcd(ehci)))) {  
  19.         status = -ESHUTDOWN;  
  20.         goto done_not_linked;  
  21.     }  
  22.     status = usb_hcd_link_urb_to_ep(ehci_to_hcd(ehci), urb);  
  23.     if (unlikely(status))  
  24.         goto done_not_linked;  
  25.   
  26.     /* get qh and force any scheduling errors */  
  27.     INIT_LIST_HEAD (&empty);  
  28.     qh = qh_append_tds(ehci, urb, &empty, epnum, &urb->ep->hcpriv);  
  29.     if (qh == NULL) {  
  30.         status = -ENOMEM;  
  31.         goto done;  
  32.     }  
  33.     if (qh->qh_state == QH_STATE_IDLE) {  
  34.         if ((status = qh_schedule (ehci, qh)) != 0)  
  35.             goto done;  
  36.     }  
  37.   
  38.     /* then queue the urb's tds to the qh */  
  39.     qh = qh_append_tds(ehci, urb, qtd_list, epnum, &urb->ep->hcpriv);  
  40.     BUG_ON (qh == NULL);  
  41.   
  42.     /* ... update usbfs periodic stats */  
  43.     ehci_to_hcd(ehci)->self.bandwidth_int_reqs++;  
  44.   
  45. done:  
  46.     if (unlikely(status))  
  47.         usb_hcd_unlink_urb_from_ep(ehci_to_hcd(ehci), urb);  
  48. done_not_linked:  
  49.     spin_unlock_irqrestore (&ehci->lock, flags);  
  50.     if (status)  
  51.         qtd_list_free (ehci, urb, qtd_list);  
  52.   
  53.     return status;  
  54. }  

接下来的描述总线带宽，都是使用时间单位us（微秒）（总线带宽的描述，可以从时域和频域来描述），一个periodic frame list中的一frame的时间是1ms，而一个frame里包含了8个uframe，每个uframe对应一个总线的时隙（time slot），其带宽是固定的1000us/8=125us，并且usb2.0规定：周期传输的带宽不能超过总线带宽的80%，即不能超过125us*80%=100us。usb1.0中规定，同步传输的总线带宽不能够超过总线带宽的90%，但是low/full-speed设别，他们的总线时隙是1ms，即刚好对应一个frame帧的时间。

QH的一些重要成员域的含义：
  • qh->start：该成员仅对中断传输有意义，表示该QH被挂在周期微帧的什么位置，即在哪个周期微帧有中断传输，取值范围： 0..(qh->period - 1), or NO_FRAME（表示poll rate为1次/微帧） 
  • qh->usecs: 分裂传输分为split阶段和 csplit阶段，而该字段就是在split阶段所需要的总线带宽
  • qh->c_usecs：表示在csplit阶段，所需要的总线带宽
  • qh->tt_usecs：表示端点最大包长度在下行的全速总线上传输所需要占用的时间
  • qh->gap_uf：表示该端点的最大包长度在下行的全速总线上传输完，该段时间对应多少个高速总线时隙
  • qh->period：表示该中断传输的poll rate，表示每隔多少个uframe产生一次中断传输，单位为微帧


/*
 * Each QH holds a qtd list; a QH is used for everything except iso.
 *
 * For interrupt urbs, the scheduler must set the microframe scheduling
 * mask(s) each time the QH gets scheduled.  For highspeed, that's
 * just one microframe in the s-mask.  For split interrupt transactions
 * there are additional complications: c-mask, maybe FSTNs.
 */
该函数的主要功能，就是分配qh结构的空间，并初始化他们。
static struct ehci_qh *qh_make ( struct ehci_hcd *ehci, struct urb *urb, gfp_t flags)
[cpp]  view plain  copy
 
 
  1. {  
  2.     struct ehci_qh      *qh = ehci_qh_alloc (ehci, flags);  
  3.     u32         info1 = 0, info2 = 0;  
  4.     int         is_input, type;  
  5.     int         maxp = 0;  
  6.     struct usb_tt       *tt = urb->dev->tt;  
  7.     struct ehci_qh_hw   *hw;  
  8.   
  9.     if (!qh)  
  10.         return qh;  
  11.   
  12.     /* 
  13.      * init endpoint/device data for this QH 
  14.      */  
  15.     info1 |= usb_pipeendpoint (urb->pipe) << 8;  
  16.     info1 |= usb_pipedevice (urb->pipe) << 0;  
  17.   
  18.     is_input = usb_pipein (urb->pipe);  
  19.     type = usb_pipetype (urb->pipe);  
  20.     maxp = usb_maxpacket (urb->dev, urb->pipe, !is_input);  
  21.   
  22.     /* 1024 byte maxpacket is a hardware ceiling.  High bandwidth 
  23.      * acts like up to 3KB, but is built from smaller packets. 
  24.      */  
  25.     if (max_packet(maxp) > 1024) {  
  26.         ehci_dbg(ehci, "bogus qh maxpacket %d\n", max_packet(maxp));  
  27.         goto done;  
  28.     }  
  29. "white-space:pre">    //下面这段英文的注释，就是在初始化中断端点对应的QH时，需要考虑的问题，是难点！！！  
  30.     /* Compute interrupt scheduling parameters just once, and save. 
  31.      * - allowing for high bandwidth, how many nsec/uframe are used? 
  32.      * - split transactions need a second CSPLIT uframe; same question 
  33.      * - splits also need a schedule gap (for full/low speed I/O) 
  34.      * - qh has a polling interval 
  35.      * 
  36.      * For control/bulk requests, the HC or TT handles these. 
  37.      */  
  38.     if (type == PIPE_INTERRUPT) {//for 中断传输  
  39.         qh->usecs = NS_TO_US(usb_calc_bus_time(USB_SPEED_HIGH,  
  40.                 is_input, 0,  
  41.                 hb_mult(maxp) * max_packet(maxp)));//计算该中断端点对应的最大包长度，在高速总线下需要的带宽（）  
  42.         qh->start = NO_FRAME;  
  43.         qh->stamp = ehci->periodic_stamp;  
  44.   
  45.         if (urb->dev->speed == USB_SPEED_HIGH) {//高速中断传输  
  46.             qh->c_usecs = 0;  
  47.             qh->gap_uf = 0;  
  48.   
  49.             qh->period = urb->interval >> 3;  
  50.             if (qh->period == 0 && urb->interval != 1) {//对于那些中断间隔为2,4个uframe的中断传输，直接都upscale到间隔为1个uframe的中断传输  
  51.                 /* NOTE interval 2 or 4 uframes could work.//这样更便于管理，带宽更高 
  52.                  * But interval 1 scheduling is simpler, and 
  53.                  * includes high bandwidth. 
  54.                  */  
  55.                 urb->interval = 1;  
  56.             } else if (qh->period > ehci->periodic_size) {//对于那些周期超过1024*8的中断传输，则都直接upscale到间隔为1024*8个uframe的中断传输  
  57.                 qh->period = ehci->periodic_size;  
  58.                 urb->interval = qh->period << 3;  
  59.             }  
  60.         } else {         //全速中断传输  
  61.             int     think_time;  
  62.   
  63.             /* gap is f(FS/LS transfer times) */  
  64.             qh->gap_uf = 1 + usb_calc_bus_time (urb->dev->speed,//针对全速和低速设备的中断传输，首先计算出该中断端点的最大包长度在全速总线上所占的总线带宽  
  65.                     is_input, 0, maxp) / (125 * 1000);  //并计算出该总线带宽对应几个高速总线时隙，即对应几个uframe  
  66.   
  67.             /* FIXME this just approximates SPLIT/CSPLIT times */  
  68.             if (is_input) {     // 分裂中断IN传输的操作模型：SPLIT（对应带宽:HS_USECS(1)）, gap, CSPLIT+DATA(对应带宽：qh->c_usecs)qh->c_usecs)  
  69.                 qh->c_usecs = qh->usecs + HS_USECS (0);  
  70.                 qh->usecs = HS_USECS (1);  
  71.             } else {        //分裂中断OUT传输的操作模型： SPLIT+DATA, gap, CSPLIT  
  72.                 qh->usecs += HS_USECS (1);  
  73.                 qh->c_usecs = HS_USECS (0);  
  74.             }  
  75.   
  76.             think_time = tt ? tt->think_time : 0;  
  77.             qh->tt_usecs = NS_TO_US (think_time +  
  78.                     usb_calc_bus_time (urb->dev->speed,  
  79.                     is_input, 0, max_packet (maxp)));//即这个长度的包在全速总线上传输，所需要的时间  
  80.             qh->period = urb->interval;  
  81.             if (qh->period > ehci->periodic_size) {  
  82.                 qh->period = ehci->periodic_size;  
  83.                 urb->interval = qh->period;  
  84.             }  
  85.         }  
  86.     }  
  87.   
  88.     /* support for tt scheduling, and access to toggles */  
  89.     qh->dev = urb->dev;  
  90.   
  91.     /* using TT? */  
  92.     switch (urb->dev->speed) {  
  93.     case USB_SPEED_LOW:  
  94.         info1 |= (1 << 12);   /*更新QH结构中的 EPS域到 "low" */  
  95.         /* FALL THROUGH */  
  96.   
  97.     case USB_SPEED_FULL:  
  98.         /* EPS 0 means "full" */  
  99.         if (type != PIPE_INTERRUPT)  
  100.             info1 |= (EHCI_TUNE_RL_TT << 28);  
  101.         if (type == PIPE_CONTROL) {  
  102.             info1 |= (1 << 27);   /*field:"C" for TT */  
  103.             info1 |= 1 << 14; /*field:"dtc" toggle from qtd */  
  104.         }  
  105.         info1 |= maxp << 16; /*field："Maximum package length"*/  
  106.   
  107.         info2 |= (EHCI_TUNE_MULT_TT << 30); /*field:"Mult"*/  
  108.   
  109.         /* Some Freescale processors have an erratum in which the 
  110.          * port number in the queue head was 0..N-1 instead of 1..N. 
  111.          */  
  112.         if (ehci_has_fsl_portno_bug(ehci))/*Port number*/  
  113.             info2 |= (urb->dev->ttport-1) << 23;  
  114.         else  
  115.             info2 |= urb->dev->ttport << 23;  
  116.   
  117.         /* set the address of the TT; for TDI's integrated 
  118.          * root hub tt, leave it zeroed. 
  119.          */  
  120.         if (tt && tt->hub != ehci_to_hcd(ehci)->self.root_hub)/*Hub address*/  
  121.             info2 |= tt->hub->devnum << 16;  
  122.   
  123.         /* NOTE:  if (PIPE_INTERRUPT) { scheduler sets c-mask } */  
  124.   
  125.         break;  
  126.   
  127.     case USB_SPEED_HIGH:        /* no TT involved */  
  128.         info1 |= (2 << 12);   /* EPS "high" */  
  129.         if (type == PIPE_CONTROL) {  
  130.             info1 |= (EHCI_TUNE_RL_HS << 28);  
  131.             info1 |= 64 << 16;    /* usb2 fixed maxpacket */  
  132.             info1 |= 1 << 14; /* toggle from qtd */  
  133.             info2 |= (EHCI_TUNE_MULT_HS << 30);  
  134.         } else if (type == PIPE_BULK) {  
  135.             info1 |= (EHCI_TUNE_RL_HS << 28);  
  136.             /* The USB spec says that high speed bulk endpoints 
  137.              * always use 512 byte maxpacket.  But some device 
  138.              * vendors decided to ignore that, and MSFT is happy 
  139.              * to help them do so.  So now people expect to use 
  140.              * such nonconformant devices with Linux too; sigh. 
  141.              */  
  142.             info1 |= max_packet(maxp) << 16;  
  143.             info2 |= (EHCI_TUNE_MULT_HS << 30);  
  144.         } else {        /* PIPE_INTERRUPT */  
  145.             info1 |= max_packet (maxp) << 16;  
  146.             info2 |= hb_mult (maxp) << 30;  
  147.         }  
  148.         break;  
  149.     default:  
  150.         dbg ("bogus dev %p speed %d", urb->dev, urb->dev->speed);  
  151. done:  
  152.         qh_put (qh);  
  153.         return NULL;  
  154.     }  
  155.   
  156.     /* NOTE:  if (PIPE_INTERRUPT) { scheduler sets s-mask } */  
  157.   
  158.     /* init as live, toggle clear, advance to dummy */  
  159.     qh->qh_state = QH_STATE_IDLE;  
  160.     hw = qh->hw;  
  161.     hw->hw_info1 = cpu_to_hc32(ehci, info1);  
  162.     hw->hw_info2 = cpu_to_hc32(ehci, info2);  
  163.     qh->is_out = !is_input;  
  164.     usb_settoggle (urb->dev, usb_pipeendpoint (urb->pipe), !is_input, 1);  
  165.     qh_refresh (ehci, qh);  
  166.     return qh;  
  167. }  

该函数的主要功能就是确定qh->start的值，而该值合理的取值范围为： 0..(qh->period - 1), or NO_FRAME，即该函数的功能就是：扫描整个周期调度uframe列表，从0...(qh->period - 1)中，选择第一个可用的值，使该值对应的那组时隙都有可用的同步带宽。
另外需要注意的是,QH结构体中的S-mask的含义:
  • 首先该值不为0，则说明是中断端点，然后再根据EPS域
    • 如果是高速端点，则smask则表示在哪些对应的微帧发起中断传输
    • 如果是低速、全速端点，则smask则表示在哪个微帧发起ssplit传输
  • 如果该值为0，说明是在异步传输队列中，只能是控制、bulk传输
最后c-mask则只有在低速、全速的中断端点时，才有意义，表示在哪几个微帧发起csplit传输
[cpp]  view plain  copy
 
 
  1. /* "first fit" scheduling policy used the first time through, 
  2.  * or when the previous schedule slot can't be re-used. 
  3.  */  
  4. static int qh_schedule(struct ehci_hcd *ehci, struct ehci_qh *qh)  
  5. {  
  6.     int     status;  
  7.     unsigned    uframe;  
  8.     __hc32      c_mask;  
  9.     unsigned    frame;      /* 0..(qh->period - 1), or NO_FRAME */  
  10.     struct ehci_qh_hw   *hw = qh->hw;  
  11.   
  12.     qh_refresh(ehci, qh);  
  13.     hw->hw_next = EHCI_LIST_END(ehci);  
  14.     frame = qh->start;  
  15.   
  16.     /* reuse the previous schedule slots, if we can */  
  17.     if (frame < qh->period) {  
  18.         uframe = ffs(hc32_to_cpup(ehci, &hw->hw_info2) & QH_SMASK);  
  19.         status = check_intr_schedule (ehci, frame, --uframe,  
  20.                 qh, &c_mask);  
  21.     } else {  
  22.         uframe = 0;  
  23.         c_mask = 0;  
  24.         status = -ENOSPC;  
  25.     }  
  26.   
  27.     /* else scan the schedule to find a group of slots such that all 
  28.      * uframes have enough periodic bandwidth available. 
  29.      */  
  30.     if (status) {  
  31.         /* "normal" case, uframing flexible except with splits */  
  32.         if (qh->period) {  
  33.             int     i;  
  34.   
  35.             for (i = qh->period; status && i > 0; --i) {  
  36.                 frame = ++ehci->random_frame % qh->period;  
  37.                 for (uframe = 0; uframe < 8; uframe++) {  
  38.                     status = check_intr_schedule (ehci,  
  39.                             frame, uframe, qh,  
  40.                             &c_mask);  
  41.                     if (status == 0)  
  42.                         break;  
  43.                 }  
  44.             }  
  45.   
  46.         /* qh->period == 0 means every uframe */  
  47.         } else {  
  48.             frame = 0;  
  49.             status = check_intr_schedule (ehci, 0, 0, qh, &c_mask);  
  50.         }  
  51.         if (status)  
  52.             goto done;  
  53.         qh->start = frame;   //选定了该frame帧对应的uframe微帧，是符合条件的。  
  54.   
  55.         /* reset S-frame and (maybe) C-frame masks */  
  56.         hw->hw_info2 &= cpu_to_hc32(ehci, ~(QH_CMASK | QH_SMASK));  
  57.         hw->hw_info2 |= qh->period  
  58.             ? cpu_to_hc32(ehci, 1 << uframe)   //qh->period == 0 means every uframe都有中断传输，  
  59.             : cpu_to_hc32(ehci, QH_SMASK);   //不为0，则意味着只有制定的那个微帧才有中断传输或start split传输  
  60.         hw->hw_info2 |= c_mask;//制定csplit传输的位置，只有全速、低速中断才有意义，如果其他情况，应该都为0.  
  61.     } else  
  62.         ehci_dbg (ehci, "reused qh %p schedule\n", qh);  
  63.   
  64.     /* stuff into the periodic schedule */  
  65.     status = qh_link_periodic (ehci, qh);  
  66. done:  
  67.     return status;  
  68. }  

分裂传输虽然可以跨H帧的边界，但是分裂传输绝不能夸B帧的边界，由于B帧滞后于H帧一个slot，所以如果要跨H帧支持分裂传输，那也只可能在下一个H帧的0、1uframe有csplit传输。
上面函数就是通过调用check_intr_schedule函数确定frame帧中的uframe微帧对应的时隙组是否有可用的周期总线带宽（包括中断、同步传输）。
由于分裂传输，是有ssplit和csplit传输组成，所以需要分别判断ssplit和csplit所在的微帧是否都有可用的周期带宽。
在这里需要关键弄清楚qh->usecs的含义：
  • 如果EPS指示是高速中断端点，则qh->usecs表示该中断IN、OUT传输所需的最大带宽
  • 如果EPS指示是全速、低速中断端点，且是OUT中断传输，则qh->usecs表示：ssplit+data所需最大的带宽
  • 如果EPS指示是全速、低速中断端点，且是IN中断传输，则qh->usecs为0

[cpp]  view plain  copy
 
 
  1. static int check_intr_schedule (  
  2.     struct ehci_hcd     *ehci,  
  3.     unsigned        frame,  
  4.     unsigned        uframe,  
  5.     const struct ehci_qh    *qh,  
  6.     __hc32          *c_maskp  
  7. )  
  8. {  
  9.     int     retval = -ENOSPC;  
  10.     u8      mask = 0;  
  11.   
  12.     if (qh->c_usecs && uframe >= 6)       /* FSTN territory? */目前usb驱动还不支持分裂传输跨H帧边界，所以需要这样一个判断  
  13.         goto done;  
  14.   
  15.     if (!check_period (ehci, frame, uframe, qh->period, qh->usecs))//计算frame帧中的uframe微帧对应的时隙组，是否有足够多可用的同步带宽来容纳qh->usecs对应的带宽  
  16.         goto done;  
  17.     if (!qh->c_usecs) {//对于全速、低速设备而言，如果中断OUT传输，则qh->c_usecs为0，如果是中断IN传输，则不为0  
  18.         retval = 0;  
  19.         *c_maskp = 0;  
  20.         goto done;  
  21.     }  
  22.   
  23. #ifdef CONFIG_USB_EHCI_TT_NEWSCHED  
  24.     if (tt_available (ehci, qh->period, qh->dev, frame, uframe,//该函数判断tt下行的fs、ls设备对应于frame帧的时隙组，是否有足够同步带宽来容纳qh->tt_usecs  
  25.                 qh->tt_usecs)) {  
  26.         unsigned i;  
  27.   
  28.         /* TODO : this may need FSTN for SSPLIT in uframe 5. */  
  29.         for (i=uframe+1; i<8 && i
  30.             if (!check_period (ehci, frame, i,  
  31.                         qh->period, qh->c_usecs))//判断对应的uframe微帧所对应的时隙组，是否有足够带宽发起csplit传输  
  32.                 goto done;  
  33.             else  
  34.                 mask |= 1 << i;  
  35.   
  36.         retval = 0;  
  37.   
  38.         *c_maskp = cpu_to_hc32(ehci, mask << 8);//设定在哪些帧发起csplit传输，固定为3个csplit传输。  
  39.     }  
  40. #else  
  41.     /* Make sure this tt's buffer is also available for CSPLITs. 
  42.      * We pessimize a bit; probably the typical full speed case 
  43.      * doesn't need the second CSPLIT. 
  44.      * 
  45.      * NOTE:  both SPLIT and CSPLIT could be checked in just 
  46.      * one smart pass... 
  47.      */  
  48.     mask = 0x03 << (uframe + qh->gap_uf);  
  49.     *c_maskp = cpu_to_hc32(ehci, mask << 8);  
  50.   
  51.     mask |= 1 << uframe;  
  52.     if (tt_no_collision (ehci, qh->period, qh->dev, frame, mask)) {  
  53.         if (!check_period (ehci, frame, uframe + qh->gap_uf + 1,  
  54.                     qh->period, qh->c_usecs))  
  55.             goto done;  
  56.         if (!check_period (ehci, frame, uframe + qh->gap_uf,  
  57.                     qh->period, qh->c_usecs))  
  58.             goto done;  
  59.         retval = 0;  
  60.     }  
  61. #endif  
  62. done:  
  63.     return retval;  
  64. }  

确定qh->start的值后，就可以通过qh_link_periodic函数，将qh以qh->period为间隔，链接到对应的时隙中。
struct ehci_hcd结构体中，有如下几个重要的成员：
  • ehci->periodic[i]： 对应hc使用的periodic frame list，里面存储的是指向下一个接口数据的开始物理地址
  • ehci->pshadow[i]：里面存储的是hc使用的接口数据对应的虚拟地址，与ehci->pshadow[i]的关系就是：
    • 他们共相同的物理空间，ehci->periodic[i]是接口数据的ehci->pshadow[i]的开始部分，是hc在执行传输时需要的接口数据单元
    • ehci->pshadow[i]中除去ehci->periodic[i]部分，还有剩余的私有部分，是用于软件来管理这些数据结构的。hc不会访问到。
    • ehci->periodic为硬件周期列表，共有1024项，供host constroller访问；ehci->pshadow是对应的软件结构列表，共hcd driver来访问。
      其实ehci->pshadow中前半部分，即为硬件表的内容，只是ehci->periodic种存的是物理地址，而ehci->pshadow
      使用的是物理地址对应的虚拟地址。

[cpp]  view plain  copy
 
 
  1. /* periodic schedule slots have iso tds (normal or split) first, then a 
  2.  * sparse tree for active interrupt transfers. 
  3.  * 
  4.  * this just links in a qh; caller guarantees uframe masks are set right. 
  5.  * no FSTN support (yet; ehci 0.96+) 
  6.  */  
  7. static int qh_link_periodic (struct ehci_hcd *ehci, struct ehci_qh *qh)  
  8. {  
  9.     unsigned    i;  
  10.     unsigned    period = qh->period;  
  11.   
  12.     dev_dbg (&qh->dev->dev,  
  13.         "link qh%d-%04x/%p start %d [%d/%d us]\n",  
  14.         period, hc32_to_cpup(ehci, &qh->hw->hw_info2)  
  15.             & (QH_CMASK | QH_SMASK),  
  16.         qh, qh->start, qh->usecs, qh->c_usecs);  
  17.   
  18.     /* high bandwidth, or otherwise every microframe */  
  19.     if (period == 0)  
  20.         period = 1;  
  21.   
  22.     for (i = qh->start; i < ehci->periodic_size; i += period) {  
  23.         union ehci_shadow   *prev = &ehci->pshadow[i];  
  24.         __hc32          *hw_p = &ehci->periodic[i];  
  25.         union ehci_shadow   here = *prev;  
  26.         __hc32          type = 0;  
  27.   
  28.         /* skip the iso nodes at list head */跳过前面的itd和sitd节点  
  29.         while (here.ptr) {  
  30.             type = Q_NEXT_TYPE(ehci, *hw_p);  
  31.             if (type == cpu_to_hc32(ehci, Q_TYPE_QH))  
  32.                 break;  
  33.             prev = periodic_next_shadow(ehci, prev, type);  
  34.             hw_p = shadow_next_periodic(ehci, &here, type);  
  35.             here = *prev;  
  36.         }  
  37.   
  38.         /* sorting each branch by period (slow-->fast)//由于中断端点对应的qh在数据结构的组织上，根据poll rate从低到高连接在一起的。 
  39.          * enables sharing interior tree nodes//所以要根据他们的qh->period来确定合适的插入位置 
  40.          */  
  41.         while (here.ptr && qh != here.qh) {     
  42.             if (qh->period > here.qh->period)  
  43.                 break;  
  44.             prev = &here.qh->qh_next;  
  45.             hw_p = &here.qh->hw->hw_next;  
  46.             here = *prev;       //在这里需要特别注意的是：here不是指针，而prev是指针，prev指向的是列表的前一个，而here指向的列表的当前节点  
  47.         }  
  48.         /* link in this qh, unless some earlier pass did that */  
  49.         if (qh != here.qh) {   // before insert: prev--->here ; after insert: prev-->qh--->here  
  50.             qh->qh_next = here;  
  51.             if (here.qh)  
  52.                 qh->hw->hw_next = *hw_p;  
  53.             wmb ();  
  54.             prev->qh = qh;  
  55.             *hw_p = QH_NEXT (ehci, qh->qh_dma);  
  56.         }  
  57.     }  
  58.     qh->qh_state = QH_STATE_LINKED;  
  59.     qh->xacterrs = 0;  
  60.     qh_get (qh);  
  61.   
  62.     /* update per-qh bandwidth for usbfs */  
  63.     ehci_to_hcd(ehci)->self.bandwidth_allocated += qh->period  
  64.         ? ((qh->usecs + qh->c_usecs) / qh->period)  
  65.         : (qh->usecs * 8);  
  66.   
  67.     /* maybe enable periodic schedule processing */  
  68.     return enable_periodic(ehci);  
  69. }  
上面操作的示意图如下：
linux usb ehci controller driver_第17张图片
上图中，需要强调的是：周期列表中，一个QH对应一个中断端点，QH/xx，"xx"为该中断端点的poll rate。

2.3.3 for PIPE_ISOCHRONOUS urb enqueue过程（包括高速同步和分裂同步传输）

struct ehci_iso_stream *stream  该结构用来将属于某个同步端点的所有sitds/itds组织在一起，通过stream->td_list列表。stream的作用类似于异步传输结构中的qh作用。因此stream也包含同步端点的一些静态内容，譬如：该同步端口所在设备的设备地址，该同步端口的端口号，该设备对应的hub的地址，hub的端口号，最大包长度。stream结构中，有如下几个重要的成员：
  • stream->usecs：表示传输该端口所允许的最大包所需要的带宽（用us单位计量，call HS_USECS_ISO（））
  • stream->c_usecs：对应同步分裂传输的csplit传输阶段所需的带宽
  • stream->raw_mask：该成员存储了在哪些微帧需要发起ssplist和csplist传输，注意是相对于0uframe的，如果是从非0uframe开始，则整体左移。
  • stream->next_uframe： 对应该端点的下次链入interface schedule data structure在periodic list列表的什么地方
  • stream->splits：该成员是stream->raw_mask在左移uframe为后的值。（uframe为同步预算调度计算出来的对应的插入该同步传输的位置，0<=uframe<8）
  • stream->interval：类似urb->interval的含义
为什么全速设备在一个microframe的时间内，只能传输188个字节的数据？
A microframe of time allows at most 187.5 raw bytes of signaling on a full-speed bus. In order to estimate when full-/low-speed transactions appear on a downstream bus, the host must calculate a best case fullspeed budget. This budget tracks in which microframes a full-/low-speed transaction appears. The best case full-speed budget assumes that 188 full-speed bytes occur in each microframe. Figure 11-60 shows how a1 ms frame subdivided into microframes of budget time. This estimate assumes that no bit stuffing occurs to lengthen the time required to move transactions over the bus.（摘自usb2.0 11.18.1）

The maximum number of bytes in a 1 ms frame is calculated as:
1157 maximum_periodic_bytes_per_frame = 12 Mb/s * 1 ms / 8 bits_per_byte *6 data_bits / 7 bit-stuffed_data_bits * 90% maximum_periodic_data_per_frame

linux usb ehci controller driver_第18张图片
同步传输的enqueue流程图如下：
linux usb ehci controller driver_第19张图片

该函数初始化struct ehci_iso_stream *stream结构，重点需要关注stream结构中的如上红色高亮部分的成员的含义和设置。

[cpp]  view plain  copy
 
 
  1. static void  
  2. iso_stream_init (  
  3.     struct ehci_hcd     *ehci,  
  4.     struct ehci_iso_stream  *stream,  
  5.     struct usb_device   *dev,  
  6.     int         pipe,  
  7.     unsigned        interval  
  8. )  
  9. {  
  10.     static const u8 smask_out [] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f };//该数组表示以microframe的数目为index，相应的值为在哪些uframe slot需要发起start split传输  
  11.   
  12.     u32         buf1;  
  13.     unsigned        epnum, maxp;  
  14.     int         is_input;  
  15.     long            bandwidth;  
  16.   
  17.     /* 
  18.      * this might be a "high bandwidth" highspeed endpoint, 
  19.      * as encoded in the ep descriptor's wMaxPacket field 
  20.      */  
  21.     epnum = usb_pipeendpoint (pipe);  
  22.     is_input = usb_pipein (pipe) ? USB_DIR_IN : 0;  
  23.     maxp = usb_maxpacket(dev, pipe, !is_input);  
  24.     if (is_input) {  
  25.         buf1 = (1 << 11);  
  26.     } else {  
  27.         buf1 = 0;  
  28.     }  
  29.   
  30.     /* knows about ITD vs SITD */  
  31.     if (dev->speed == USB_SPEED_HIGH) {//高速同步传输  
  32.         unsigned multi = hb_mult(maxp);//陪乘数，表示在一个uframe中连续发起multi个IN/OUT传输  
  33.   
  34.         stream->highspeed = 1;  
  35.   
  36.         maxp = max_packet(maxp);  
  37.         buf1 |= maxp;  
  38.         maxp *= multi;  
  39.   
  40.         stream->buf0 = cpu_to_hc32(ehci, (epnum << 8) | dev->devnum);  
  41.         stream->buf1 = cpu_to_hc32(ehci, buf1);  
  42.         stream->buf2 = cpu_to_hc32(ehci, multi);  
  43.   
  44.         /* usbfs wants to report the average usecs per frame tied up 
  45.          * when transfers on this endpoint are scheduled ... 
  46.          */  
  47.         stream->usecs = HS_USECS_ISO (maxp);//同步带宽  
  48.         bandwidth = stream->usecs * 8;  
  49.         bandwidth /= interval;  
  50.   
  51.     } else {//全速同步分裂传输  
  52.         u32     addr;  
  53.         int     think_time;  
  54.         int     hs_transfers;  
  55.   
  56.         addr = dev->ttport << 24;  
  57.         if (!ehci_is_TDI(ehci)  
  58.                 || (dev->tt->hub !=  
  59.                     ehci_to_hcd(ehci)->self.root_hub))  
  60.             addr |= dev->tt->hub->devnum << 16;  
  61.         addr |= epnum << 8;  
  62.         addr |= dev->devnum;  
  63.         stream->usecs = HS_USECS_ISO (maxp);//同步带宽  
  64.         think_time = dev->tt ? dev->tt->think_time : 0;  
  65.         stream->tt_usecs = NS_TO_US (think_time + usb_calc_bus_time (//这个最大包长度在全速总线上，所占的总线带宽（以时间us计量）  
  66.                 dev->speed, is_input, 1, maxp));  
  67.         hs_transfers = max (1u, (maxp + 187) / 188);//这个全速同步传输时间，跨越了几个uframe微帧，由于在一个微帧（125us）的时间里，全速同步传输最多可以传送188个字节。  
  68.         if (is_input) {// 同步端点IN传输的操作模式：SSplit+IN , CSplit+IN+DATA  
  69.             u32 tmp;  
  70.             addr |= 1 << 31;  
  71.             stream->c_usecs = stream->usecs;//同步IN传输csplist阶段所需的最大带宽  
  72.             stream->usecs = HS_USECS_ISO (1);//同步In传输ssplit阶段所需的最大带宽  
  73.             stream->raw_mask = 1;  
  74.   
  75.             /* c-mask as specified in USB 2.0 11.18.4 3.c */该语句的含义，见下面的示意图  
  76.             tmp = (1 << (hs_transfers + 2)) - 1;  
  77.             stream->raw_mask |= tmp << (8 + 2);  
  78.         } else    //同步端点OUT传输的操作模式：SSplist+OUT+DATA，没有csplist阶段，因为同步传输是不不可靠传输，不需要响应  
  79.             stream->raw_mask = smask_out [hs_transfers - 1];//对应那些位置需要发起ssplist out传输，如果数据包大于188byte，则需要多个ssplist  
  80.         bandwidth = stream->usecs + stream->c_usecs;  
  81.         bandwidth /= interval << 3;  
  82.   
  83.         /* stream->splits gets created from raw_mask later */  
  84.         stream->address = cpu_to_hc32(ehci, addr);  
  85.     }  
  86.     stream->bandwidth = bandwidth;  
  87.   
  88.     stream->udev = dev;  
  89.   
  90.     stream->bEndpointAddress = is_input | epnum;  
  91.     stream->interval = interval;  
  92.     stream->maxp = maxp;  
  93. }  
下图演示了周期传输的csplist和ssplist是如何设置的：

linux usb ehci controller driver_第20张图片

struct ehci_iso_packet结构体用来描述一个同步端点在某个microframe（0
[cpp]  view plain  copy
 
 
  1. /* description of one iso transaction (up to 3 KB data if highspeed) */  
  2. struct ehci_iso_packet {  
  3.     /* These will be copied to iTD when scheduling */  
  4.     u64         bufp;       /* itd->hw_bufp{,_hi}[pg] |= */  
  5.     __hc32          transaction;    /* itd->hw_transaction[i] |= */  
  6.     u8          cross;      /* buf crosses pages */  
  7.     /* for full speed OUT splits */  
  8.     u32         buf1;  
  9. };  
struct ehci_iso_sched结构对应一个urb的传输，他是一个暂存结构，暂存这个urb所对应的itd中所需的信息；注意一个urb可能会跨多个itd结构。
[cpp]  view plain  copy
 
 
  1. /* temporary schedule data for packets from iso urbs (both speeds) 
  2.  * each packet is one logical usb transaction to the device (not TT), 
  3.  * beginning at stream->next_uframe 
  4.  */  
  5. struct ehci_iso_sched {  
  6.     struct list_head    td_list;  
  7.     unsigned        span;  
  8.     struct ehci_iso_packet  packet [0];  
  9. };  

urb->number_of_packets与itd的关系：一个poll rate为N的同步端点，一个urb包含了在uframe，uframe+N，uframe+2N三个时隙的同步传输buffer，则urb->number_of_packets就为3.当N大于8时，itd的数目就跟urb->number_of_packets的数目相同。而当N小于8时，则一个urb所需的itd的数据就小于urb->number_of_packets，因为一个itd是对应一个frame的，而在一个frame中，在N小于8时，就会有多个同步传输发生，即会消耗多个urb->iso_frame_desc[i]（0number_of_packets）
itd_urb_transaction 函数，就是根据urb的urb->number_of_packets和urb->interval来确定需要分配多少个itd结构体，并初始化他们，并挂在sched->td_list列表上。
[cpp]  view plain  copy
 
 
  1. static int  
  2. itd_urb_transaction (  
  3.     struct ehci_iso_stream  *stream,  
  4.     struct ehci_hcd     *ehci,  
  5.     struct urb      *urb,  
  6.     gfp_t           mem_flags  
  7. )  
  8. {  
  9.     struct ehci_itd     *itd;  
  10.     dma_addr_t      itd_dma;  
  11.     int         i;  
  12.     unsigned        num_itds;  
  13.     struct ehci_iso_sched   *sched;  
  14.     unsigned long       flags;  
  15.   
  16.     sched = iso_sched_alloc (urb->number_of_packets, mem_flags);  
  17.     if (unlikely (sched == NULL))  
  18.         return -ENOMEM;  
  19.   
  20.     itd_sched_init(ehci, sched, stream, urb);  
  21.   
  22.     if (urb->interval < 8)  
  23.         num_itds = 1 + (sched->span + 7) / 8;//计算一个urb需要多少个itd接口数据  
  24.     else  
  25.         num_itds = urb->number_of_packets;  
  26.   
  27.     /* allocate/init ITDs */  
  28.     spin_lock_irqsave (&ehci->lock, flags);  
  29.     for (i = 0; i < num_itds; i++) {  
  30.   
  31.         /* free_list.next might be cache-hot ... but maybe 
  32.          * the HC caches it too. avoid that issue for now. 
  33.          */  
  34.   
  35.         /* prefer previously-allocated itds */  
  36.         if (likely (!list_empty(&stream->free_list))) {  
  37.             itd = list_entry (stream->free_list.prev,  
  38.                     struct ehci_itd, itd_list);  
  39.             list_del (&itd->itd_list);  
  40.             itd_dma = itd->itd_dma;  
  41.         } else {  
  42.             spin_unlock_irqrestore (&ehci->lock, flags);  
  43.             itd = dma_pool_alloc (ehci->itd_pool, mem_flags,  
  44.                     &itd_dma);  
  45.             spin_lock_irqsave (&ehci->lock, flags);  
  46.             if (!itd) {  
  47.                 iso_sched_free(stream, sched);  
  48.                 spin_unlock_irqrestore(&ehci->lock, flags);  
  49.                 return -ENOMEM;  
  50.             }  
  51.         }  
  52.   
  53.         memset (itd, 0, sizeof *itd);  
  54.         itd->itd_dma = itd_dma;  
  55.         list_add (&itd->itd_list, &sched->td_list);  
  56.     }  
  57.     spin_unlock_irqrestore (&ehci->lock, flags);  
  58.   
  59.     /* temporarily store schedule info in hcpriv */  
  60.     urb->hcpriv = sched;  
  61.     urb->error_count = 0;  
  62.     return 0;  
  63. }  


下面这个图示意了urb和ehci_iso_stream, itd, iso_frame_desc等结构体之间的关系。
linux usb ehci controller driver_第21张图片


iso_stream_schedule：(struct ehci_hcd  *ehci, struct urb*urb, struct ehci_iso_stream *stream)：该函数决定此次提交的urb将被放在周期微帧列表的什么位置，并将该位置保存到stream->next_uframe变量中，供以后使用。
周期微帧列表： 是1024*8个微帧，每帧为125us， 所以上述0
[cpp]  view plain  copy
 
 
  1. /* 
  2.  * This scheduler plans almost as far into the future as it has actual 
  3.  * periodic schedule slots.  (Affected by TUNE_FLS, which defaults to 
  4.  * "as small as possible" to be cache-friendlier.)  That limits the size 
  5.  * transfers you can stream reliably; avoid more than 64 msec per urb. 
  6.  * Also avoid queue depths of less than ehci's worst irq latency (affected 
  7.  * by the per-urb URB_NO_INTERRUPT hint, the log2_irq_thresh module parameter, 
  8.  * and other factors); or more than about 230 msec total (for portability, 
  9.  * given EHCI_TUNE_FLS and the slop).  Or, write a smarter scheduler! 
  10.  */  
  11.   
  12. #define SCHEDULE_SLOP   80  /* microframes */  
  13.   
  14. static int  
  15. iso_stream_schedule (  
  16.     struct ehci_hcd     *ehci,  
  17.     struct urb      *urb,  
  18.     struct ehci_iso_stream  *stream  
  19. )  
  20. {  
  21.     u32         now, next, start, period, span;  
  22.     int         status;  
  23.     unsigned        mod = ehci->periodic_size << 3;  
  24.     struct ehci_iso_sched   *sched = urb->hcpriv;  
  25.   
  26.     period = urb->interval;  
  27.     span = sched->span;  
  28.     if (!stream->highspeed) {  
  29.         period <<= 3;  
  30.         span <<= 3;  
  31.     }  
  32.   
  33.     if (span > mod - SCHEDULE_SLOP) {  
  34.         ehci_dbg (ehci, "iso request %p too long\n", urb);  
  35.         status = -EFBIG;  
  36.         goto fail;  
  37.     }  
  38.   
  39.     now = ehci_read_frame_index(ehci) & (mod - 1);//当前hc在哪个周期列表元素中执行  
  40.   
  41.     /* Typical case: reuse current schedule, stream is still active. 
  42.      * Hopefully there are no gaps from the host falling behind 
  43.      * (irq delays etc), but if there are we'll take the next 
  44.      * slot in the schedule, implicitly assuming URB_ISO_ASAP. 
  45.      */  
  46.     if (likely (!list_empty (&stream->td_list))) {//这个说明这个周期端点，之前已经被调度过了只要按对应的时隙间隔填充，不用再去判断对应的时隙组是否有足够可用的总线带宽，因为已经判断过了。  
  47.         u32 excess;  
  48.   
  49.         /* For high speed devices, allow scheduling within the 
  50.          * isochronous scheduling threshold.  For full speed devices 
  51.          * and Intel PCI-based controllers, don't (work around for 
  52.          * Intel ICH9 bug). 
  53.          */  
  54.         if (!stream->highspeed && ehci->fs_i_thresh)  
  55.             next = now + ehci->i_thresh;  
  56.         else  
  57.             next = now;  
  58.   
  59.         /* Fell behind (by up to twice the slop amount)? 
  60.          * We decide based on the time of the last currently-scheduled 
  61.          * slot, not the time of the next available slot. 
  62.          */  
  63.         excess = (stream->next_uframe - period - next) & (mod - 1);  
  64.         if (excess >= mod - 2 * SCHEDULE_SLOP)  
  65.             start = next + excess - mod + period *  
  66.                     DIV_ROUND_UP(mod - excess, period);//保证在对应的间隔为period的时隙slot中。  
  67.         else  
  68.             start = next + excess + period;   //基于上次被调度的地方，而不是最近hc被访问的地方  
  69.         if (start - now >= mod) {  
  70.             ehci_dbg(ehci, "request %p would overflow (%d+%d >= %d)\n",  
  71.                     urb, start - now - period, period,  
  72.                     mod);  
  73.             status = -EFBIG;  
  74.             goto fail;  
  75.         }  
  76.     }  
  77.   
  78.     /* need to schedule; when's the next (u)frame we could start? 
  79.      * this is bigger than ehci->i_thresh allows; scheduling itself 
  80.      * isn't free, the slop should handle reasonably slow cpus.  it 
  81.      * can also help high bandwidth if the dma and irq loads don't 
  82.      * jump until after the queue is primed. 
  83.      */  
  84.     else {  
  85.         int done = 0;  
  86.         start = SCHEDULE_SLOP + (now & ~0x07);  
  87.   
  88.         /* NOTE:  assumes URB_ISO_ASAP, to limit complexity/bugs */  
  89.   
  90.         /* find a uframe slot with enough bandwidth. 
  91.          * Early uframes are more precious because full-speed 
  92.          * iso IN transfers can't use late uframes, 
  93.          * and therefore they should be allocated last. 
  94.          */  
  95.         next = start;  
  96.         start += period;  
  97.         do {  
  98.             start--;  
  99.             /* check schedule: enough space? */  
  100.             if (stream->highspeed) {  
  101.                 if (itd_slot_ok(ehci, mod, start,  
  102.                         stream->usecs, period))//详细见下面的解析  
  103.                     done = 1;  
  104.             } else {  
  105.                 if ((start % 8) >= 6)  
  106.                     continue;  
  107.                 if (sitd_slot_ok(ehci, mod, stream,  
  108.                         start, sched, period))//详细见下面的解析  
  109.                     done = 1;  
  110.             }  
  111.         } while (start > next && !done);  
  112.   
  113.         /* no room in the schedule */  
  114.         if (!done) {  
  115.             ehci_dbg(ehci, "iso resched full %p (now %d max %d)\n",  
  116.                 urb, now, now + mod);  
  117.             status = -ENOSPC;  
  118.             goto fail;  
  119.         }  
  120.     }  
  121.   
  122.     /* Tried to schedule too far into the future? */  
  123.     if (unlikely(start - now + span - period  
  124.                 >= mod - 2 * SCHEDULE_SLOP)) {  
  125.         ehci_dbg(ehci, "request %p would overflow (%d+%d >= %d)\n",  
  126.                 urb, start - now, span - period,  
  127.                 mod - 2 * SCHEDULE_SLOP);  
  128.         status = -EFBIG;  
  129.         goto fail;  
  130.     }  
  131.   
  132.     stream->next_uframe = start & (mod - 1);//该值在新的itd或sitd被连入到这个周期列表后，会被更新（详见itd_link_urb和sitd_link_urb函数）  
  133.   
  134.     /* report high speed start in uframes; full speed, in frames */  
  135.     urb->start_frame = stream->next_uframe;  
  136.     if (!stream->highspeed)  
  137.         urb->start_frame >>= 3;  
  138.     return 0;  
  139.   
  140.  fail:  
  141.     iso_sched_free(stream, sched);  
  142.     urb->hcpriv = NULL;  
  143.     return status;  
  144. }  

periodic_usecs (struct ehci_hcd *ehci, unsigned frame, unsigned uframe): 用来计算某个帧（frame指定）中的某个微帧（uframe指定）目前已经占用的周期总线带宽
参数的取值范围：1
对于全速设备，每个frame帧中的，同步带宽不能超过90%；而对于高速设备，每个微帧中，同步带宽不能超过微帧总线带宽的80%，而ehci->uframe_periodic_max变量就保存了在高速设备的一个微帧中，最多可以有多少时间的同步带宽可用（以us单位计量）.

[cpp]  view plain  copy
 
 
  1. /* how many of the uframe's 125 usecs are allocated? */  
  2. static unsigned short  
  3. periodic_usecs (struct ehci_hcd *ehci, unsigned frame, unsigned uframe)  
  4. {  
  5.     __hc32          *hw_p = &ehci->periodic [frame];  
  6.     union ehci_shadow   *q = &ehci->pshadow [frame];  
  7.     unsigned        usecs = 0;  
  8.     struct ehci_qh_hw   *hw;  
  9.   
  10.     while (q->ptr) {  
  11.         switch (hc32_to_cpu(ehci, Q_NEXT_TYPE(ehci, *hw_p))) {  
  12.         case Q_TYPE_QH:  //该QH只能对应的就是中断端点，  
  13.             hw = q->qh->hw;  
  14.             /* is it in the S-mask? */  
  15.             if (hw->hw_info2 & cpu_to_hc32(ehci, 1 << uframe))//对于高速中断设备，表示在S-mask对应的位置发起中断传输，对应的最大可能的带宽包存在qh->usecs变量中。  
  16.                 usecs += q->qh->usecs;  
  17.             /* ... or C-mask? */  
  18.             if (hw->hw_info2 & cpu_to_hc32(ehci,  
  19.                     1 << (8 + uframe)))//对于高速中断设备而言，该域为0，而对于全速设备而言，该域就是csplist传输，对应的带宽  
  20.                 usecs += q->qh->c_usecs;  
  21.             hw_p = &hw->hw_next;  
  22.             q = &q->qh->qh_next;  
  23.             break;  
  24.         // case Q_TYPE_FSTN:  
  25.         default:  
  26.             /* for "save place" FSTNs, count the relevant INTR 
  27.              * bandwidth from the previous frame 
  28.              */  
  29.             if (q->fstn->hw_prev != EHCI_LIST_END(ehci)) {  
  30.                 ehci_dbg (ehci, "ignoring FSTN cost ...\n");  
  31.             }  
  32.             hw_p = &q->fstn->hw_next;  
  33.             q = &q->fstn->fstn_next;  
  34.             break;  
  35.         case Q_TYPE_ITD:  
  36.             if (q->itd->hw_transaction[uframe])//高速同步端点，一个itd保存了8个微帧的传输，如果对应的微帧位置没有事务传输，则应该为0，如果有对应的传输，则最大可能的带宽保存在stream->usecs变量中  
  37.                 usecs += q->itd->stream->usecs;  
  38.             hw_p = &q->itd->hw_next;  
  39.             q = &q->itd->itd_next;  
  40.             break;  
  41.         case Q_TYPE_SITD:  
  42.             /* is it in the S-mask?  (count SPLIT, DATA) */  
  43.             if (q->sitd->hw_uframe & cpu_to_hc32(ehci,  
  44.                     1 << uframe)) {  
  45.                 if (q->sitd->hw_fullspeed_ep &  
  46.                         cpu_to_hc32(ehci, 1<<31))  
  47.                     usecs += q->sitd->stream->usecs;// 全速设备的，In同步端点传输，对应的start split传输，最大可能的带宽保存在stream->usecs里  
  48.                 else    /* worst case for OUT start-split */  
  49.                     usecs += HS_USECS_ISO (188);//全速设备的OUT同步端点传输，只有start-split+data传输，没有cspllist传输，out传输所允许最大的包大小就是188个字节  
  50.             }  
  51.   
  52.             /* ... C-mask?  (count CSPLIT, DATA) */  
  53.             if (q->sitd->hw_uframe &  
  54.                     cpu_to_hc32(ehci, 1 << (8 + uframe))) {  
  55.                 /* worst case for IN complete-split */  
  56.                 usecs += q->sitd->stream->c_usecs;//全速设备的IN同步端点，他的csplit传输，包含了data阶段，所允许的最大带宽保存在stream->usecs里。  
  57.             }  
  58.   
  59.             hw_p = &q->sitd->hw_next;  
  60.             q = &q->sitd->sitd_next;  
  61.             break;  
  62.         }  
  63.     }  
  64. #ifdef  DEBUG  
  65.     if (usecs > ehci->uframe_periodic_max)  
  66.         ehci_err (ehci, "uframe %d sched overrun: %d usecs\n",  
  67.             frame * 8 + uframe, usecs);  
  68. #endif  
  69.     return usecs;  
  70. }  

itd_slot_ok函数确定在uframe>>3的大帧中的第uframe&0x7个微帧位置，预算调度一个带宽为usecs时长的传输，是否符合同步带宽的约束条件（即总得周期带宽不能超过整个微帧总线带宽的80%）
[cpp]  view plain  copy
 
 
  1. static inline int  
  2. itd_slot_ok (  
  3.     struct ehci_hcd     *ehci,  
  4.     u32         mod,  //mod即为1024*8  
  5.     u32         uframe,  
  6.     u8          usecs,  
  7.     u32         period //每隔多少个微帧发起一个同步传输  
  8. )  
  9. {  
  10.     uframe %= period;//uframe的范围为0...(period-1)  
  11.     do {  
  12.         /* can't commit more than uframe_periodic_max usec */  
  13.         if (periodic_usecs (ehci, uframe >> 3, uframe & 0x7)  
  14.                 > (ehci->uframe_periodic_max - usecs))  
  15.             return 0;  
  16.   
  17.         /* we know urb->interval is 2^N uframes */  
  18.         uframe += period;  
  19.     } while (uframe < mod);//遍历整个周期帧列表，即有个1024个列表，而每个列表中的每项又包含了8个微帧的带宽分布情况  
  20.     return 1;  
  21. }  

sitd_slot_ok函数的功能：确定在frame大帧中的第uframe微帧，预算一个分裂传输stream，是否ok？
该函数的理解确实是比较艰辛的，我相信如果读者对这个函数已经彻底理解了，那他对分裂传输也就理解的差不多了。应该具备了自己创造的基础了。预算调度高速的同步传输和预算调度低速同步分裂传输相比，预算低速同步分裂传输的调度要复杂的多。
为了把这个复杂的问题清楚的描述出来，我们分如下几个步骤：
  • 分裂传输，涉及到TT，那也就是说，会同时涉及高速周期传输和低速周期传输，那要往这个frame大帧上预算分配一个调度（用stream来表述这个调度，类似qh的功能，一个同步端点对应一个stream），则这个调度要同时满足两个约束：
    • 在高速总线带宽这边，要满足在对应的微帧中（125us），周期传输不能超过总线带宽的80%
    • 同时在低速总线带宽这边，也要满足在对应的大帧中（1000us即1ms），周期传输不能超过总线带宽的90%
  • 如果是OUT同步分裂传输，由于他只有start split+data阶段，没有csplit阶段，并且在data长度大于188字节时，会包含多个连续的start split+data阶段，就要保证每个split阶段对应的微帧的周期带宽都符合约束条件
  • 如果是IN同步分裂传输，他是由：start split , csplit +IN + data阶段组成，所以主要是检查在发起csplist传输的微帧，它的周期带宽是否符合周期带宽的约束，由于会在多个微帧发起这个cplit传输，所以要根据cmask位检查多个对应的微帧
  • stream->raw_mask是未移位的smask和cmask位掩码。在微帧uframe的位置确定后，就需要将stream->raw_mask集体向左移位uframe & 7位，即：stream->splits = stream->raw_mask << (uframe & 7)
[cpp]  view plain  copy
 
 
  1. static inline int  
  2. sitd_slot_ok (  
  3.     struct ehci_hcd     *ehci,  
  4.     u32         mod,  
  5.     struct ehci_iso_stream  *stream,  
  6.     u32         uframe,  
  7.     struct ehci_iso_sched   *sched,  
  8.     u32         period_uframes  
  9. )  
  10. {  
  11.     u32         mask, tmp;  
  12.     u32         frame, uf;  
  13.   
  14.     mask = stream->raw_mask << (uframe & 7);  
  15.   
  16.     /* for IN, don't wrap CSPLIT into the next frame */  
  17.     if (mask & ~0xffff)  //目前尚不支持分裂传输跨H frame边界  
  18.         return 0;  
  19.   
  20.     /* this multi-pass logic is simple, but performance may 
  21.      * suffer when the schedule data isn't cached. 
  22.      */  
  23.   
  24.     /* check bandwidth */  
  25.     uframe %= period_uframes;// 范围：0  
  26.     do {  
  27.         u32     max_used;  
  28.   
  29.         frame = uframe >> 3;//计算对应的大帧  
  30.         uf = uframe & 7;  //计算对应的微帧  
  31.   
  32. #ifdef CONFIG_USB_EHCI_TT_NEWSCHED  
  33.         /* The tt's fullspeed bus bandwidth must be available. 
  34.          * tt_available scheduling guarantees 10+% for control/bulk. 
  35.          */  
  36.         if (!tt_available (ehci, period_uframes << 3,  
  37.                 stream->udev, frame, uf, stream->tt_usecs))//确定在对应的大帧是否有足够可用的低速周期带宽来发起这次分裂周期传输  
  38.             return 0;  
  39. #else  
  40.         /* tt must be idle for start(s), any gap, and csplit. 
  41.          * assume scheduling slop leaves 10+% for control/bulk. 
  42.          */  
  43.         if (!tt_no_collision (ehci, period_uframes << 3,  
  44.                 stream->udev, frame, mask))  
  45.             return 0;  
  46. #endif  
  47.   
  48.         /* check starts (OUT uses more than one) */  
  49.         max_used = ehci->uframe_periodic_max - stream->usecs;  
  50.         for (tmp = stream->raw_mask & 0xff; tmp; tmp >>= 1, uf++) {//如果是OUT分裂传输，我们要确定在连续的这几个分裂OUT周期传输所对应的微帧是否有足够可用的周期带宽  
  51.             if (periodic_usecs (ehci, frame, uf) > max_used)  
  52.                 return 0;  
  53.         }  
  54.   
  55.         /* for IN, check CSPLIT */  
  56.         if (stream->c_usecs) { //如果是IN分裂传输，我们要判断，在多个csplit传输对应的微帧是否都有足够可用的周期带宽  
  57.             uf = uframe & 7;  
  58.             max_used = ehci->uframe_periodic_max - stream->c_usecs;  
  59.             do {  
  60.                 tmp = 1 << uf;  
  61.                 tmp <<= 8;  
  62.                 if ((stream->raw_mask & tmp) == 0)  
  63.                     continue;  
  64.                 if (periodic_usecs (ehci, frame, uf)  
  65.                         > max_used)  
  66.                     return 0;  
  67.             } while (++uf < 8);  
  68.         }  
  69.   
  70.         /* we know urb->interval is 2^N uframes */  
  71.         uframe += period_uframes;  
  72.     } while (uframe < mod);  
  73.   
  74.     stream->splits = cpu_to_hc32(ehci, stream->raw_mask << (uframe & 7));//保存移位后的smask和cmask  
  75.     return 1;  
  76. }  
tt_available函数用来确定TT在frame/uframe（第frame（0
[cpp]  view plain  copy
 
 
  1. /* 
  2.  * Return true if the device's tt's downstream bus is available for a 
  3.  * periodic transfer of the specified length (usecs), starting at the 
  4.  * specified frame/uframe.  Note that (as summarized in section 11.19 
  5.  * of the usb 2.0 spec) TTs can buffer multiple transactions for each 
  6.  * uframe. 
  7.  * 
  8.  * The uframe parameter is when the fullspeed/lowspeed transfer 
  9.  * should be executed in "B-frame" terms, which is the same as the 
  10.  * highspeed ssplit's uframe (which is in "H-frame" terms).  For example 
  11.  * a ssplit in "H-frame" 0 causes a transfer in "B-frame" 0. 
  12.  * See the EHCI spec sec 4.5 and fig 4.7. 
  13.  * 
  14.  * This checks if the full/lowspeed bus, at the specified starting uframe, 
  15.  * has the specified bandwidth available, according to rules listed 
  16.  * in USB 2.0 spec section 11.18.1 fig 11-60. 
  17.  * 
  18.  * This does not check if the transfer would exceed the max ssplit 
  19.  * limit of 16, specified in USB 2.0 spec section 11.18.4 requirement #4, 
  20.  * since proper scheduling limits ssplits to less than 16 per uframe. 
  21.  */  
  22. static int tt_available (  
  23.     struct ehci_hcd     *ehci,  
  24.     unsigned        period,  
  25.     struct usb_device   *dev,  
  26.     unsigned        frame,  
  27.     unsigned        uframe,  
  28.     u16         usecs  
  29. )  
  30. {  
  31.     if ((period == 0) || (uframe >= 7))  /* error */  
  32.         return 0;  
  33.   
  34.     for (; frame < ehci->periodic_size; frame += period) {  
  35.         unsigned short tt_usecs[8];  
  36.   
  37.         periodic_tt_usecs (ehci, dev, frame, tt_usecs);//确定在frame大帧中（对应1000us），有多少带宽已经被全速周期传输占用了，并将他们记录在tt_usecs数组中。  
  38.   
  39.         ehci_vdbg(ehci, "tt frame %d check %d usecs start uframe %d in"  
  40.             " schedule %d/%d/%d/%d/%d/%d/%d/%d\n",  
  41.             frame, usecs, uframe,  
  42.             tt_usecs[0], tt_usecs[1], tt_usecs[2], tt_usecs[3],  
  43.             tt_usecs[4], tt_usecs[5], tt_usecs[6], tt_usecs[7]);  
  44.   
  45.         if (max_tt_usecs[uframe] <= tt_usecs[uframe]) {  
  46.             ehci_vdbg(ehci, "frame %d uframe %d fully scheduled\n",  
  47.                 frame, uframe);  
  48.             return 0;  
  49.         }  
  50.   
  51.         /* special case for isoc transfers larger than 125us: 
  52.          * the first and each subsequent fully used uframe 
  53.          * must be empty, so as to not illegally delay 
  54.          * already scheduled transactions 
  55.          */  
  56.         if (125 < usecs) {//对于那些带宽大于125us的周期传输，我们要求第一个和随后的几个微帧都必须是空的，不然当前的周期传输就会被非法的延迟。  
  57.             int ufs = (usecs / 125);  
  58.             int i;  
  59.             for (i = uframe; i < (uframe + ufs) && i < 8; i++)  
  60.                 if (0 < tt_usecs[i]) {  
  61.                     ehci_vdbg(ehci,  
  62.                         "multi-uframe xfer can't fit "  
  63.                         "in frame %d uframe %d\n",  
  64.                         frame, i);  
  65.                     return 0;  
  66.                 }  
  67.         }  
  68.   
  69.         tt_usecs[uframe] += usecs;  
  70.   
  71.         carryover_tt_bandwidth(tt_usecs);  
  72.   
  73.         /* fail if the carryover pushed bw past the last uframe's limit */  
  74.         if (max_tt_usecs[7] < tt_usecs[7]) {  
  75.             ehci_vdbg(ehci,  
  76.                 "tt unavailable usecs %d frame %d uframe %d\n",  
  77.                 usecs, frame, uframe);  
  78.             return 0;  
  79.         }  
  80.     }  
  81.   
  82.     return 1;  
  83. }  
下面这个数组，是表示周期传输在全速总线带宽的约束下，在8个微帧中的最佳总线带宽分配时间。
[cpp]  view plain  copy
 
 
  1. static const unsigned char  
  2. max_tt_usecs[] = { 125, 125, 125, 125, 125, 125, 30, 0 };  

periodic_tt_usecs函数用来计算目前这个大帧中（刚好对应1000us=1ms），TT设备中有多少全速、低速周期传输已经被占用了。由于在高速总线下，只可能存在TT类型的全速和低速设备，所以我们统计全速设备在当前大帧中的总线带宽，我们只需统计中断分裂传输和同步分裂传输。而每个全速、低速设备的中断端点所占的最大总线带宽保存在qh->tt_usecs中，而同步高速端点所占的最大总线带宽保存在stream->tt_usecs中。
如下面函数开头的英文注释所说，低速设备是没有微帧的概念的，所以他们的一个传输是可以跨微帧的边界的。

另外需要注意的是：对于同一个全速、低速中断端点而言，在一个大帧中，最多只有一次传输（即qh->smask只可能有一个bit位为1），因为他们的最低分辨率就是1ms，但对于同一个高速中断端点，则不然，他可以在一个大帧中，最多可以发起8个中断传输，即一个微帧一次。

为了加深对下面函数的理解，我们可以假设这样一个全速设备：它由1个同步IN端点，1个同步OUT端点，1个中断IN端点，1个中断OUT端点，总计4个端点构成。则他们在周期列表frame帧中，对应的列表构成如下：
sitd(IN,smask:0000 000 1)-->sitd(OUT,smask:0000 00 10)-->qh(IN,smask:000 1 0000)--->qh(OUT,smask:000 1 0000)
[cpp]  view plain  copy
 
 
  1. /* How many of the tt's periodic downstream 1000 usecs are allocated? 
  2.  * 
  3.  * While this measures the bandwidth in terms of usecs/uframe, 
  4.  * the low/fullspeed bus has no notion of uframes, so any particular 
  5.  * low/fullspeed transfer can "carry over" from one uframe to the next, 
  6.  * since the TT just performs downstream transfers in sequence. 
  7.  * 
  8.  * For example two separate 100 usec transfers can start in the same uframe, 
  9.  * and the second one would "carry over" 75 usecs into the next uframe. 
  10.  */  
  11. static void  
  12. periodic_tt_usecs (  
  13.     struct ehci_hcd *ehci,  
  14.     struct usb_device *dev,  
  15.     unsigned frame,  
  16.     unsigned short tt_usecs[8]  
  17. )  
  18. {  
  19.     __hc32          *hw_p = &ehci->periodic [frame];  
  20.     union ehci_shadow   *q = &ehci->pshadow [frame];  
  21.     unsigned char       uf;  
  22.   
  23.     memset(tt_usecs, 0, 16);  
  24.   
  25.     while (q->ptr) {  
  26.         switch (hc32_to_cpu(ehci, Q_NEXT_TYPE(ehci, *hw_p))) {  
  27.         case Q_TYPE_ITD:  
  28.             hw_p = &q->itd->hw_next;  
  29.             q = &q->itd->itd_next;  
  30.             continue;  
  31.         case Q_TYPE_QH:  
  32.             if (same_tt(dev, q->qh->dev)) {  
  33.                 uf = tt_start_uframe(ehci, q->qh->hw->hw_info2);//通过查看s-mask位，全速、低速中断传输将在哪个微帧被发起  
  34.                 tt_usecs[uf] += q->qh->tt_usecs;//对应的全速、低速中断传输的最大带宽  
  35.             }  
  36.             hw_p = &q->qh->hw->hw_next;  
  37.             q = &q->qh->qh_next;  
  38.             continue;  
  39.         case Q_TYPE_SITD:  
  40.             if (same_tt(dev, q->sitd->urb->dev)) {  
  41.                 uf = tt_start_uframe(ehci, q->sitd->hw_uframe);//通过查看s-mask位，全速、低速同步传输在哪个微帧被发起  
  42.                 tt_usecs[uf] += q->sitd->stream->tt_usecs;//低速同步带宽的最大带宽  
  43.             }  
  44.             hw_p = &q->sitd->hw_next;  
  45.             q = &q->sitd->sitd_next;  
  46.             continue;  
  47.         // case Q_TYPE_FSTN:  
  48.         default:  
  49.             ehci_dbg(ehci, "ignoring periodic frame %d FSTN\n",  
  50.                     frame);  
  51.             hw_p = &q->fstn->hw_next;  
  52.             q = &q->fstn->fstn_next;  
  53.         }  
  54.     }  
  55.   
  56.     carryover_tt_bandwidth(tt_usecs);  
  57.   
  58.     if (max_tt_usecs[7] < tt_usecs[7])  
  59.         ehci_err(ehci, "frame %d tt sched overrun: %d usecs\n",  
  60.             frame, tt_usecs[7] - max_tt_usecs[7]);  
  61. }  

itd_link_urb函数： 将urb对应的itd链接到硬件对应的周期列表中
[cpp]  view plain  copy
 
 
  1. /* fit urb's itds into the selected schedule slot; activate as needed */  
  2. static int  
  3. itd_link_urb (  
  4.     struct ehci_hcd     *ehci,  
  5.     struct urb      *urb,  
  6.     unsigned        mod,  
  7.     struct ehci_iso_stream  *stream  
  8. )  
  9. {  
  10.     int         packet;  
  11.     unsigned        next_uframe, uframe, frame;  
  12.     struct ehci_iso_sched   *iso_sched = urb->hcpriv;  
  13.     struct ehci_itd     *itd;  
  14.   
  15.     next_uframe = stream->next_uframe & (mod - 1);//itd被连入的位置  
  16.   
  17.     if (unlikely (list_empty(&stream->td_list))) {  
  18.         ehci_to_hcd(ehci)->self.bandwidth_allocated  
  19.                 += stream->bandwidth;  
  20.         ehci_vdbg (ehci,  
  21.             "schedule devp %s ep%d%s-iso period %d start %d.%d\n",  
  22.             urb->dev->devpath, stream->bEndpointAddress & 0x0f,  
  23.             (stream->bEndpointAddress & USB_DIR_IN) ? "in" : "out",  
  24.             urb->interval,  
  25.             next_uframe >> 3, next_uframe & 0x7);  
  26.     }  
  27.   
  28.     if (ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs == 0) {  
  29.         if (ehci->amd_pll_fix == 1)  
  30.             usb_amd_quirk_pll_disable();  
  31.     }  
  32.   
  33.     ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs++;  
  34.   
  35.     /* fill iTDs uframe by uframe */  
  36.     for (packet = 0, itd = NULL; packet < urb->number_of_packets; ) {//注意一个itd可能包含多个struct ehci_iso_packet包，  
  37.         if (itd == NULL) {  
  38.             /* ASSERT:  we have all necessary itds */  
  39.             // BUG_ON (list_empty (&iso_sched->td_list));  
  40.   
  41.             /* ASSERT:  no itds for this endpoint in this uframe */  
  42.   
  43.             itd = list_entry (iso_sched->td_list.next,  
  44.                     struct ehci_itd, itd_list);  //iso_sched结构对应一个urb（是一一对应的），里面保存了用于填充itd的成员，iso_sched结构可以对应多个itd成员（1对多）。  
  45.             list_move_tail (&itd->itd_list, &stream->td_list);//将这个itd连入到stream->td_list列表中  
  46.             itd->stream = iso_stream_get (stream);  
  47.             itd->urb = urb;  
  48.             itd_init (ehci, stream, itd);//初始化itd，主要是包含一些同步端点的信息  
  49.         }  
  50.   
  51.         uframe = next_uframe & 0x07;  
  52.         frame = next_uframe >> 3;  
  53.   
  54.         itd_patch(ehci, itd, iso_sched, packet, uframe);//初始化同步端点在uframe微帧位置对应的传输描述，包括：itd->hw_transaction，pg，itd->hw_bufp  
  55.   
  56.         next_uframe += stream->interval;//跳到下一个填充微帧的位置  
  57.         next_uframe &= mod - 1;  
  58.         packet++;  
  59.   
  60.         /* link completed itds into the schedule */  
  61.         if (((next_uframe >> 3) != frame)  
  62.                 || packet == urb->number_of_packets) {//如果越过了itd结构对应的大帧frame，则这个itd连入到周期调度列表中  
  63.             itd_link(ehci, frame & (ehci->periodic_size - 1), itd);//详细见下面的描述  
  64.             itd = NULL;  
  65.         }  
  66.     }  
  67.     stream->next_uframe = next_uframe;//用于下次调度的插入位置  
  68.   
  69.     /* don't need that schedule data any more */  
  70.     iso_sched_free (stream, iso_sched);  
  71.     urb->hcpriv = NULL;  
  72.   
  73.     timer_action (ehci, TIMER_IO_WATCHDOG);  
  74.     return enable_periodic(ehci);  
  75. }  

该函数将itd链入到frame参数（0
[cpp]  view plain  copy
 
 
  1. static inline void  
  2. itd_link (struct ehci_hcd *ehci, unsigned frame, struct ehci_itd *itd)  
  3. {  
  4.     union ehci_shadow   *prev = &ehci->pshadow[frame];//取得这个周期调度列表对应的软件部分  
  5.     __hc32          *hw_p = &ehci->periodic[frame];//取得这个周期调度列表对应的硬件部分  
  6.     union ehci_shadow   here = *prev;  
  7.     __hc32          type = 0;  
  8.   
  9.     /* skip any iso nodes which might belong to previous microframes */  //注意要跳过前面已经链入的所有同步节点。因为可以肯定的是，他们都是在当前要连入的微帧之前  
  10.     while (here.ptr) {  
  11.         type = Q_NEXT_TYPE(ehci, *hw_p);  
  12.         if (type == cpu_to_hc32(ehci, Q_TYPE_QH))//已连入的同步节点之后，中断节点之前： itd--itd--itd（new added node）---qh---qh  
  13.             break;  
  14.         prev = periodic_next_shadow(ehci, prev, type);  
  15.         hw_p = shadow_next_periodic(ehci, &here, type);  
  16.         here = *prev;  
  17.     }  
  18.   
  19.     itd->itd_next = here;//操作如下：itd--itd（prev）--itd（new added node）--qh（here）  
  20.     itd->hw_next = *hw_p;  
  21.     prev->itd = itd;  
  22.     itd->frame = frame;  
  23.     wmb ();  
  24.     *hw_p = cpu_to_hc32(ehci, itd->itd_dma | Q_TYPE_ITD);  
  25. }  

该函数的功能就是将urb对应的sitds插入到指定的周期调度时隙中。其中这个urb对应sitd数目等于urb->number_of_packets，即sitd跟ehci_iso_packet结构是一一对应的。对于同一个端点，sitd跟大帧是一一对应的，即一个sitd对应一个大帧。而高速同步端点，一个itd可能对应多个ehci_iso_packet结构

你可能感兴趣的:(usb,usb,EHCI)

  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南） 诚芯微科技 社交电子
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
  • 摩托车加装车载手机充电usb方案/雅马哈USB充电方案开发 诚芯微科技 社交电子
    长途骑行需要给手机与行车记录仪等设备供电，那么，加装USB充电器就相继在两轮电动车上应用起来了。摩托车加装usb充电方案主要应用于汽车、电动自行车、摩托车、房车、渡轮、游艇等交通工具。提供电动车USB充电器方案/摩托车加装usb充电方案/渡轮加装usb充电方案/游艇加装usb充电方案开发。摩托车加装车载手机充电usb方案、汽车游艇改装四孔面板装双USB车充点烟器5V/4A电动车USB充电器输入4.
  • HBuilderX真机运行安卓APP hello_world_Q android
    前提：1.安卓设备进入开发者模式（设置-系统-关于本机-点击版本号直至出现已进入开发者模式提醒）2.找到开发者选项-打开USB调试3.下图4.下图
  • 使用FPGA接收MIPI CSI RX信号并进行去抖动、RGB转YUV处理：FX3014 USB3.0 UVC传输与帧率控制源代码，FPGA实现MIPI CSI RX接收，去Debayer， RGB转 kVfINoSzdrt fpga开发程序人生
    fpgamipicsirx接收去debayer,rgb转yuv,fx3014usb3.0uvc传输与帧率控制源代码，具体架构看图，除dphy物理层外，mipi均为源码sensorimx219mipi源码mipi4lanecsirxraw10fpgamachXO3lf-690usb3.0fx301432bityuvdatawithframesync测试模式3280*246415fps1920*108
  • ROM修改进阶教程------如何修改固件 线刷转卡刷 卡刷转线刷 操作中的一些注意事项 安卓机器 ROM修改进阶教程卡刷转换线刷线刷转换卡刷固件转换
    在接待各种rom定制化服务中。有很多客户需要各种各样的需求。包括修改rom默认开启usb调试类默认开启开发者选项。修改不锁屏不休眠跳过开机引导以及一些内置app和可卸载app等等的定制项目。还有很多导出系统导出数据完整恢复类要求。今天给大家解析下如何将固件转换类的相关步骤解析通过博文可以了解;1--------线刷固件转换卡刷固件的注意事项以及步骤2--------卡刷固件转换线刷固件的注意事项以
  • Adb无线连接调试 EHCB adbandroid
    1.在开发者选项打开usb调试，以及无线调试2.手机连接wifi，进入设置静态ip地址，网关3.手机通过usb先连接电脑4.adbdevices命令检查设备连接情况5.adbtcpip55556.adb-s255d50d7tcpip5555（255d50d7为第4步获取的设备号）7.断开手机与PC的USB连接8.adbconnect192.168.200.220:5555（ip为第2步设置的ip地
  • GD32的虚拟串口CDC的一些注意事项 跳动的代码 单片机mcu
    在移植GD32CDC的USB虚拟串口，即CDC设备时，需要注意一下几点。我这里已GD32E503为例。1、时钟要正确，GD32E503的时钟必须为168M才能用2、硬件问题，GD32E503的USB必须要三个脚，除了DPDM外，还有DP一个上拉脚要配置。3、不要忘了移植中断部分代码，USB是有中断函数的。4、关于CDC的发送和接收问题：用官方的例程，发送和接收是没问题的。但是在我们代码里是不能直接
  • python离线安装pip 于光yuguang pythonpip开发语言
    如果您的服务器没有互联网连接，您仍然可以通过其他方式将pip安装到服务器上。以下是一种可能的方法：方法一：离线安装下载pip安装文件：在另一台联网的计算机上，下载pip的安装文件（.whl文件）以及其依赖项的安装文件（如果有）。可以从PyPI下载pip的.whl文件。传输文件：将下载的.whl文件和依赖项文件通过USB等方式传输到没有互联网的服务器上。安装pip：在服务器上，使用pip的安装文件进
  • ROS yaml参数文件的使用 Sun Shiteng ROS
    举个例子，若在params.yaml文件中定义如下参数LidarImageFusion:points_src:"/hilbert_h/deskew/cloud_info"image_src:"/usb_cam0/image_raw"camera_info_src:"/home/hdj/fusion_slam/Color_SLAM_ws/src/hilbert_h/config/firefly_8s
  • ROS下使用usb_cam驱动读取摄像头数据 小杨~~~~ ubuntu
    因为darknet_ros会直接订阅指定的图像话题名，然后对图像进行检测，绘制检测框，并发布相应的检测话题，因此首先需要找一个能够发布图像话题的ROS包，这里经推荐使用ROS官方提供的usb_cam驱动包，可以直接将小车摄像头采集的图像发布为ROS图像话题。1、下载摄像头驱动包usb_cam#方式一：直接终端输入，通过apt便捷安装cdtest/src/sudoapt-getinstallros-
  • 关于ROS调用USB摄像头的一些问题 Robot_hfut ROS
    一.基本途径1.使用sudo安装使用以下命令安装usb-cam包，对于kinetic版本：roscoresudoapt-getinstallros-kinetic-usb-camroslaunchusb_camusb_cam-test.launch2.使用源代码安装使用以下命令安装usb-cam包：cdcatkin_ws/srcgitclonehttps://github.com/bosch-ro
  • Android移动测试入门—— adb 测试环境搭建及常用命令 蘑菇头上不长草 Androidadbpython爬虫requestandroid
    目录搭建abd环境安装jdk并配置环境变量安装adb并配置环境常用命令连接设备1.打开开发者模式2.USB连接移动设备3.查看连接设备4.进入手机5.adbpush电脑文件上传到手机6.adbpull从手机里下载文件到电脑7.adbinstall安装app8.查看手机上安装的所有软件（查看包名）9.卸载app10.monkey测试11.logcat搭建abd环境adb环境搭建主要分为2部分，一是j
  • 3. 测试Docker镜像 jcfszxc RKNN系列RKNNrknn-toolkit2
    运行命令进入Docker镜像：dockerrun-t-i--privileged\-v/dev/bus/usb:/dev/bus/usb\-v/path/to/your/project:/examples\rknn-toolkit2:2.1.0-cp38\/bin/bash参数解释：dockerrun:这是Docker的基本命令，用于创建和启动一个新的容器。-t:分配一个伪终端（pseudo-TT
  • 电脑的问题简单判断及保养 哲伦贼稳妥 电脑硬件IT技术电脑经验分享硬件工程其他
    1电脑过热一般电脑过热有以下几种情况1.长时间没有清理散热风扇及更换硅脂，建议每年清理一次风扇及更换硅脂，并对电脑进行清灰2.散热风扇出现问题，具体表现在电脑声音不正常，异响或发出刺耳的蜂鸣声，建议直接更换风扇3.天气过热，建议采取物理降温，比如打开机箱的侧盖和风扇空调等4长时间使用，如感觉电脑过热，可以稍微休息一会，等待电脑温度稍微降下来后再继续使用2.USB端口失灵1.重启电脑重启电脑可以解决
  • USB HOST DWC3 初始化 wing_7 usbusbdwc
    https://www.cnblogs.com/newjiang/p/15675746.html如果dr_mode为device，则初始化gadget。如果dr_mode为host，需要初始化xHCI驱动。在dwc3_host_init函数的最后调用platform_device_add(xhci)添加platformdevice（xhci-hcd），用于匹配xHCIdriver（xHCIdriv
  • zynq usb dwc3中断事件异常 charschu linux-usb驱动开发
    最近在调试zynq的usb，发现一个问题，给pcbulk传输吐log，传输速率1MB左右速率发包，发现会传输终止，调用epsend接口会失败原因在于没有收到传输完成事件，收到连续2次notready事件，这种情况usbbusy标志没有清除，结果send会进入updatethansfer分支指令，但是此时usbhardware已经释放了sourceindex，会挂死掉这里，这样说明硬件已经发送了完成
  • 【Linux】 LTG：移动硬盘部署Ubuntu24.04 T0uken linux数据库运维
    UbuntuToGo是一种便携式的Ubuntu操作系统解决方案，允许用户将Ubuntu系统安装在USB驱动器或其他可移动存储设备上。这样，用户可以在任何支持USB启动的计算机上运行Ubuntu，而无需在本地硬盘上进行安装。准备工作移动硬盘：确保移动硬盘有足够的空间（建议至少16GB或更大）。启动U盘：准备一个用于创建Ubuntu启动盘的U盘，容量建议为4GB或更大。安装媒体：下载UbuntuISO
  • 网络安全 L1 Introduction to Security h08.14 网络安全web安全安全
    Informationsecurity1.Theprocessofpreventinganddetectingunauthoriseduseofyourinformation.2.Thescienceofguardinginformationsystemsandassetsagainstmaliciousbehavioursofintelligentadversaries.3.Securityvs
  • usbserver工程师手记(四）ft2usbhub服务启动不了 c++代码诗人 usbserver工程师手记linux服务器
    技术支持：可能他用360扫描或者驱动精灵的时候，把驱动给卸载了客户：老师确定下原因，用户那面着急用电脑了技术支持向日葵远程登录......技术支持：卸载客户端，重新安装一下就可以客户：我们要确定问题的原因那客户：用户那面允许我们继续排查客户领导：需要确定影响原因，不能是：可能、应该客户领导：有些杀毒软件是可以看到被加入杀毒软件黑名单/被杀毒软件被删除的文件我们的服务理念：客户的问题就是我们的问题.
  • adb不弹出授权提示的终极杀招 吉凶以情迁
    e6e4d42c0204unauthorized一个命令解决,曾经尝试过拔掉usb线或者在手机上开关usb调试，但是没啥效果，taskkill/f/imadb*直接杀死adb,重新打开一次，就提示了。
  • 基于STM32设计的酒驾检测报警系统(OneNet+4G模块)(222) DS小龙哥 智能家居与物联网项目实战stm32嵌入式硬件单片机酒驾检测酒驾监测
    文章目录一、前言1.1项目介绍【1】项目背景【2】项目实现的功能【3】项目硬件模块组成1.2设计思路1.3项目开发背景【1】选题的意义【2】可行性分析【3】参考文献【4】摘要1.4开发工具的选择【1】设备端开发【2】可视化页面开发1.5系统框架图1.6系统功能总结1.7设备原理图1.8硬件实物图二、硬件选型2.1STM32开发板2.2USB下载线2.3杜邦线（2排）2.4OLED显示屏2.5Air
  • php 扫描条形码,将条形码扫描仪集成到PHP应用程序中？ weixin_39575054 php扫描条形码
    PHP可以很容易地用于阅读打印在纸质文档上的条形码。通过USB将手动条形码读取器连接到计算机，显着地将PHP(或任何其他Web编程语言)的可用性扩展到涉及文档和产品管理的任务，例如在数据库中查找书记录或列出特定客户的所有帐单。以下部分简要介绍了使用PHP连接和使用手动条形码读取器的过程。Theusageofbarcodescannersdescribedinthisarticleareinthes
  • 单片机软件工程师确认硬件 蓝黑墨水 单片机嵌入式硬件
    文章目录简介流程确认能连接usb和调试器确认芯片信息确认芯片存储是否正常确认屏幕是否能点亮确认其他硬件方式方法简介硬件工程师给出板子后，后面就是软件工程师的事儿了。通常来说并不会很顺利。流程确认能连接usb和调试器也是在“计算机管理”中或者在keil调试那里能发现你连的板子。确认芯片信息1，直接用眼看上面的封装信息2，使用相关命令确认一下确认芯片存储是否正常主要是确认芯片的存储是否正常。好几种情况
  • c语言中char16_t是什么类型,错误[Pe167]：类型为“uint16_t *”的参数与类型为“unsigned char *”的参数不兼容... 于西奥
    我想通过usb建立tablet与stm32之间的通信，为此我在代码中添加了usb库。在代码中添加库我得到了这个错误。错误[Pe167]：类型为“uint16_t*”的参数与类型为“unsignedchar*”的参数不兼容错误[Pe167]：类型的参数“uint16_t*”是类型为“无符号字符*”我使用的参数不兼容的IAREmbeddedWorkbenchEWARM工具STM32coding.Err
  • Windows Hello 可绕过漏洞进行身份认证 H_00c8
    Windows安全漏洞将允许攻击者欺骗用于系统生物特征面部识别方面的USB摄像头。微软Windows10无密码身份验证系统中的一个漏洞已被发现，攻击者可以利用该漏洞欺骗人脸图像以欺骗面部识别系统并控制设备。【网安资料】WindowsHello是Windows10提供的一个新的安全功能，该功能通过生物识别技术为小伙伴们带来指纹、人脸和虹膜等多种身份验证方式，具有极高的安全性。只有具备特定的硬件设备才
  • 在国产芯片上实现YOLOv5/v8图像AI识别-【4.2】RK3588获取USB摄像头图像推流RTSP更多内容见视频 橘子的战斗日记 YOLO人工智能音视频
    本专栏主要是提供一种国产化图像识别的解决方案，专栏中实现了YOLOv5/v8在国产化芯片上的使用部署，并可以实现网页端实时查看。根据自己的具体需求可以直接产品化部署使用。B站配套视频：https://www.bilibili.com/video/BV1or421T74f前言在实际生产过程中，有很多时候不光是通过网络获取rtsp视频流，通常会采用在板子上插上USB摄像头获取画面。今天我将向搭建演示该
  • 六、部署与验证 机 ＿ 长 人工智能目标检测计算机视觉深度学习
    在算法嵌入式部署的最终阶段，部署与验证是确保算法能够在目标嵌入式设备上正确运行并满足预期功能要求的关键步骤。以下是对这一环节的详细扩写：部署1.代码编译与链接将优化后的代码使用适合嵌入式设备的交叉编译器进行编译，生成目标平台的机器码。根据需要，将编译生成的多个目标文件链接成最终的可执行文件或固件。2.固件烧录将编译链接好的固件通过适当的接口（如JTAG、UART、USB等）烧录到嵌入式设备的存储介
  • USB驱动程序知识介绍 黄卷青灯77 USB驱动
    USB驱动程序是一类专门用于管理和控制USB（通用串行总线）设备的驱动程序，它使得操作系统能够与各种USB设备进行通信，如键盘、鼠标、存储设备、打印机等。USB驱动程序的主要作用是处理数据传输、设备识别和资源分配等任务，以确保USB设备能够正确连接并被系统识别和使用。USB驱动程序的作用设备识别与初始化：当USB设备插入电脑时，USB驱动程序负责检测设备的插入，并通过USB协议与设备通信，获取设备
  • 探索Etherkey：网络化可编程USB键盘模拟器 皮静滢Annette
    探索Etherkey：网络化可编程USB键盘模拟器etherkeyEmulateaconventionalUSBkeyboardwithascriptable,networkcapablemicrocontroller.项目地址:https://gitcode.com/gh_mirrors/et/etherkey在数字化时代，自动化和远程控制的需求日益增长。Etherkey项目应运而生，它通过一个
  • abc365 E MGNisme c++算法
    abc365E-XorSigmaProblem思路本题首先可以想到用前缀异或和维护，我们记作bi=a1⊕a2⊕⋅⋅⋅⊕aib_i=a_1\oplusa_2\oplus···\oplusa_ibi=a1⊕a2⊕⋅⋅⋅⊕ai，所求的式子就变成了∑i=0n−2∑j=i+2nbi⊕bj\sum^{n-2}_{i=0}\sum^n_{j=i+2}b_i\oplusb_j∑i=0n−2∑j=i+2nbi⊕bj
  • jQuery 键盘事件keydown ,keypress ,keyup介绍 107x jsjquerykeydownkeypresskeyup
    本文章总结了下些关于jQuery 键盘事件keydown ,keypress ,keyup介绍，有需要了解的朋友可参考。 一、首先需要知道的是： 1、keydown() keydown事件会在键盘按下时触发. 2、keyup()  代码如下 复制代码 $('input').keyup(funciton(){      
  • AngularJS中的Promise bijian1013 JavaScriptAngularJSPromise
    一.Promise         Promise是一个接口，它用来处理的对象具有这样的特点：在未来某一时刻（主要是异步调用）会从服务端返回或者被填充属性。其核心是，promise是一个带有then()函数的对象。         为了展示它的优点，下面来看一个例子，其中需要获取用户当前的配置文件： var cu
  • c++ 用数组实现栈类 CrazyMizzz 数据结构C++
    #include<iostream> #include<cassert> using namespace std; template<class T, int SIZE = 50> class Stack{ private: T list[SIZE];//数组存放栈的元素 int top;//栈顶位置 public: Stack(
  • java和c语言的雷同 麦田的设计者 java递归scaner
    软件启动时的初始化代码，加载用户信息2015年5月27号 从头学java二 1、语言的三种基本结构：顺序、选择、循环。废话不多说，需要指出一下几点：      a、return语句的功能除了作为函数返回值以外，还起到结束本函数的功能，return后的语句 不会再继续执行。      b、for循环相比于whi
  • LINUX环境并发服务器的三种实现模型 被触发 linux
    服务器设计技术有很多，按使用的协议来分有TCP服务器和UDP服务器。按处理方式来分有循环服务器和并发服务器。 1  循环服务器与并发服务器模型 在网络程序里面，一般来说都是许多客户对应一个服务器，为了处理客户的请求，对服务端的程序就提出了特殊的要求。 目前最常用的服务器模型有： ·循环服务器：服务器在同一时刻只能响应一个客户端的请求 ·并发服务器：服
  • Oracle数据库查询指令 肆无忌惮_ oracle数据库
    20140920   单表查询 -- 查询************************************************************************************************************ -- 使用scott用户登录   -- 查看emp表   desc emp  
  • ext右下角浮动窗口 知了ing JavaScriptext
    第一种 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/
  • 浅谈REDIS数据库的键值设计 矮蛋蛋 redis
    http://www.cnblogs.com/aidandan/ 原文地址：http://www.hoterran.info/redis_kv_design 丰富的数据结构使得redis的设计非常的有趣。不像关系型数据库那样，DEV和DBA需要深度沟通，review每行sql语句，也不像memcached那样，不需要DBA的参与。redis的DBA需要熟悉数据结构，并能了解使用场景。
  • maven编译可执行jar包 alleni123 maven
    http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven <build> <plugins> <plugin> <artifactId>maven-asse
  • 人力资源在现代企业中的作用 百合不是茶 HR 企业管理
    //人力资源在在企业中的作用人力资源为什么会存在，人力资源究竟是干什么的 人力资源管理是对管理模式一次大的创新，人力资源兴起的原因有以下点： 工业时代的国际化竞争，现代市场的风险管控等等。所以人力资源 在现代经济竞争中的优势明显的存在，人力资源在集团类公司中存在着 明显的优势(鸿海集团)，有一次笔者亲自去体验过红海集团的招聘，只 知道人力资源是管理企业招聘的 当时我被招聘上了，当时给我们培训 的人
  • Linux自启动设置详解 bijian1013 linux
    linux有自己一套完整的启动体系，抓住了linux启动的脉络，linux的启动过程将不再神秘。 阅读之前建议先看一下附图。 本文中假设inittab中设置的init tree为： /etc/rc.d/rc0.d /etc/rc.d/rc1.d /etc/rc.d/rc2.d /etc/rc.d/rc3.d /etc/rc.d/rc4.d /etc/rc.d/rc5.d /etc
  • Spring Aop Schema实现 bijian1013 javaspringAOP
    本例使用的是Spring2.5 1.Aop配置文件spring-aop.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmln
  • 【Gson七】Gson预定义类型适配器 bit1129 gson
    Gson提供了丰富的预定义类型适配器，在对象和JSON串之间进行序列化和反序列化时，指定对象和字符串之间的转换方式，   DateTypeAdapter   public final class DateTypeAdapter extends TypeAdapter<Date> { public static final TypeAdapterFacto
  • 【Spark八十八】Spark Streaming累加器操作（updateStateByKey) bit1129 update
    在实时计算的实际应用中，有时除了需要关心一个时间间隔内的数据，有时还可能会对整个实时计算的所有时间间隔内产生的相关数据进行统计。 比如： 对Nginx的access.log实时监控请求404时，有时除了需要统计某个时间间隔内出现的次数，有时还需要统计一整天出现了多少次404，也就是说404监控横跨多个时间间隔。   Spark Streaming的解决方案是累加器，工作原理是，定义
  • linux系统下通过shell脚本快速找到哪个进程在写文件 ronin47
    一个文件正在被进程写 我想查看这个进程 文件一直在增大 找不到谁在写 使用lsof也没找到 这个问题挺有普遍性的，解决方法应该很多，这里我给大家提个比较直观的方法。 linux下每个文件都会在某个块设备上存放，当然也都有相应的inode, 那么透过vfs.write我们就可以知道谁在不停的写入特定的设备上的inode。 幸运的是systemtap的安装包里带了inodewatch.stp，位
  • java-两种方法求第一个最长的可重复子串 bylijinnan java算法
    import java.util.Arrays; import java.util.Collections; import java.util.List; public class MaxPrefix { public static void main(String[] args) { String str="abbdabcdabcx";
  • Netty源码学习-ServerBootstrap启动及事件处理过程 bylijinnan javanetty
    Netty是采用了Reactor模式的多线程版本，建议先看下面这篇文章了解一下Reactor模式： http://bylijinnan.iteye.com/blog/1992325 Netty的启动及事件处理的流程，基本上是按照上面这篇文章来走的 文章里面提到的操作，每一步都能在Netty里面找到对应的代码 其中Reactor里面的Acceptor就对应Netty的ServerBo
  • servelt filter listener 的生命周期 cngolon filterlistenerservelt生命周期
    1. servlet    当第一次请求一个servlet资源时，servlet容器创建这个servlet实例，并调用他的 init(ServletConfig config)做一些初始化的工作，然后调用它的service方法处理请求。当第二次请求这个servlet资源时，servlet容器就不在创建实例，而是直接调用它的service方法处理请求，也就是说
  • jmpopups获取input元素值 ctrain JavaScript
    jmpopups 获取弹出层form表单 首先，我有一个div，里面包含了一个表单，默认是隐藏的，使用jmpopups时，会弹出这个隐藏的div，其实jmpopups是将我们的代码生成一份拷贝。 当我直接获取这个form表单中的文本框时，使用方法：$('#form input[name=test1]').val()；这样是获取不到的。 我们必须到jmpopups生成的代码中去查找这个值，$(
  • vi查找替换命令详解 daizj linux正则表达式替换查找vim
    一、查找 查找命令 /pattern<Enter> ：向下查找pattern匹配字符串 ?pattern<Enter>：向上查找pattern匹配字符串 使用了查找命令之后，使用如下两个键快速查找： n：按照同一方向继续查找 N：按照反方向查找 字符串匹配 pattern是需要匹配的字符串，例如： 1:  /abc<En
  • 对网站中的js,css文件进行打包 dcj3sjt126com PHP打包
    一，为什么要用smarty进行打包 apache中也有给js,css这样的静态文件进行打包压缩的模块，但是本文所说的不是以这种方式进行的打包，而是和smarty结合的方式来把网站中的js,css文件进行打包。 为什么要进行打包呢，主要目的是为了合理的管理自己的代码 。现在有好多网站，你查看一下网站的源码的话，你会发现网站的头部有大量的JS文件和CSS文件，网站的尾部也有可能有大量的J
  • php Yii: 出现undefined offset 或者 undefined index解决方案 dcj3sjt126com undefined
    在开发Yii 时，在程序中定义了如下方式：        if($this->menuoption[2] === 'test')，那么在运行程序时会报：undefined offset:2，这样的错误主要是由于php.ini 里的错误等级太高了，在windows下错误等级
  • linux 文件格式（1） sed工具 eksliang linuxlinux sed工具sed工具linux sed详解
    转载请出自出处： http://eksliang.iteye.com/blog/2106082 简介       sed 是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾
  • Android应用程序获取系统权限 gqdy365 android
    引用 如何使Android应用程序获取系统权限         第一个方法简单点，不过需要在Android系统源码的环境下用make来编译：         1. 在应用程序的AndroidManifest.xml中的manifest节点
  • HoverTree开发日志之验证码 hvt .netC#asp.nethovertreewebform
    HoverTree是一个ASP.NET的开源CMS，目前包含文章系统，图库和留言板功能。代码完全开放，文章内容页生成了静态的HTM页面，留言板提供留言审核功能，文章可以发布HTML源代码，图片上传同时生成高品质缩略图。推出之后得到许多网友的支持，再此表示感谢！留言板不断收到许多有益留言，但同时也有不少广告，因此决定在提交留言页面增加验证码功能。ASP.NET验证码在网上找，如果不是很多，就是特别多
  • JSON API：用 JSON 构建 API 的标准指南中文版 justjavac json
    译文地址：https://github.com/justjavac/json-api-zh_CN 如果你和你的团队曾经争论过使用什么方式构建合理 JSON 响应格式， 那么 JSON API 就是你的 anti-bikeshedding 武器。 通过遵循共同的约定，可以提高开发效率，利用更普遍的工具，可以是你更加专注于开发重点：你的程序。 基于 JSON API 的客户端还能够充分利用缓存，
  • 数据结构随记_2 lx.asymmetric 数据结构笔记
    第三章 栈与队列 一．简答题 1. 在一个循环队列中，队首指针指向队首元素的  前一个    位置。  2.在具有n个单元的循环队列中，队满时共有  n-1  个元素。  3. 向栈中压入元素的操作是先  移动栈顶指针&n
  • Linux下的监控工具dstat 网络接口 linux
    1) 工具说明dstat是一个用来替换 vmstat,iostat netstat,nfsstat和ifstat这些命令的工具, 是一个全能系统信息统计工具. 与sysstat相比, dstat拥有一个彩色的界面, 在手动观察性能状况时, 数据比较显眼容易观察; 而且dstat支持即时刷新, 譬如输入dstat 3, 即每三秒收集一次, 但最新的数据都会每秒刷新显示. 和sysstat相同的是,
  • C 语言初级入门--二维数组和指针 1140566087 二维数组c/c++指针
    /* 二维数组的定义和二维数组元素的引用 二维数组的定义： 当数组中的每个元素带有两个下标时，称这样的数组为二维数组； (逻辑上把数组看成一个具有行和列的表格或一个矩阵); 语法： 类型名 数组名[常量表达式1][常量表达式2] 二维数组的引用： 引用二维数组元素时必须带有两个下标，引用形式如下： 例如： int a[3][4];  引用：
  • 10点睛Spring4.1-Application Event wiselyman application
    10.1 Application Event Spring使用Application Event给bean之间的消息通讯提供了手段 应按照如下部分实现bean之间的消息通讯 继承ApplicationEvent类实现自己的事件 实现继承ApplicationListener接口实现监听事件 使用ApplicationContext发布消息
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他