Subversion Repositories Kolibri OS

; Implementation of periodic transaction scheduler for USB.

; Implementation of periodic transaction scheduler for USB.

; Bandwidth dedicated to periodic transactions is limited, so

; Bandwidth dedicated to periodic transactions is limited, so

; different pipes should be scheduled as uniformly as possible.

; different pipes should be scheduled as uniformly as possible.

; USB2 scheduler.

; USB2 scheduler.

; There are two parts: high-speed pipes and split-transaction pipes.

; There are two parts: high-speed pipes and split-transaction pipes.

;

;

; High-speed scheduler uses the same algorithm as USB1 scheduler:

; High-speed scheduler uses the same algorithm as USB1 scheduler:

; when adding a pipe, optimize the following quantity:

; when adding a pipe, optimize the following quantity:

;  * for every microframe, take all bandwidth scheduled to periodic transfers,

;  * for every microframe, take all bandwidth scheduled to periodic transfers,

;  * calculate maximum over all microframes,

;  * calculate maximum over all microframes,

;  * select a variant which minimizes that maximum;

;  * select a variant which minimizes that maximum;

;  * if there are several such variants,

;  * if there are several such variants,

;    prefer those that are closer to end of frame

;    prefer those that are closer to end of frame

;    to minimize collisions with split transactions;

;    to minimize collisions with split transactions;

; when removing a pipe, do nothing (except for bookkeeping).

; when removing a pipe, do nothing (except for bookkeeping).

; in: esi -> usb_controller

; in: esi -> usb_controller

; out: edx -> usb_static_ep, eax = S-Mask

; out: edx -> usb_static_ep, eax = S-Mask

proc ehci_select_hs_interrupt_list

proc ehci_select_hs_interrupt_list

; inherit some variables from usb_open_pipe

; inherit some variables from usb_open_pipe

virtual at ebp-12

virtual at ebp-12

.targetsmask    dd      ?

.targetsmask    dd      ?

.bandwidth      dd      ?

.bandwidth      dd      ?

.target         dd      ?

.target         dd      ?

                dd      ?

                dd      ?

                dd      ?

                dd      ?

.config_pipe    dd      ?

.config_pipe    dd      ?

.endpoint       dd      ?

.endpoint       dd      ?

.maxpacket      dd      ?

.maxpacket      dd      ?

.type           dd      ?

.type           dd      ?

.interval       dd      ?

.interval       dd      ?

end virtual

end virtual

; prolog, initialize local vars

; prolog, initialize local vars

        or      [.bandwidth], -1

        or      [.bandwidth], -1

        or      [.target], -1

        or      [.target], -1

        or      [.targetsmask], -1

        or      [.targetsmask], -1

        push    ebx edi         ; save used registers to be stdcall

        push    ebx edi         ; save used registers to be stdcall

; 1. In EHCI, every list describes one millisecond = 8 microframes.

; 1. In EHCI, every list describes one millisecond = 8 microframes.

; Thus, there are two significantly different branches:

; Thus, there are two significantly different branches:

; for pipes with interval >= 8 microframes, advance to 2,

; for pipes with interval >= 8 microframes, advance to 2,

; for pipes which should be planned in every frame (one or more microframes),

; for pipes which should be planned in every frame (one or more microframes),

; go to 9.

; go to 9.

; Note: the actual interval for high-speed devices is 2^([.interval]-1),

; Note: the actual interval for high-speed devices is 2^([.interval]-1),

; (the core specification forbids [.interval] == 0)

; (the core specification forbids [.interval] == 0)

        mov     ecx, [.interval]

        mov     ecx, [.interval]

        dec     ecx

        dec     ecx

        cmp     ecx, 3

        cmp     ecx, 3

        jb      .every_frame

        jb      .every_frame

; 2. Determine the actual interval in milliseconds.

; 2. Determine the actual interval in milliseconds.

        sub     ecx, 3

        sub     ecx, 3

        cmp     ecx, 5  ; maximum 32ms

        cmp     ecx, 5  ; maximum 32ms

        jbe     @f

        jbe     @f

        movi    ecx, 5

        movi    ecx, 5

@@:

@@:

; There are four nested loops,

; There are four nested loops,

; * Loop #4 (the innermost one) calculates the total periodic bandwidth

; * Loop #4 (the innermost one) calculates the total periodic bandwidth

;   scheduled in the given microframe of the given millisecond.

;   scheduled in the given microframe of the given millisecond.

; * Loop #3 calculates the maximum over all milliseconds

; * Loop #3 calculates the maximum over all milliseconds

;   in the given variant, that is the quantity we're trying to minimize.

;   in the given variant, that is the quantity we're trying to minimize.

; * Loops #1 and #2 check all variants;

; * Loops #1 and #2 check all variants;

;   loop #1 is responsible for the target millisecond,

;   loop #1 is responsible for the target millisecond,

;   loop #2 is responsible for the microframe within millisecond.

;   loop #2 is responsible for the microframe within millisecond.

; 3. Prepare for loops.

; 3. Prepare for loops.

; ebx = number of iterations of loop #1

; ebx = number of iterations of loop #1

; [esp] = delta of counter for loop #3, in bytes

; [esp] = delta of counter for loop #3, in bytes

; [esp+4] = delta between the first group and the target group, in bytes

; [esp+4] = delta between the first group and the target group, in bytes

        movi    ebx, 1

        movi    ebx, 1

        movi    edx, sizeof.ehci_static_ep

        movi    edx, sizeof.ehci_static_ep

        shl     ebx, cl

        shl     ebx, cl

        shl     edx, cl

        shl     edx, cl

        mov     eax, 64*sizeof.ehci_static_ep

        mov     eax, 64*sizeof.ehci_static_ep

        sub     eax, edx

        sub     eax, edx

        sub     eax, edx

        sub     eax, edx

        push    eax

        push    eax

        push    edx

        push    edx

; 4. Select the best variant.

; 4. Select the best variant.

; 4a. Loop #1: initialize counter = pointer to ehci_static_ep for

; 4a. Loop #1: initialize counter = pointer to ehci_static_ep for

; the target millisecond in the first group.

; the target millisecond in the first group.

        lea     edx, [esi+ehci_controller.IntEDs-sizeof.ehci_controller]

        lea     edx, [esi+ehci_controller.IntEDs-sizeof.ehci_controller]

.varloop0:

.varloop0:

; 4b. Loop #2: initialize counter = microframe within the target millisecond.

; 4b. Loop #2: initialize counter = microframe within the target millisecond.

        xor     ecx, ecx

        xor     ecx, ecx

.varloop:

.varloop:

; 4c. Loop #3: save counter of loop #1,

; 4c. Loop #3: save counter of loop #1,

; initialize counter with the value of loop #1 counter,

; initialize counter with the value of loop #1 counter,

; initialize maximal bandwidth = zero.

; initialize maximal bandwidth = zero.

        xor     edi, edi

        xor     edi, edi

        push    edx

        push    edx

virtual at esp

virtual at esp

.saved_counter1         dd      ?       ; step 4c

.saved_counter1         dd      ?       ; step 4c

.loop3_delta            dd      ?       ; step 3

.loop3_delta            dd      ?       ; step 3

.target_delta           dd      ?       ; step 3

.target_delta           dd      ?       ; step 3

end virtual

end virtual

.calc_max_bandwidth:

.calc_max_bandwidth:

; 4d. Loop #4: initialize counter with the value of loop #3 counter,

; 4d. Loop #4: initialize counter with the value of loop #3 counter,

; initialize total bandwidth = zero.

; initialize total bandwidth = zero.

        xor     eax, eax

        xor     eax, eax

        push    edx

        push    edx

.calc_bandwidth:

.calc_bandwidth:

; 4e. Loop #4: add the bandwidth from the current list

; 4e. Loop #4: add the bandwidth from the current list

; and advance to the next list, while there is one.

; and advance to the next list, while there is one.

        add     ax, [edx+ehci_static_ep.Bandwidths+ecx*2]

        add     ax, [edx+ehci_static_ep.Bandwidths+ecx*2]

        mov     edx, [edx+ehci_static_ep.NextList]

        mov     edx, [edx+ehci_static_ep.NextList]

        test    edx, edx

        test    edx, edx

        jnz     .calc_bandwidth

        jnz     .calc_bandwidth

; 4f. Loop #4 end: restore counter of loop #3.

; 4f. Loop #4 end: restore counter of loop #3.

        pop     edx

        pop     edx

; 4g. Loop #3: update maximal bandwidth.

; 4g. Loop #3: update maximal bandwidth.

        cmp     eax, edi

        cmp     eax, edi

        jb      @f

        jb      @f

        mov     edi, eax

        mov     edi, eax

@@:

@@:

; 4h. Loop #3: advance the counter and repeat while within the first group.

; 4h. Loop #3: advance the counter and repeat while within the first group.

        lea     eax, [esi+ehci_controller.IntEDs+32*sizeof.ehci_static_ep-sizeof.ehci_controller]

        lea     eax, [esi+ehci_controller.IntEDs+32*sizeof.ehci_static_ep-sizeof.ehci_controller]

        add     edx, [.loop3_delta]

        add     edx, [.loop3_delta]

        cmp     edx, eax

        cmp     edx, eax

        jb      .calc_max_bandwidth

        jb      .calc_max_bandwidth

; 4i. Loop #3 end: restore counter of loop #1.

; 4i. Loop #3 end: restore counter of loop #1.

        pop     edx

        pop     edx

; 4j. Loop #2: if the current variant is better (maybe not strictly)

; 4j. Loop #2: if the current variant is better (maybe not strictly)

; then the previous optimum, update the optimal bandwidth and the target.

; then the previous optimum, update the optimal bandwidth and the target.

        cmp     edi, [.bandwidth]

        cmp     edi, [.bandwidth]

        ja      @f

        ja      @f

        jb      .update

        jb      .update

        cmp     ecx, [.targetsmask]

        cmp     ecx, [.targetsmask]

        jb      @f

        jb      @f

.update:

.update:

        mov     [.bandwidth], edi

        mov     [.bandwidth], edi

        mov     [.target], edx

        mov     [.target], edx

        mov     [.targetsmask], ecx

        mov     [.targetsmask], ecx

@@:

@@:

; 4k. Loop #2: continue 8 times for every microframe.

; 4k. Loop #2: continue 8 times for every microframe.

        inc     ecx

        inc     ecx

        cmp     ecx, 8

        cmp     ecx, 8

        jb      .varloop

        jb      .varloop

; 4l. Loop #1: advance counter and repeat ebx times,

; 4l. Loop #1: advance counter and repeat ebx times,

; ebx was calculated in step 3.

; ebx was calculated in step 3.

        add     edx, sizeof.ehci_static_ep

        add     edx, sizeof.ehci_static_ep

        dec     ebx

        dec     ebx

        jnz     .varloop0

        jnz     .varloop0

; 5. Calculate bandwidth for the new pipe.

; 5. Calculate bandwidth for the new pipe.

        mov     eax, [.maxpacket]

        mov     eax, [.maxpacket]

        call    calc_hs_bandwidth

        call    calc_hs_bandwidth

        mov     ecx, [.maxpacket]

        mov     ecx, [.maxpacket]

        shr     ecx, 11

        shr     ecx, 11

        inc     ecx

        inc     ecx

        and     ecx, 3

        and     ecx, 3

        imul    eax, ecx

        imul    eax, ecx

; 6. Get the pointer to the best list.

; 6. Get the pointer to the best list.

        pop     edx             ; restore value from step 3

        pop     edx             ; restore value from step 3

        pop     edx             ; get delta calculated in step 3

        pop     edx             ; get delta calculated in step 3

        add     edx, [.target]

        add     edx, [.target]

; 7. Check that bandwidth for the new pipe plus old bandwidth

; 7. Check that bandwidth for the new pipe plus old bandwidth

; still fits to maximum allowed by the core specification

; still fits to maximum allowed by the core specification

; current [.bandwidth] + new bandwidth <= limit;

; current [.bandwidth] + new bandwidth <= limit;

; USB2 specification allows maximum 60000*80% bit times for periodic microframe

; USB2 specification allows maximum 60000*80% bit times for periodic microframe

        mov     ecx, [.bandwidth]

        mov     ecx, [.bandwidth]

        add     ecx, eax

        add     ecx, eax

        cmp     ecx, 48000

        cmp     ecx, 48000

        ja      .no_bandwidth

        ja      .no_bandwidth

; 8. Convert {o|u}hci_static_ep to usb_static_ep, update bandwidth and return.

; 8. Convert {o|u}hci_static_ep to usb_static_ep, update bandwidth and return.

        mov     ecx, [.targetsmask]

        mov     ecx, [.targetsmask]

        add     [edx+ehci_static_ep.Bandwidths+ecx*2], ax

        add     [edx+ehci_static_ep.Bandwidths+ecx*2], ax

        add     edx, ehci_static_ep.SoftwarePart

        add     edx, ehci_static_ep.SoftwarePart

        movi    eax, 1

        movi    eax, 1

        shl     eax, cl

        shl     eax, cl

        pop     edi ebx         ; restore used registers to be stdcall

        pop     edi ebx         ; restore used registers to be stdcall

        ret

        ret

.no_bandwidth:

.no_bandwidth:

        dbgstr 'Periodic bandwidth limit reached'

        dbgstr 'Periodic bandwidth limit reached'

        xor     eax, eax

        xor     eax, eax

        xor     edx, edx

        xor     edx, edx

        pop     edi ebx

        pop     edi ebx

        ret

        ret

.every_frame:

.every_frame:

; The pipe should be scheduled every frame in two or more microframes.

; The pipe should be scheduled every frame in two or more microframes.

; 9. Calculate maximal bandwidth for every microframe: three nested loops.

; 9. Calculate maximal bandwidth for every microframe: three nested loops.

; 9a. The outermost loop: ebx = microframe to calculate.

; 9a. The outermost loop: ebx = microframe to calculate.

        xor     ebx, ebx

        xor     ebx, ebx

.calc_all_bandwidths:

.calc_all_bandwidths:

; 9b. The intermediate loop:

; 9b. The intermediate loop:

; edx = pointer to ehci_static_ep in the first group, [esp] = counter,

; edx = pointer to ehci_static_ep in the first group, [esp] = counter,

; edi = maximal bandwidth

; edi = maximal bandwidth

        lea     edx, [esi+ehci_controller.IntEDs-sizeof.ehci_controller]

        lea     edx, [esi+ehci_controller.IntEDs-sizeof.ehci_controller]

        xor     edi, edi

        xor     edi, edi

        push    32

        push    32

.calc_max_bandwidth2:

.calc_max_bandwidth2:

; 9c. The innermost loop: calculate bandwidth for the given microframe

; 9c. The innermost loop: calculate bandwidth for the given microframe

; in the given frame.

; in the given frame.

        xor     eax, eax

        xor     eax, eax

        push    edx

        push    edx

.calc_bandwidth2:

.calc_bandwidth2:

        add     ax, [edx+ehci_static_ep.Bandwidths+ebx*2]

        add     ax, [edx+ehci_static_ep.Bandwidths+ebx*2]

        mov     edx, [edx+ehci_static_ep.NextList]

        mov     edx, [edx+ehci_static_ep.NextList]

        test    edx, edx

        test    edx, edx

        jnz     .calc_bandwidth2

        jnz     .calc_bandwidth2

        pop     edx

        pop     edx

; 9d. The intermediate loop continued: update maximal bandwidth.

; 9d. The intermediate loop continued: update maximal bandwidth.

        cmp     eax, edi

        cmp     eax, edi

        jb      @f

        jb      @f

        mov     edi, eax

        mov     edi, eax

@@:

@@:

        add     edx, sizeof.ehci_static_ep

        add     edx, sizeof.ehci_static_ep

        dec     dword [esp]

        dec     dword [esp]

        jnz     .calc_max_bandwidth2

        jnz     .calc_max_bandwidth2

        pop     eax

        pop     eax

; 9e. Push the calculated maximal bandwidth and continue the outermost loop.

; 9e. Push the calculated maximal bandwidth and continue the outermost loop.

        push    edi

        push    edi

        inc     ebx

        inc     ebx

        cmp     ebx, 8

        cmp     ebx, 8

        jb      .calc_all_bandwidths

        jb      .calc_all_bandwidths

virtual at esp

virtual at esp

.bandwidth7     dd      ?

.bandwidth7     dd      ?

.bandwidth6     dd      ?

.bandwidth6     dd      ?

.bandwidth5     dd      ?

.bandwidth5     dd      ?

.bandwidth4     dd      ?

.bandwidth4     dd      ?

.bandwidth3     dd      ?

.bandwidth3     dd      ?

.bandwidth2     dd      ?

.bandwidth2     dd      ?

.bandwidth1     dd      ?

.bandwidth1     dd      ?

.bandwidth0     dd      ?

.bandwidth0     dd      ?

end virtual

end virtual

; 10. Select the best variant.

; 10. Select the best variant.

; edx = S-Mask = bitmask of scheduled microframes

; edx = S-Mask = bitmask of scheduled microframes

        movi    edx, 0x11

        movi    edx, 0x11

        cmp     ecx, 1

        cmp     ecx, 1

        ja      @f

        ja      @f

        mov     dl, 0x55

        mov     dl, 0x55

        jz      @f

        jz      @f

        mov     dl, 0xFF

        mov     dl, 0xFF

@@:

@@:

; try all variants edx, edx shl 1, edx shl 2, ...

; try all variants edx, edx shl 1, edx shl 2, ...

; while they fit in the lower byte (8 microframes per frame)

; while they fit in the lower byte (8 microframes per frame)

.select_best_mframe:

.select_best_mframe:

        xor     edi, edi

        xor     edi, edi

        mov     ecx, edx

        mov     ecx, edx

        mov     eax, esp

        mov     eax, esp

.calc_mframe:

.calc_mframe:

        add     cl, cl

        add     cl, cl

        jnc     @f

        jnc     @f

        cmp     edi, [eax]

        cmp     edi, [eax]

        jae     @f

        jae     @f

        mov     edi, [eax]

        mov     edi, [eax]

@@:

@@:

        add     eax, 4

        add     eax, 4

        test    cl, cl

        test    cl, cl

        jnz     .calc_mframe

        jnz     .calc_mframe

        cmp     [.bandwidth], edi

        cmp     [.bandwidth], edi

        jb      @f

        jb      @f

        mov     [.bandwidth], edi

        mov     [.bandwidth], edi

        mov     [.targetsmask], edx

        mov     [.targetsmask], edx

@@:

@@:

        add     dl, dl

        add     dl, dl

        jnc     .select_best_mframe

        jnc     .select_best_mframe

; 11. Restore stack after step 9.

; 11. Restore stack after step 9.

        add     esp, 8*4

        add     esp, 8*4

; 12. Get the pointer to the target list (responsible for every microframe).

; 12. Get the pointer to the target list (responsible for every microframe).

        lea     edx, [esi+ehci_controller.IntEDs.SoftwarePart+62*sizeof.ehci_static_ep-sizeof.ehci_controller]

        lea     edx, [esi+ehci_controller.IntEDs.SoftwarePart+62*sizeof.ehci_static_ep-sizeof.ehci_controller]

; 13. Calculate bandwidth on the bus.

; 13. Calculate bandwidth on the bus.

        mov     eax, [.maxpacket]

        mov     eax, [.maxpacket]

        call    calc_hs_bandwidth

        call    calc_hs_bandwidth

        mov     ecx, [.maxpacket]

        mov     ecx, [.maxpacket]

        shr     ecx, 11

        shr     ecx, 11

        inc     ecx

        inc     ecx

        and     ecx, 3

        and     ecx, 3

        imul    eax, ecx

        imul    eax, ecx

; 14. Check that current [.bandwidth] + new bandwidth <= limit;

; 14. Check that current [.bandwidth] + new bandwidth <= limit;

; USB2 specification allows maximum 60000*80% bit times for periodic microframe.

; USB2 specification allows maximum 60000*80% bit times for periodic microframe.

        mov     ecx, [.bandwidth]

        mov     ecx, [.bandwidth]

        add     ecx, eax

        add     ecx, eax

        cmp     ecx, 48000

        cmp     ecx, 48000

        ja      .no_bandwidth

        ja      .no_bandwidth

; 15. Update bandwidths including the new pipe.

; 15. Update bandwidths including the new pipe.

        mov     ecx, [.targetsmask]

        mov     ecx, [.targetsmask]

        lea     edi, [edx+ehci_static_ep.Bandwidths-ehci_static_ep.SoftwarePart]

        lea     edi, [edx+ehci_static_ep.Bandwidths-ehci_static_ep.SoftwarePart]

.update_bandwidths:

.update_bandwidths:

        shr     ecx, 1

        shr     ecx, 1

        jnc     @f

        jnc     @f

        add     [edi], ax

        add     [edi], ax

@@:

@@:

        add     edi, 2

        add     edi, 2

        test    ecx, ecx

        test    ecx, ecx

        jnz     .update_bandwidths

        jnz     .update_bandwidths

; 16. Return target list and target S-Mask.

; 16. Return target list and target S-Mask.

        mov     eax, [.targetsmask]

        mov     eax, [.targetsmask]

        pop     edi ebx         ; restore used registers to be stdcall

        pop     edi ebx         ; restore used registers to be stdcall

        ret

        ret

endp

endp

; Pipe is removing, update the corresponding lists.

; Pipe is removing, update the corresponding lists.

; We do not reorder anything, so just update book-keeping variable

; We do not reorder anything, so just update book-keeping variable

; in the list header.

; in the list header.

proc ehci_hs_interrupt_list_unlink

proc ehci_hs_interrupt_list_unlink

        movzx   eax, word [ebx+ehci_pipe.Token-sizeof.ehci_pipe+2]

        movzx   eax, word [ebx+ehci_pipe.Token-sizeof.ehci_pipe+2]

; calculate bandwidth

; calculate bandwidth

        call    calc_hs_bandwidth

        call    calc_hs_bandwidth

        mov     ecx, [ebx+ehci_pipe.Flags-sizeof.ehci_pipe]

        mov     ecx, [ebx+ehci_pipe.Flags-sizeof.ehci_pipe]

        shr     ecx, 30

        shr     ecx, 30

        imul    eax, ecx

        imul    eax, ecx

        movzx   ecx, byte [ebx+ehci_pipe.Flags-sizeof.ehci_pipe]

        movzx   ecx, byte [ebx+ehci_pipe.Flags-sizeof.ehci_pipe]

; get target list

; get target list

; update bandwidth

; update bandwidth

.dec_bandwidth:

.dec_bandwidth:

        shr     ecx, 1

        shr     ecx, 1

        jnc     @f

        jnc     @f

        sub     word [edx+ehci_static_ep.Bandwidths - ehci_static_ep.SoftwarePart], ax

        sub     word [edx+ehci_static_ep.Bandwidths - ehci_static_ep.SoftwarePart], ax

@@:

@@:

        add     edx, 2

        add     edx, 2

        test    ecx, ecx

        test    ecx, ecx

        jnz     .dec_bandwidth

        jnz     .dec_bandwidth

; return

; return

        ret

        ret

endp

endp

; Helper procedure for USB2 scheduler: calculate bandwidth on the bus.

; Helper procedure for USB2 scheduler: calculate bandwidth on the bus.

; in: low 11 bits of eax = payload size in bytes

; in: low 11 bits of eax = payload size in bytes

; out: eax = maximal bandwidth in HS-bits

; out: eax = maximal bandwidth in HS-bits

proc calc_hs_bandwidth

proc calc_hs_bandwidth

        and     eax, (1 shl 11) - 1     ; get payload for one transaction

        and     eax, (1 shl 11) - 1     ; get payload for one transaction

        add     eax, 3  ; add 3 bytes for other fields in data packet, PID+CRC16

        add     eax, 3  ; add 3 bytes for other fields in data packet, PID+CRC16

; Multiply by 8 for bytes -> bits and then by 7/6 to accomodate bit stuffing;

; Multiply by 8 for bytes -> bits and then by 7/6 to accomodate bit stuffing;

; total 28/3 = 9+1/3

; total 28/3 = 9+1/3

        mov     edx, 55555556h

        mov     edx, 55555556h

        lea     ecx, [eax*9]

        lea     ecx, [eax*9]

        mul     edx

        mul     edx

; Add 989 extra bits: 68 bits for Token packet (32 for SYNC, 24 for token+address,

; Add 989 extra bits: 68 bits for Token packet (32 for SYNC, 24 for token+address,

; 4 extra bits for possible bit stuffing in token+address, 8 for EOP),

; 4 extra bits for possible bit stuffing in token+address, 8 for EOP),

; 736 bits for bus turn-around, 40 bits for SYNC+EOP in Data packet,

; 736 bits for bus turn-around, 40 bits for SYNC+EOP in Data packet,

; 8 bits for inter-packet delay, 49 bits for Handshake packet,

; 8 bits for inter-packet delay, 49 bits for Handshake packet,

; 88 bits for another inter-packet delay.

; 88 bits for another inter-packet delay.

        lea     eax, [ecx+edx+989]

        lea     eax, [ecx+edx+989]

        ret

        ret

endp

endp

; Split-transaction scheduler (aka TT scheduler, TT stands for Transaction

; Split-transaction scheduler (aka TT scheduler, TT stands for Transaction

; Translator, section 11.14 of the core spec) needs to schedule three event

; Translator, section 11.14 of the core spec) needs to schedule three event

; types on two buses: Start-Split and Complete-Split on HS bus and normal

; types on two buses: Start-Split and Complete-Split on HS bus and normal

; transaction on FS/LS bus.

; transaction on FS/LS bus.

; Assume that FS/LS bus is more restricted and more important to be scheduled

; Assume that FS/LS bus is more restricted and more important to be scheduled

; uniformly, so select the variant which minimizes maximal used bandwidth

; uniformly, so select the variant which minimizes maximal used bandwidth

; on FS/LS bus and does not overflow HS bus.

; on FS/LS bus and does not overflow HS bus.

; If there are several such variants, prefer variants which is closest to

; If there are several such variants, prefer variants which is closest to

; start of frame, and within the same microframe consider HS bandwidth

; start of frame, and within the same microframe consider HS bandwidth

; utilization as a last criteria.

; utilization as a last criteria.

; The procedure ehci_select_tt_interrupt_list has been splitted into several

; The procedure ehci_select_tt_interrupt_list has been splitted into several

; macro, each representing a logical step of the procedure,

; macro, each representing a logical step of the procedure,

; to simplify understanding what is going on. Consider all the following macro

; to simplify understanding what is going on. Consider all the following macro

; as logical parts of one procedure, they are meaningless outside the context.

; as logical parts of one procedure, they are meaningless outside the context.

; Given a frame, calculate bandwidth occupied by already opened pipes

; Given a frame, calculate bandwidth occupied by already opened pipes

; in every microframe.

; in every microframe.

; Look for both HS and FS/LS buses: there are 16 words of information,

; Look for both HS and FS/LS buses: there are 16 words of information,

; 8 for HS bus, 8 for FS/LS bus, for every microframe.

; 8 for HS bus, 8 for FS/LS bus, for every microframe.

; Since we count already opened pipes, the total bandwidth in every microframe

; Since we count already opened pipes, the total bandwidth in every microframe

; is less than 60000 bits (and even 60000*80% bits), otherwise the scheduler

; is less than 60000 bits (and even 60000*80% bits), otherwise the scheduler

; would not allow to open those pipes.

; would not allow to open those pipes.

; edi -> first list for the frame

; edi -> first list for the frame

macro tt_calc_bandwidth_in_frame

macro tt_calc_bandwidth_in_frame

{

{

local .lists, .pipes, .pipes_done, .carry

local .lists, .pipes, .pipes_done, .carry

; 1. Zero everything.

; 1. Zero everything.

        xor     eax, eax

        xor     eax, eax

        mov     edx, edi

        mov     edx, edi

repeat 4

repeat 4

        mov     dword [.budget+(%-1)*4], eax

        mov     dword [.budget+(%-1)*4], eax

end repeat

end repeat

repeat 4

repeat 4

        mov     dword [.hs_bandwidth+(%-1)*4], eax

        mov     dword [.hs_bandwidth+(%-1)*4], eax

end repeat

end repeat

        mov     [.total_budget], ax

        mov     [.total_budget], ax

; Loop over all lists for the given frame.

; Loop over all lists for the given frame.

.lists:

.lists:

; 2. Total HS bandwidth for all pipes in one list is kept inside list header,

; 2. Total HS bandwidth for all pipes in one list is kept inside list header,

; add it. Note that overflow is impossible, so we may add entire dwords.

; add it. Note that overflow is impossible, so we may add entire dwords.

        mov     ebx, [edx+ehci_static_ep.SoftwarePart+usb_static_ep.NextVirt]

        mov     ebx, [edx+ehci_static_ep.SoftwarePart+usb_static_ep.NextVirt]

repeat 4

repeat 4

        mov     eax, dword [edx+ehci_static_ep.Bandwidths+(%-1)*4]

        mov     eax, dword [edx+ehci_static_ep.Bandwidths+(%-1)*4]

        add     dword [.hs_bandwidth+(%-1)*4], eax

        add     dword [.hs_bandwidth+(%-1)*4], eax

end repeat

end repeat

; Loop over all pipes in the given list.

; Loop over all pipes in the given list.

        add     edx, ehci_static_ep.SoftwarePart

        add     edx, ehci_static_ep.SoftwarePart

.pipes:

.pipes:

        cmp     ebx, edx

        cmp     ebx, edx

        jz      .pipes_done

        jz      .pipes_done

; 3. For every pipe in every list for the given frame:

; 3. For every pipe in every list for the given frame:

; 3a. Check whether the pipe resides on the same FS/LS bus as the new pipe.

; 3a. Check whether the pipe resides on the same FS/LS bus as the new pipe.

; If not, skip this pipe.

; If not, skip this pipe.

        mov     eax, [ebx+usb_pipe.DeviceData]

        mov     eax, [ebx+usb_pipe.DeviceData]

        mov     eax, [eax+usb_device_data.TTHub]

        mov     eax, [eax+usb_device_data.TTHub]

        cmp     eax, [.tthub]

        cmp     eax, [.tthub]

        jnz     @f

        jnz     @f

; 3b. Calculate FS/LS budget for the opened pipe.

; 3b. Calculate FS/LS budget for the opened pipe.

; Note that eax = TTHub after 3a.

; Note that eax = TTHub after 3a.

        call    tt_calc_budget

        call    tt_calc_budget

; 3c. Update total budget: add the value from 3b

; 3c. Update total budget: add the value from 3b

; to the budget of the first microframe scheduled for this pipe.

; to the budget of the first microframe scheduled for this pipe.

        bsf     ecx, [ebx+ehci_pipe.Flags-sizeof.ehci_pipe]

        bsf     ecx, [ebx+ehci_pipe.Flags-sizeof.ehci_pipe]

        add     [.budget+ecx*2], ax

        add     [.budget+ecx*2], ax

@@:

@@:

        mov     ebx, [ebx+usb_pipe.NextVirt]

        mov     ebx, [ebx+usb_pipe.NextVirt]

        jmp     .pipes

        jmp     .pipes

.pipes_done:

.pipes_done:

        mov     edx, [edx+ehci_static_ep.NextList-ehci_static_ep.SoftwarePart]

        mov     edx, [edx+ehci_static_ep.NextList-ehci_static_ep.SoftwarePart]

        test    edx, edx

        test    edx, edx

        jnz     .lists

        jnz     .lists

; 4. If the budget for some microframe is exceeded, carry it to the following

; 4. If the budget for some microframe is exceeded, carry it to the following

; microframe(s). The actual size of one microframe is 187.5 raw bytes;

; microframe(s). The actual size of one microframe is 187.5 raw bytes;

; the core spec says that 188 bytes should be scheduled in every microframe.

; the core spec says that 188 bytes should be scheduled in every microframe.

        xor     eax, eax

        xor     eax, eax

        xor     ecx, ecx

        xor     ecx, ecx

.carry:

.carry:

        xor     edx, edx

        xor     edx, edx

        add     ax, [.budget+ecx*2]

        add     ax, [.budget+ecx*2]

        cmp     ax, 188

        cmp     ax, 188

        jbe     @f

        jbe     @f

        mov     dx, ax

        mov     dx, ax

        mov     ax, 188

        mov     ax, 188

        sub     dx, ax

        sub     dx, ax

@@:

@@:

        mov     [.budget+ecx*2], ax

        mov     [.budget+ecx*2], ax

        add     [.total_budget], ax

        add     [.total_budget], ax

        mov     ax, dx

        mov     ax, dx

        inc     ecx

        inc     ecx

        cmp     ecx, 8

        cmp     ecx, 8

        jb      .carry

        jb      .carry

}

}

; Checks whether the new pipe fits in the existing FS budget

; Checks whether the new pipe fits in the existing FS budget

; starting from the given microframe. If not, mark the microframe

; starting from the given microframe. If not, mark the microframe

; as impossible for scheduling.

; as impossible for scheduling.

; in: ecx = microframe

; in: ecx = microframe

macro tt_exclude_microframe_if_no_budget

macro tt_exclude_microframe_if_no_budget

{

{

local .loop, .good, .bad

local .loop, .good, .bad

; 1. If the new budget plus the current budget does not exceed 188 bytes,

; 1. If the new budget plus the current budget does not exceed 188 bytes,

; the variant is possible.

; the variant is possible.

        mov     ax, [.budget+ecx*2]

        mov     ax, [.budget+ecx*2]

        mov     edx, ecx

        mov     edx, ecx

        add     ax, [.new_budget]

        add     ax, [.new_budget]

        sub     ax, 188

        sub     ax, 188

        jbe     .good

        jbe     .good

; 2. Otherwise,

; 2. Otherwise,

; a) nothing should be scheduled in some following microframes,

; a) nothing should be scheduled in some following microframes,

; b) after adding the new budget everything should fit in first 6 microframes,

; b) after adding the new budget everything should fit in first 6 microframes,

;    this guarantees that even in the worst case 90% limit is satisfied.

;    this guarantees that even in the worst case 90% limit is satisfied.

.loop:

.loop:

        cmp     edx, 5

        cmp     edx, 5

        jae     .bad

        jae     .bad

        cmp     [.budget+(edx+1)*2], 0

        cmp     [.budget+(edx+1)*2], 0

        jnz     .bad

        jnz     .bad

        inc     edx

        inc     edx

        sub     ax, 188

        sub     ax, 188

        ja      .loop

        ja      .loop

.bad:

.bad:

        btr     [.possible_microframes], ecx

        btr     [.possible_microframes], ecx

.good:

.good:

}

}

; Calculate data corresponding to the particular scheduling variant for the new pipe.

; Calculate data corresponding to the particular scheduling variant for the new pipe.

; Data describe the current scheduling state collected over all frames touched

; Data describe the current scheduling state collected over all frames touched

; by the given variant: maximal HS bandwidth, maximal FS/LS budget,

; by the given variant: maximal HS bandwidth, maximal FS/LS budget,

; which microframes fit in the current FS/LS budget for all frames.

; which microframes fit in the current FS/LS budget for all frames.

macro tt_calc_statistics_for_one_variant

macro tt_calc_statistics_for_one_variant

{

{

local .frames, .microframes

local .frames, .microframes

; 1. Initialize: zero maximal bandwidth,

; 1. Initialize: zero maximal bandwidth,

; first 6 microframes are possible for scheduling.

; first 6 microframes are possible for scheduling.

        xor     eax, eax

        xor     eax, eax

repeat 4

repeat 4

        mov     dword [.max_hs_bandwidth+(%-1)*4], eax

        mov     dword [.max_hs_bandwidth+(%-1)*4], eax

end repeat

end repeat

        mov     [.max_fs_bandwidth], ax

        mov     [.max_fs_bandwidth], ax

        mov     [.possible_microframes], 0x3F

        mov     [.possible_microframes], 0x3F

; Loop over all frames starting with [.variant] advancing by [.variant_delta].

; Loop over all frames starting with [.variant] advancing by [.variant_delta].

        mov     edi, [.variant]

        mov     edi, [.variant]

.frames:

.frames:

; 2. Calculate statistics for one frame.

; 2. Calculate statistics for one frame.

        tt_calc_bandwidth_in_frame

        tt_calc_bandwidth_in_frame

; 3. Update maximal FS budget.

; 3. Update maximal FS budget.

        mov     ax, [.total_budget]

        mov     ax, [.total_budget]

        cmp     ax, [.max_fs_bandwidth]

        cmp     ax, [.max_fs_bandwidth]

        jb      @f

        jb      @f

        mov     [.max_fs_bandwidth], ax

        mov     [.max_fs_bandwidth], ax

@@:

@@:

; 4. For every microframe, update maximal HS bandwidth

; 4. For every microframe, update maximal HS bandwidth

; and check whether the microframe is allowed for scheduling.

; and check whether the microframe is allowed for scheduling.

        xor     ecx, ecx

        xor     ecx, ecx

.microframes:

.microframes:

        mov     ax, [.hs_bandwidth+ecx*2]

        mov     ax, [.hs_bandwidth+ecx*2]

        cmp     ax, [.max_hs_bandwidth+ecx*2]

        cmp     ax, [.max_hs_bandwidth+ecx*2]

        jb      @f

        jb      @f

        mov     [.max_hs_bandwidth+ecx*2], ax

        mov     [.max_hs_bandwidth+ecx*2], ax

@@:

@@:

        tt_exclude_microframe_if_no_budget

        tt_exclude_microframe_if_no_budget

        inc     ecx

        inc     ecx

        cmp     ecx, 8

        cmp     ecx, 8

        jb      .microframes

        jb      .microframes

; Stop loop when outside of first descriptor group.

; Stop loop when outside of first descriptor group.

        lea     eax, [esi+ehci_controller.IntEDs+32*sizeof.ehci_static_ep-sizeof.ehci_controller]

        lea     eax, [esi+ehci_controller.IntEDs+32*sizeof.ehci_static_ep-sizeof.ehci_controller]

        add     edi, [.variant_delta]

        add     edi, [.variant_delta]

        cmp     edi, eax

        cmp     edi, eax

        jb      .frames

        jb      .frames

}

}

struct usb_split_info

struct usb_split_info

microframe_mask         dd      ?       ; lower byte is S-mask, second byte is C-mask

microframe_mask         dd      ?       ; lower byte is S-mask, second byte is C-mask

ssplit_bandwidth        dd      ?

ssplit_bandwidth        dd      ?

csplit_bandwidth        dd      ?

csplit_bandwidth        dd      ?

ends

ends

; Check whether the current variant and the current microframe are allowed

; Check whether the current variant and the current microframe are allowed

; for scheduling. If so, check whether they are better than the previously

; for scheduling. If so, check whether they are better than the previously

; selected variant+microframe, if any. If so, update the previously selected

; selected variant+microframe, if any. If so, update the previously selected

; variant+microframe to current ones.

; variant+microframe to current ones.

; ecx = microframe, [.variant] = variant

; ecx = microframe, [.variant] = variant

macro tt_check_variant_microframe

macro tt_check_variant_microframe

{

{

local .nothing, .update, .ssplit, .csplit, .csplit_done

local .nothing, .update, .ssplit, .csplit, .csplit_done

; 1. If the current microframe does not fit in existing FS budget, do nothing.

; 1. If the current microframe does not fit in existing FS budget, do nothing.

        bt      [.possible_microframes], ecx

        bt      [.possible_microframes], ecx

        jnc     .nothing

        jnc     .nothing

; 2. Calculate maximal HS bandwidth over all affected microframes.

; 2. Calculate maximal HS bandwidth over all affected microframes.

; 2a. Start-split phase: one or more microframes starting with ecx,

; 2a. Start-split phase: one or more microframes starting with ecx,

; coded in lower byte of .info.microframe_mask.

; coded in lower byte of .info.microframe_mask.

        xor     ebx, ebx

        xor     ebx, ebx

        xor     edx, edx

        xor     edx, edx

.ssplit:

.ssplit:

        lea     eax, [ecx+edx]

        lea     eax, [ecx+edx]

        movzx   eax, [.max_hs_bandwidth+eax*2]

        movzx   eax, [.max_hs_bandwidth+eax*2]

        add     eax, [.info.ssplit_bandwidth]

        add     eax, [.info.ssplit_bandwidth]

        cmp     ebx, eax

        cmp     ebx, eax

        ja      @f

        ja      @f

        mov     ebx, eax

        mov     ebx, eax

@@:

@@:

        inc     edx

        inc     edx

        bt      [.info.microframe_mask], edx

        bt      [.info.microframe_mask], edx

        jc      .ssplit

        jc      .ssplit

; 2b. Complete-split phase: zero or more microframes starting with

; 2b. Complete-split phase: zero or more microframes starting with

; ecx+(last start-split microframe)+2,

; ecx+(last start-split microframe)+2,

; coded in second byte of .info.microframe_mask.

; coded in second byte of .info.microframe_mask.

        add     edx, 8

        add     edx, 8

.csplit:

.csplit:

        inc     edx

        inc     edx

        bt      [.info.microframe_mask], edx

        bt      [.info.microframe_mask], edx

        jnc     .csplit_done

        jnc     .csplit_done

        lea     eax, [ecx+edx]

        lea     eax, [ecx+edx]

        cmp     eax, 8

        cmp     eax, 8

        jae     .csplit_done

        jae     .csplit_done

        movzx   eax, [.max_hs_bandwidth+(eax-8)*2]

        movzx   eax, [.max_hs_bandwidth+(eax-8)*2]

        add     eax, [.info.csplit_bandwidth]

        add     eax, [.info.csplit_bandwidth]

        cmp     ebx, eax

        cmp     ebx, eax

        ja      .csplit

        ja      .csplit

        mov     ebx, eax

        mov     ebx, eax

        jmp     .csplit

        jmp     .csplit

.csplit_done:

.csplit_done:

; 3. Check that current HS bandwidth + new bandwidth <= limit;

; 3. Check that current HS bandwidth + new bandwidth <= limit;

; USB2 specification allows maximum 60000*80% bit times for periodic microframe.

; USB2 specification allows maximum 60000*80% bit times for periodic microframe.

        cmp     ebx, 48000

        cmp     ebx, 48000

        ja      .nothing

        ja      .nothing

; 4. This variant is possible for scheduling.

; 4. This variant is possible for scheduling.

; Check whether it is better than the currently selected one.

; Check whether it is better than the currently selected one.

; 4a. The primary criteria: FS/LS bandwidth.

; 4a. The primary criteria: FS/LS bandwidth.

        mov     ax, [.max_fs_bandwidth]

        mov     ax, [.max_fs_bandwidth]

        cmp     ax, [.best_fs_bandwidth]

        cmp     ax, [.best_fs_bandwidth]

        ja      .nothing

        ja      .nothing

        jb      .update

        jb      .update

; 4b. The secondary criteria: prefer microframes which are closer to start of frame.

; 4b. The secondary criteria: prefer microframes which are closer to start of frame.

        cmp     ecx, [.targetsmask]

        cmp     ecx, [.targetsmask]

        ja      .nothing

        ja      .nothing

        jb      .update

        jb      .update

; 4c. The last criteria: HS bandwidth.

; 4c. The last criteria: HS bandwidth.

        cmp     ebx, [.bandwidth]

        cmp     ebx, [.bandwidth]

        ja      .nothing

        ja      .nothing

.update:

.update:

; 5. This variant is better than the previously selected.

; 5. This variant is better than the previously selected.

; Update the best variant with current data.

; Update the best variant with current data.

        mov     [.best_fs_bandwidth], ax

        mov     [.best_fs_bandwidth], ax

        mov     [.bandwidth], ebx

        mov     [.bandwidth], ebx

        mov     [.targetsmask], ecx

        mov     [.targetsmask], ecx

        mov     eax, [.variant]

        mov     eax, [.variant]

        mov     [.target], eax

        mov     [.target], eax

.nothing:

.nothing:

}

}

; TT scheduler: add new pipe.

; TT scheduler: add new pipe.

; in: esi -> usb_controller, edi -> usb_pipe

; in: esi -> usb_controller, edi -> usb_pipe

; out: edx -> usb_static_ep, eax = S-Mask

; out: edx -> usb_static_ep, eax = S-Mask

proc ehci_select_tt_interrupt_list

proc ehci_select_tt_interrupt_list

virtual at ebp-12-.local_vars_size

virtual at ebp-12-.local_vars_size

.local_vars_start:

.local_vars_start:

.info                   usb_split_info

.info                   usb_split_info

.new_budget             dw      ?

.new_budget             dw      ?

.total_budget           dw      ?

.total_budget           dw      ?

.possible_microframes   dd      ?

.possible_microframes   dd      ?

.tthub                  dd      ?

.tthub                  dd      ?

.budget                 rw      8

.budget                 rw      8

.hs_bandwidth           rw      8

.hs_bandwidth           rw      8

.max_hs_bandwidth       rw      8

.max_hs_bandwidth       rw      8

.max_fs_bandwidth       dw      ?

.max_fs_bandwidth       dw      ?

.best_fs_bandwidth      dw      ?

.best_fs_bandwidth      dw      ?

.variant                dd      ?

.variant                dd      ?

.variant_delta          dd      ?

.variant_delta          dd      ?

.target_delta           dd      ?

.target_delta           dd      ?

.local_vars_size = $ - .local_vars_start

.local_vars_size = $ - .local_vars_start

if .local_vars_size > 24*4

if .local_vars_size > 24*4

err Modify stack frame size in 

err Modify stack frame size in 

end if

end if

.targetsmask    dd      ?

.targetsmask    dd      ?

.bandwidth      dd      ?

.bandwidth      dd      ?

.target         dd      ?

.target         dd      ?

                dd      ?

                dd      ?

                dd      ?

                dd      ?

.config_pipe    dd      ?

.config_pipe    dd      ?

.endpoint       dd      ?

.endpoint       dd      ?

.maxpacket      dd      ?

.maxpacket      dd      ?

.type           dd      ?

.type           dd      ?

.interval       dd      ?

.interval       dd      ?

end virtual

end virtual

        mov     eax, [edi+ehci_pipe.Token-sizeof.ehci_pipe]

        mov     eax, [edi+ehci_pipe.Token-sizeof.ehci_pipe]

        shr     eax, 16

        shr     eax, 16

        and     eax, (1 shl 11) - 1

        and     eax, (1 shl 11) - 1

        push    ebx edi

        push    ebx edi

; 1. Compute the real interval. FS/LS devices encode the interval as

; 1. Compute the real interval. FS/LS devices encode the interval as

; number of milliseconds. Use the maximal power of two that is not greater than

; number of milliseconds. Use the maximal power of two that is not greater than

; the given interval and EHCI scheduling area = 32 frames.

; the given interval and EHCI scheduling area = 32 frames.

        cmp     [.interval], 1

        cmp     [.interval], 1

        adc     [.interval], 0

        adc     [.interval], 0

        mov     ecx, 64

        mov     ecx, 64

        mov     eax, 64 * sizeof.ehci_static_ep

        mov     eax, 64 * sizeof.ehci_static_ep

@@:

@@:

        shr     ecx, 1

        shr     ecx, 1

        cmp     [.interval], ecx

        cmp     [.interval], ecx

        jb      @b

        jb      @b

        mov     [.interval], ecx

        mov     [.interval], ecx

; 2. Compute variables for further calculations.

; 2. Compute variables for further calculations.

; 2a. [.variant_delta] is delta between two lists from the first group

; 2a. [.variant_delta] is delta between two lists from the first group

; that correspond to the same variant.

; that correspond to the same variant.

        imul    ecx, sizeof.ehci_static_ep

        imul    ecx, sizeof.ehci_static_ep

        mov     [.variant_delta], ecx

        mov     [.variant_delta], ecx

; 2b. [.target_delta] is delta between the final answer from the group

; 2b. [.target_delta] is delta between the final answer from the group

; corresponding to [.interval] and the item from the first group.

; corresponding to [.interval] and the item from the first group.

        sub     eax, ecx

        sub     eax, ecx

        sub     eax, ecx

        sub     eax, ecx

        mov     [.target_delta], eax

        mov     [.target_delta], eax

; 2c. [.variant] is the first list from the first group that corresponds

; 2c. [.variant] is the first list from the first group that corresponds

; to the current variant.

; to the current variant.

        lea     eax, [esi+ehci_controller.IntEDs-sizeof.ehci_controller]

        lea     eax, [esi+ehci_controller.IntEDs-sizeof.ehci_controller]

        mov     [.variant], eax

        mov     [.variant], eax

; 2d. [.tthub] identifies TT hub for new pipe, [.new_budget] is FS budget

; 2d. [.tthub] identifies TT hub for new pipe, [.new_budget] is FS budget

; for new pipe.

; for new pipe.

        mov     eax, [edi+usb_pipe.DeviceData]

        mov     eax, [edi+usb_pipe.DeviceData]

        mov     eax, [eax+usb_device_data.TTHub]

        mov     eax, [eax+usb_device_data.TTHub]

        mov     ebx, edi

        mov     ebx, edi

        mov     [.tthub], eax

        mov     [.tthub], eax

        call    tt_calc_budget

        call    tt_calc_budget

        mov     [.new_budget], ax

        mov     [.new_budget], ax

; 2e. [.usb_split_info] describes bandwidth used by new pipe on HS bus.

; 2e. [.usb_split_info] describes bandwidth used by new pipe on HS bus.

        lea     edi, [.info]

        lea     edi, [.info]

        call    tt_fill_split_info

        call    tt_fill_split_info

        test    eax, eax

        test    eax, eax

        jz      .no_bandwidth

        jz      .no_bandwidth

; 2f. There is no best variant yet, put maximal possible values,

; 2f. There is no best variant yet, put maximal possible values,

; so any variant would be better than the "current".

; so any variant would be better than the "current".

        or      [.best_fs_bandwidth], -1

        or      [.best_fs_bandwidth], -1

        or      [.target], -1

        or      [.target], -1

        or      [.bandwidth], -1

        or      [.bandwidth], -1

        or      [.targetsmask], -1

        or      [.targetsmask], -1

; 3. Loop over all variants, for every variant decide whether it is acceptable,

; 3. Loop over all variants, for every variant decide whether it is acceptable,

; select the best variant from all acceptable variants.

; select the best variant from all acceptable variants.

.check_variants:

.check_variants:

        tt_calc_statistics_for_one_variant

        tt_calc_statistics_for_one_variant

        xor     ecx, ecx

        xor     ecx, ecx

.check_microframes:

.check_microframes:

        tt_check_variant_microframe

        tt_check_variant_microframe

        inc     ecx

        inc     ecx

        cmp     ecx, 6

        cmp     ecx, 6

        jb      .check_microframes

        jb      .check_microframes

        add     [.variant], sizeof.ehci_static_ep

        add     [.variant], sizeof.ehci_static_ep

        dec     [.interval]

        dec     [.interval]

        jnz     .check_variants

        jnz     .check_variants

; 4. If there is no acceptable variants, return error.

; 4. If there is no acceptable variants, return error.

        mov     ecx, [.targetsmask]

        mov     ecx, [.targetsmask]

        mov     edx, [.target]

        mov     edx, [.target]

        cmp     ecx, -1

        cmp     ecx, -1

        jz      .no_bandwidth

        jz      .no_bandwidth

; 5. Calculate the answer: edx -> selected list, eax = S-Mask and C-Mask.

; 5. Calculate the answer: edx -> selected list, eax = S-Mask and C-Mask.

        mov     eax, [.info.microframe_mask]

        mov     eax, [.info.microframe_mask]

        add     edx, [.target_delta]

        add     edx, [.target_delta]

        shl     eax, cl

        shl     eax, cl

        and     eax, 0xFFFF

        and     eax, 0xFFFF

; 6. Update HS bandwidths in the selected list.

; 6. Update HS bandwidths in the selected list.

        xor     ecx, ecx

        xor     ecx, ecx

        mov     ebx, [.info.ssplit_bandwidth]

        mov     ebx, [.info.ssplit_bandwidth]

.update_ssplit:

.update_ssplit:

        bt      eax, ecx

        bt      eax, ecx

        jnc     @f

        jnc     @f

        add     [edx+ehci_static_ep.Bandwidths+ecx*2], bx

        add     [edx+ehci_static_ep.Bandwidths+ecx*2], bx

@@:

@@:

        inc     ecx

        inc     ecx

        cmp     ecx, 8

        cmp     ecx, 8

        jb      .update_ssplit

        jb      .update_ssplit

        mov     ebx, [.info.csplit_bandwidth]

        mov     ebx, [.info.csplit_bandwidth]

.update_csplit:

.update_csplit:

        bt      eax, ecx

        bt      eax, ecx

        jnc     @f

        jnc     @f

        add     [edx+ehci_static_ep.Bandwidths+(ecx-8)*2], bx

        add     [edx+ehci_static_ep.Bandwidths+(ecx-8)*2], bx

@@:

@@:

        inc     ecx

        inc     ecx

        cmp     ecx, 16

        cmp     ecx, 16

        jb      .update_csplit

        jb      .update_csplit

; 7. Return.

; 7. Return.

        add     edx, ehci_static_ep.SoftwarePart

        add     edx, ehci_static_ep.SoftwarePart

        pop     edi ebx

        pop     edi ebx

        ret

        ret

.no_bandwidth:

.no_bandwidth:

        dbgstr 'Periodic bandwidth limit reached'

        dbgstr 'Periodic bandwidth limit reached'

        xor     eax, eax

        xor     eax, eax

        xor     edx, edx

        xor     edx, edx

        pop     edi ebx

        pop     edi ebx

        ret

        ret

endp

endp

; Pipe is removing, update the corresponding lists.

; Pipe is removing, update the corresponding lists.

; We do not reorder anything, so just update book-keeping variable

; We do not reorder anything, so just update book-keeping variable

; in the list header.

; in the list header.

proc ehci_fs_interrupt_list_unlink

proc ehci_fs_interrupt_list_unlink

; calculate bandwidth

; calculate bandwidth

        push    edi

        push    edi

        sub     esp, sizeof.usb_split_info

        sub     esp, sizeof.usb_split_info

        mov     edi, esp

        mov     edi, esp

        call    tt_fill_split_info

        call    tt_fill_split_info

; get target list

; get target list

; update bandwidth for Start-Split

; update bandwidth for Start-Split

        mov     eax, [edi+usb_split_info.ssplit_bandwidth]

        mov     eax, [edi+usb_split_info.ssplit_bandwidth]

        xor     ecx, ecx

        xor     ecx, ecx

.dec_bandwidth_1:

.dec_bandwidth_1:

        bt      [ebx+ehci_pipe.Flags-sizeof.ehci_pipe], ecx

        bt      [ebx+ehci_pipe.Flags-sizeof.ehci_pipe], ecx

        jnc     @f

        jnc     @f

        sub     word [edx+ecx*2+ehci_static_ep.Bandwidths - ehci_static_ep.SoftwarePart], ax

        sub     word [edx+ecx*2+ehci_static_ep.Bandwidths - ehci_static_ep.SoftwarePart], ax

@@:

@@:

        inc     ecx

        inc     ecx

        cmp     ecx, 8

        cmp     ecx, 8

        jb      .dec_bandwidth_1

        jb      .dec_bandwidth_1

; update bandwidth for Complete-Split

; update bandwidth for Complete-Split

        mov     eax, [edi+usb_split_info.csplit_bandwidth]

        mov     eax, [edi+usb_split_info.csplit_bandwidth]

.dec_bandwidth_2:

.dec_bandwidth_2:

        bt      [ebx+ehci_pipe.Flags-sizeof.ehci_pipe], ecx

        bt      [ebx+ehci_pipe.Flags-sizeof.ehci_pipe], ecx

        jnc     @f

        jnc     @f

        sub     word [edx+(ecx-8)*2+ehci_static_ep.Bandwidths - ehci_static_ep.SoftwarePart], ax

        sub     word [edx+(ecx-8)*2+ehci_static_ep.Bandwidths - ehci_static_ep.SoftwarePart], ax

@@:

@@:

        inc     ecx

        inc     ecx

        cmp     ecx, 16

        cmp     ecx, 16

        jb      .dec_bandwidth_2

        jb      .dec_bandwidth_2

        add     esp, sizeof.usb_split_info

        add     esp, sizeof.usb_split_info

        pop     edi

        pop     edi

        ret

        ret

endp

endp

; Helper procedure for ehci_select_tt_interrupt_list.

; Helper procedure for ehci_select_tt_interrupt_list.

; Calculates "best-case budget" according to the core spec,

; Calculates "best-case budget" according to the core spec,

; that is, number of bytes (not bits) corresponding to "optimistic" transaction

; that is, number of bytes (not bits) corresponding to "optimistic" transaction

; time, including inter-packet delays/bus turn-around time,

; time, including inter-packet delays/bus turn-around time,

; but without bit stuffing and timers drift.

; but without bit stuffing and timers drift.

; One extra TT-specific delay is added: TT think time from the hub descriptor.

; One extra TT-specific delay is added: TT think time from the hub descriptor.

; Similar to calc_usb1_bandwidth with corresponding changes.

; Similar to calc_usb1_bandwidth with corresponding changes.

; eax -> usb_hub with TT, ebx -> usb_pipe

; eax -> usb_hub with TT, ebx -> usb_pipe

proc tt_calc_budget

proc tt_calc_budget

        invoke  usbhc_api.usb_get_tt_think_time ; ecx = TT think time in FS-bytes

        invoke  usbhc_api.usb_get_tt_think_time ; ecx = TT think time in FS-bytes

        mov     eax, [ebx+ehci_pipe.Token-sizeof.ehci_pipe]

        mov     eax, [ebx+ehci_pipe.Token-sizeof.ehci_pipe]

        shr     eax, 16

        shr     eax, 16

        and     eax, (1 shl 11) - 1     ; get data length

        and     eax, (1 shl 11) - 1     ; get data length

        bt      [ebx+ehci_pipe.Token-sizeof.ehci_pipe], 12

        bt      [ebx+ehci_pipe.Token-sizeof.ehci_pipe], 12

        jc      .low_speed

        jc      .low_speed

; Full-speed interrupt IN/OUT:

; Full-speed interrupt IN/OUT:

; 33 bits for Token packet (8 for SYNC, 24 for token+address, 3 for EOP),

; 33 bits for Token packet (8 for SYNC, 24 for token+address, 3 for EOP),

; 18 bits for bus turn-around, 11 bits for SYNC+EOP in Data packet,

; 18 bits for bus turn-around, 11 bits for SYNC+EOP in Data packet,

; 2 bits for inter-packet delay, 19 bits for Handshake packet,

; 2 bits for inter-packet delay, 19 bits for Handshake packet,

; 2 bits for another inter-packet delay. 85 bits total, pad to 11 bytes.

; 2 bits for another inter-packet delay. 85 bits total, pad to 11 bytes.

        lea     eax, [eax+11+ecx]

        lea     eax, [eax+11+ecx]

; 1 byte is minimal TT think time in addition to ecx.

; 1 byte is minimal TT think time in addition to ecx.

        ret

        ret

.low_speed:

.low_speed:

; Low-speed interrupt IN/OUT:

; Low-speed interrupt IN/OUT:

; multiply by 8 for LS -> FS,

; multiply by 8 for LS -> FS,

; add 85 bytes as in full-speed interrupt and extra 5 bytes for two PRE packets

; add 85 bytes as in full-speed interrupt and extra 5 bytes for two PRE packets

; and two hub delays.

; and two hub delays.

; 1 byte is minimal TT think time in addition to ecx.

; 1 byte is minimal TT think time in addition to ecx.

        lea     eax, [eax*8+90+ecx]

        lea     eax, [eax*8+90+ecx]

        ret

        ret

endp

endp

; Helper procedure for TT scheduler.

; Helper procedure for TT scheduler.

; Calculates Start-Split/Complete-Split masks and HS bandwidths.

; Calculates Start-Split/Complete-Split masks and HS bandwidths.

; ebx -> usb_pipe, edi -> usb_split_info

; ebx -> usb_pipe, edi -> usb_split_info

proc tt_fill_split_info

proc tt_fill_split_info

; Interrupt endpoints.

; Interrupt endpoints.

; The core spec says in 5.7.3 "Interrupt Transfer Packet Size Constraints" that:

; The core spec says in 5.7.3 "Interrupt Transfer Packet Size Constraints" that:

; The maximum allowable interrupt data payload size is 64 bytes or less for full-speed.

; The maximum allowable interrupt data payload size is 64 bytes or less for full-speed.

; Low-speed devices are limited to eight bytes or less maximum data payload size.

; Low-speed devices are limited to eight bytes or less maximum data payload size.

; This is important for scheduling, it guarantees that in any case transaction fits

; This is important for scheduling, it guarantees that in any case transaction fits

; in two microframes (usually one, two if transaction has started too late in the first

; in two microframes (usually one, two if transaction has started too late in the first

; microframe), so check it.

; microframe), so check it.

        mov     eax, [ebx+ehci_pipe.Token-sizeof.ehci_pipe]

        mov     eax, [ebx+ehci_pipe.Token-sizeof.ehci_pipe]

        mov     ecx, 8

        mov     ecx, 8

        bt      eax, 12

        bt      eax, 12

        jc      @f

        jc      @f

        mov     ecx, 64

        mov     ecx, 64

@@:

@@:

        shr     eax, 16

        shr     eax, 16

        and     eax, (1 shl 11) - 1     ; get data length

        and     eax, (1 shl 11) - 1     ; get data length

        cmp     eax, ecx

        cmp     eax, ecx

        ja      .error

        ja      .error

        add     eax, 3  ; add 3 bytes for other fields in data packet, PID+CRC16

        add     eax, 3  ; add 3 bytes for other fields in data packet, PID+CRC16

; Multiply by 8 for bytes -> bits and then by 7/6 to accomodate bit stuffing;

; Multiply by 8 for bytes -> bits and then by 7/6 to accomodate bit stuffing;

; total 28/3 = 9+1/3

; total 28/3 = 9+1/3

        mov     edx, 55555556h

        mov     edx, 55555556h

        lea     ecx, [eax*9]

        lea     ecx, [eax*9]

        mul     edx

        mul     edx

; One start-split, three complete-splits (unless the last is too far,

; One start-split, three complete-splits (unless the last is too far,

; but this is handled by the caller).

; but this is handled by the caller).

        mov     eax, [ebx+usb_pipe.LastTD]

        mov     eax, [ebx+usb_pipe.LastTD]

        mov     [edi+usb_split_info.microframe_mask], 0x1C01

        mov     [edi+usb_split_info.microframe_mask], 0x1C01

; Structure and HS bandwidth of packets depends on the direction.

; Structure and HS bandwidth of packets depends on the direction.

        bt      [eax+ehci_gtd.Token-sizeof.ehci_gtd], 8

        bt      [eax+ehci_gtd.Token-sizeof.ehci_gtd], 8

        jc      .interrupt_in

        jc      .interrupt_in

.interrupt_out:

.interrupt_out:

; Start-Split phase:

; Start-Split phase:

; 77 bits for SPLIT packet (32 for SYNC, 8 for EOP, 32 for data, 5 for bit stuffing),

; 77 bits for SPLIT packet (32 for SYNC, 8 for EOP, 32 for data, 5 for bit stuffing),

; 88 bits for inter-packet delay, 68 bits for Token packet,

; 88 bits for inter-packet delay, 68 bits for Token packet,

; 88 bits for inter-packet delay, 40 bits for SYNC+EOP in Data packet,

; 88 bits for inter-packet delay, 40 bits for SYNC+EOP in Data packet,

; 88 bits for last inter-packet delay, total 449 bits.

; 88 bits for last inter-packet delay, total 449 bits.

        lea     eax, [edx+ecx+449]

        lea     eax, [edx+ecx+449]

        mov     [edi+usb_split_info.ssplit_bandwidth], eax

        mov     [edi+usb_split_info.ssplit_bandwidth], eax

; Complete-Split phase:

; Complete-Split phase:

; 77 bits for SPLIT packet,

; 77 bits for SPLIT packet,

; 88 bits for inter-packet delay, 68 bits for Token packet,

; 88 bits for inter-packet delay, 68 bits for Token packet,

; 736 bits for bus turn-around, 49 bits for Handshake packet,

; 736 bits for bus turn-around, 49 bits for Handshake packet,

; 8 bits for inter-packet delay, total 1026 bits.

; 8 bits for inter-packet delay, total 1026 bits.

        mov     [edi+usb_split_info.csplit_bandwidth], 1026

        mov     [edi+usb_split_info.csplit_bandwidth], 1026

        ret

        ret

.interrupt_in:

.interrupt_in:

; Start-Split phase:

; Start-Split phase:

; 77 bits for SPLIT packet, 88 bits for inter-packet delay,

; 77 bits for SPLIT packet, 88 bits for inter-packet delay,

; 68 bits for Token packet, 88 bits for another inter-packet delay,

; 68 bits for Token packet, 88 bits for another inter-packet delay,

; total 321 bits.

; total 321 bits.

        mov     [edi+usb_split_info.ssplit_bandwidth], 321

        mov     [edi+usb_split_info.ssplit_bandwidth], 321

; Complete-Split phase:

; Complete-Split phase:

; 77 bits for SPLIT packet, 88 bits for inter-packet delay,

; 77 bits for SPLIT packet, 88 bits for inter-packet delay,

; 68 bits for Token packet, 736 bits for bus turn-around,

; 68 bits for Token packet, 736 bits for bus turn-around,

; 40 bits for SYNC+EOP in Data packet, 8 bits for inter-packet delay,

; 40 bits for SYNC+EOP in Data packet, 8 bits for inter-packet delay,

; total 1017 bits.

; total 1017 bits.

        lea     eax, [edx+ecx+1017]

        lea     eax, [edx+ecx+1017]

        mov     [edi+usb_split_info.csplit_bandwidth], eax

        mov     [edi+usb_split_info.csplit_bandwidth], eax

        ret

        ret

.error:

.error:

        xor     eax, eax

        xor     eax, eax

        ret

        ret

endp

endp