Subversion Repositories Kolibri OS

; * The hardware part consists of first 52 bytes and corresponds to

; * The hardware part consists of first 52 bytes and corresponds to

;   the Queue Element Transfer Descriptor from EHCI specification.

;   the Queue Element Transfer Descriptor from EHCI specification.

; * The hardware requires 32-bytes alignment of the hardware part, so

; * The hardware requires 32-bytes alignment of the hardware part, so

;   the entire descriptor must be 32-bytes aligned. Since the allocator

;   the entire descriptor must be 32-bytes aligned. Since the allocator

;   (usb_allocate_common) allocates memory sequentially from page start

;   (usb_allocate_common) allocates memory sequentially from page start

; * The hardware also requires that the hardware part must not cross page

; * The hardware also requires that the hardware part must not cross page

;   boundary; the allocator satisfies this automatically.

;   boundary; the allocator satisfies this automatically.

struct ehci_gtd ehci_hardware_td

struct ehci_gtd ehci_hardware_td

Flags                   dd      ?

Flags                   dd      ?

; Copy of flags from the call to usb_*_transfer_async.

; Copy of flags from the call to usb_*_transfer_async.

ends

ends

; EHCI-specific part of a pipe descriptor.

; EHCI-specific part of a pipe descriptor.

; * This structure corresponds to the Queue Head from the EHCI specification.

; * This structure corresponds to the Queue Head from the EHCI specification.

; * The hardware requires 32-bytes alignment of the hardware part.

; * The hardware requires 32-bytes alignment of the hardware part.

;   divisible by 32.

;   must be divisible by 32; ehci_alloc_pipe ensures this.

; * The hardware requires also that the hardware part must not cross page

; * The hardware requires also that the hardware part must not cross page

;   boundary; the allocator satisfies this automatically.

;   boundary; the allocator satisfies this automatically.

struct ehci_pipe

struct ehci_pipe

NextQH                  dd      ?

NextQH                  dd      ?

; Working area for the current TD, if there is any.

; Working area for the current TD, if there is any.

; When TD is retired, it is written to that TD and Overlay is loaded

; When TD is retired, it is written to that TD and Overlay is loaded

; from the new TD, if any.

; from the new TD, if any.

BaseList                dd      ?

BaseList                dd      ?

; Pointer to head of the corresponding pipe list.

; Pointer to head of the corresponding pipe list.

ends

ends

; This structure describes the static head of every list of pipes.

; This structure describes the static head of every list of pipes.

; The hardware requires 32-bytes alignment of this structure.

; The hardware requires 32-bytes alignment of this structure.

; All instances of this structure are located sequentially in ehci_controller,

; All instances of this structure are located sequentially in ehci_controller,

; ehci_controller is page-aligned, so it is sufficient to make this structure

; ehci_controller is page-aligned, so it is sufficient to make this structure

; This procedure is called from usb_set_address_callback

; This procedure is called from usb_set_address_callback

; and stores USB device address in the ehci_pipe structure.

; and stores USB device address in the ehci_pipe structure.

; in: esi -> usb_controller, ebx -> usb_pipe, cl = address

; in: esi -> usb_controller, ebx -> usb_pipe, cl = address

        mov     byte [ebx+ehci_pipe.Token-ehci_pipe.SoftwarePart], cl

        mov     byte [ebx+ehci_pipe.Token-sizeof.ehci_pipe], cl

        call    usb_subscribe_control

        call    usb_subscribe_control

        ret

        ret

endp

endp

; This procedure returns USB device address from the ehci_pipe structure.

; This procedure returns USB device address from the ehci_pipe structure.

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

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

proc ehci_get_device_address

proc ehci_get_device_address

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

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

        and     eax, 7Fh

        and     eax, 7Fh

        ret

        ret

; This procedure is called from usb_get_descr8_callback when

; This procedure is called from usb_get_descr8_callback when

; the packet size for zero endpoint becomes known and

; the packet size for zero endpoint becomes known and

; stores the packet size in ehci_pipe structure.

; stores the packet size in ehci_pipe structure.

; in: esi -> usb_controller, ebx -> usb_pipe, ecx = packet size

; in: esi -> usb_controller, ebx -> usb_pipe, ecx = packet size

proc ehci_set_endpoint_packet_size

proc ehci_set_endpoint_packet_size

        and     eax, not (0x7FF shl 16)

        and     eax, not (0x7FF shl 16)

        shl     ecx, 16

        shl     ecx, 16

        or      eax, ecx

        or      eax, ecx

; Wait until hardware cache is evicted.

; Wait until hardware cache is evicted.

        call    usb_subscribe_control

        call    usb_subscribe_control

        ret

        ret

endp

endp

; Both hardware+software parts must be allocated, returns pointer to usb_pipe

; Both hardware+software parts must be allocated, returns pointer to usb_pipe

; (software part).

; (software part).

proc ehci_alloc_pipe

proc ehci_alloc_pipe

        push    ebx

        push    ebx

        mov     ebx, ehci_ep_mutex

        mov     ebx, ehci_ep_mutex

        test    eax, eax

        test    eax, eax

        jz      @f

        jz      @f

@@:

@@:

        pop     ebx

        pop     ebx

        ret

        ret

endp

endp

proc ehci_free_pipe

proc ehci_free_pipe

virtual at esp

virtual at esp

        dd      ?       ; return address

        dd      ?       ; return address

.ptr    dd      ?

.ptr    dd      ?

end virtual

end virtual

        jmp     usb_free_common

        jmp     usb_free_common

endp

endp

; This procedure is called from API usb_open_pipe and processes

; This procedure is called from API usb_open_pipe and processes

.type           dd      ?

.type           dd      ?

.interval       dd      ?

.interval       dd      ?

end virtual

end virtual

; 1. Zero all fields in the hardware part.

; 1. Zero all fields in the hardware part.

        push    eax ecx

        push    eax ecx

        xor     eax, eax

        xor     eax, eax

        rep stosd

        rep stosd

        pop     ecx eax

        pop     ecx eax

; 2. Setup PID in the first TD and make sure that the it is not active.

; 2. Setup PID in the first TD and make sure that the it is not active.

        xor     edx, edx

        xor     edx, edx

        test    byte [.endpoint], 80h

        test    byte [.endpoint], 80h

        setnz   dh

        setnz   dh

; 3. Store physical address of the first TD.

; 3. Store physical address of the first TD.

        call    get_phys_addr

        call    get_phys_addr

; 4. Fill ehci_pipe.Flags except for S- and C-masks.

; 4. Fill ehci_pipe.Flags except for S- and C-masks.

; Copy location from the config pipe.

; Copy location from the config pipe.

        and     eax, 3FFF0000h

        and     eax, 3FFF0000h

; Use 1 requests per microframe for control/bulk endpoints,

; Use 1 requests per microframe for control/bulk endpoints,

; use value from the endpoint descriptor for periodic endpoints

; use value from the endpoint descriptor for periodic endpoints

        movi    edx, 1

        movi    edx, 1

        test    [.type], 1

        test    [.type], 1

        shr     edx, 11

        shr     edx, 11

        inc     edx

        inc     edx

@@:

@@:

        shl     edx, 30

        shl     edx, 30

        or      eax, edx

        or      eax, edx

; 5. Fill ehci_pipe.Token.

; 5. Fill ehci_pipe.Token.

; copy following fields from the config pipe:

; copy following fields from the config pipe:

; DeviceAddress, EndpointSpeed, ControlEndpoint if new type is control

; DeviceAddress, EndpointSpeed, ControlEndpoint if new type is control

        mov     ecx, eax

        mov     ecx, eax

        and     eax, 307Fh

        and     eax, 307Fh

        and     ecx, 8000000h

        and     ecx, 8000000h

        cmp     [.type], BULK_PIPE

        cmp     [.type], BULK_PIPE

        jnz     .nonak

        jnz     .nonak

@@:

@@:

        or      eax, 40000000h

        or      eax, 40000000h

.nonak:

.nonak:

; 5. Select the corresponding list and insert to the list.

; 5. Select the corresponding list and insert to the list.

; 5a. Use Control list for control pipes, Bulk list for bulk pipes.

; 5a. Use Control list for control pipes, Bulk list for bulk pipes.

        lea     edx, [esi+ehci_controller.ControlED.SoftwarePart-sizeof.ehci_controller]

        lea     edx, [esi+ehci_controller.ControlED.SoftwarePart-sizeof.ehci_controller]

        cmp     [.type], BULK_PIPE

        cmp     [.type], BULK_PIPE

        jb      .insert ; control pipe

        jb      .insert ; control pipe

; based on the current bandwidth distribution and the requested bandwidth.

; based on the current bandwidth distribution and the requested bandwidth.

; There are two schedulers, one for high-speed devices,

; There are two schedulers, one for high-speed devices,

; another for split transactions.

; another for split transactions.

; This could fail if the requested bandwidth is not available;

; This could fail if the requested bandwidth is not available;

; if so, return an error.

; if so, return an error.

        jnz     .interrupt_fs

        jnz     .interrupt_fs

        call    ehci_select_hs_interrupt_list

        call    ehci_select_hs_interrupt_list

        jmp     .interrupt_common

        jmp     .interrupt_common

.interrupt_fs:

.interrupt_fs:

        call    ehci_select_fs_interrupt_list

        call    ehci_select_fs_interrupt_list

.interrupt_common:

.interrupt_common:

        test    edx, edx

        test    edx, edx

        jz      .return0

        jz      .return0

.insert:

.insert:

; Insert to the head of the corresponding list.

; Insert to the head of the corresponding list.

; Note: inserting to the head guarantees that the list traverse in

; Note: inserting to the head guarantees that the list traverse in

; ehci_process_updated_schedule, once started, will not interact with new pipes.

; ehci_process_updated_schedule, once started, will not interact with new pipes.

; However, we still need to ensure that links in the new pipe (edi.NextVirt)

; However, we still need to ensure that links in the new pipe (edi.NextVirt)

; are initialized before links to the new pipe (edx.NextVirt).

; are initialized before links to the new pipe (edx.NextVirt).

        mov     [ecx+usb_pipe.PrevVirt], edi

        mov     [ecx+usb_pipe.PrevVirt], edi

        mov     [edx+usb_pipe.NextVirt], edi

        mov     [edx+usb_pipe.NextVirt], edi

; 5d. Insert in the hardware list: copy previous NextQH to the new pipe,

; 5d. Insert in the hardware list: copy previous NextQH to the new pipe,

; store the physical address of the new pipe to previous NextQH.

; store the physical address of the new pipe to previous NextQH.

        mov     ecx, [edx+ehci_static_ep.NextQH-ehci_static_ep.SoftwarePart]

        mov     ecx, [edx+ehci_static_ep.NextQH-ehci_static_ep.SoftwarePart]

        call    get_phys_addr

        call    get_phys_addr

        inc     eax

        inc     eax

        inc     eax

        inc     eax

        mov     [edx+ehci_static_ep.NextQH-ehci_static_ep.SoftwarePart], eax

        mov     [edx+ehci_static_ep.NextQH-ehci_static_ep.SoftwarePart], eax

; 6. Return with nonzero eax.

; 6. Return with nonzero eax.

; One transfer descriptor can describe up to 5 pages.

; One transfer descriptor can describe up to 5 pages.

; In the worst case (when the buffer is something*1000h+0FFFh)

; In the worst case (when the buffer is something*1000h+0FFFh)

; this corresponds to 4001h bytes. If the requested size is

; this corresponds to 4001h bytes. If the requested size is

; greater, we should split the transfer into several descriptors.

; greater, we should split the transfer into several descriptors.

; Boundaries to split must be multiples of endpoint transfer size

; Boundaries to split must be multiples of endpoint transfer size

; 2. While the remaining data cannot fit in one descriptor,

; 2. While the remaining data cannot fit in one descriptor,

; allocate full descriptors (of maximal possible size).

; allocate full descriptors (of maximal possible size).

        mov     [packetSize], edi

        mov     [packetSize], edi

.fullpackets:

.fullpackets:

        call    ehci_alloc_packet

        call    ehci_alloc_packet

        test    eax, eax

        test    eax, eax

        jz      .fail

        jz      .fail

        mov     [td], eax

        mov     [td], eax

        add     [buffer], edi

        add     [buffer], edi

        sub     [size], edi

        sub     [size], edi

; 3. The remaining data can fit in one packet;

; 3. The remaining data can fit in one packet;

; allocate the last descriptor with size = size of remaining data.

; allocate the last descriptor with size = size of remaining data.

.lastpacket:

.lastpacket:

        mov     eax, [size]

        mov     eax, [size]

        mov     [packetSize], eax

        mov     [packetSize], eax

        call    ehci_alloc_packet

        call    ehci_alloc_packet

        test    eax, eax

        test    eax, eax

        jz      .fail

        jz      .fail

; 9. Update flags in the last packet.

; 9. Update flags in the last packet.

        mov     edx, [flags]

        mov     edx, [flags]

; 10. Fill AlternateNextTD field in all allocated TDs.

; 10. Fill AlternateNextTD field in all allocated TDs.

; If the caller says that short transfer is ok, the queue must advance to

; If the caller says that short transfer is ok, the queue must advance to

; the next descriptor, which is in eax.

; the next descriptor, which is in eax.

; Otherwise, the queue should stop, so make AlternateNextTD point to

; Otherwise, the queue should stop, so make AlternateNextTD point to

; always-inactive descriptor StopQueueTD.

; always-inactive descriptor StopQueueTD.

        push    eax

        push    eax

        test    dl, 1

        test    dl, 1

        jz      .disable_short

        jz      .disable_short

        jmp     @f

        jmp     @f

.disable_short:

.disable_short:

        mov     eax, [ebx+usb_pipe.Controller]

        mov     eax, [ebx+usb_pipe.Controller]

        add     eax, ehci_controller.StopQueueTD - sizeof.ehci_controller

        add     eax, ehci_controller.StopQueueTD - sizeof.ehci_controller

@@:

@@:

        call    get_phys_addr

        call    get_phys_addr

        mov     edx, [origTD]

        mov     edx, [origTD]

@@:

@@:

        cmp     edx, [esp]

        cmp     edx, [esp]

        jz      @f

        jz      @f

        mov     edx, [edx+usb_gtd.NextVirt]

        mov     edx, [edx+usb_gtd.NextVirt]

        jmp     @b

        jmp     @b

@@:

@@:

        pop     eax

        pop     eax

        ret

        ret

; 2. Initialize controller-independent parts of both TDs.

; 2. Initialize controller-independent parts of both TDs.

        push    eax

        push    eax

        call    usb_init_transfer

        call    usb_init_transfer

        pop     eax

        pop     eax

; 3. Copy PID to the new descriptor.

; 3. Copy PID to the new descriptor.

; 4. Save the returned value (next descriptor).

; 4. Save the returned value (next descriptor).

        push    eax

        push    eax

; 5. Store the physical address of the next descriptor.

; 5. Store the physical address of the next descriptor.

        call    get_phys_addr

        call    get_phys_addr

; 6. For zero-length transfers, store zero in all fields for buffer addresses.

; 6. For zero-length transfers, store zero in all fields for buffer addresses.

; Otherwise, fill them with real values.

; Otherwise, fill them with real values.

        xor     eax, eax

        xor     eax, eax

repeat 10

repeat 10

end repeat

end repeat

        cmp     [.packetSize], eax

        cmp     [.packetSize], eax

        jz      @f

        jz      @f

        mov     eax, [.buffer]

        mov     eax, [.buffer]

        call    get_phys_addr

        call    get_phys_addr

        and     eax, 0xFFF

        and     eax, 0xFFF

        mov     edx, [.packetSize]

        mov     edx, [.packetSize]

        add     edx, eax

        add     edx, eax

        sub     edx, 0x1000

        sub     edx, 0x1000

        jbe     @f

        jbe     @f

        mov     eax, [.buffer]

        mov     eax, [.buffer]

        add     eax, 0x1000

        add     eax, 0x1000

        call    get_pg_addr

        call    get_pg_addr

        sub     edx, 0x1000

        sub     edx, 0x1000

        jbe     @f

        jbe     @f

        mov     eax, [.buffer]

        mov     eax, [.buffer]

        add     eax, 0x2000

        add     eax, 0x2000

        call    get_pg_addr

        call    get_pg_addr

        sub     edx, 0x1000

        sub     edx, 0x1000

        jbe     @f

        jbe     @f

        mov     eax, [.buffer]

        mov     eax, [.buffer]

        add     eax, 0x3000

        add     eax, 0x3000

        call    get_pg_addr

        call    get_pg_addr

        sub     edx, 0x1000

        sub     edx, 0x1000

        jbe     @f

        jbe     @f

        mov     eax, [.buffer]

        mov     eax, [.buffer]

        add     eax, 0x4000

        add     eax, 0x4000

        call    get_pg_addr

        call    get_pg_addr

@@:

@@:

; 7. Fill Token field:

; 7. Fill Token field:

; set Status = 0 (inactive, ehci_insert_transfer would mark everything active);

; set Status = 0 (inactive, ehci_insert_transfer would mark everything active);

; keep current PID if [.direction] is zero, use two lower bits of [.direction]

; keep current PID if [.direction] is zero, use two lower bits of [.direction]

; otherwise shifted as (0|1|2) -> (2|0|1);

; otherwise shifted as (0|1|2) -> (2|0|1);

; set error counter to 3;

; set error counter to 3;

; set current page to 0;

; set current page to 0;

; do not interrupt on complete (ehci_insert_transfer sets this bit where needed);

; do not interrupt on complete (ehci_insert_transfer sets this bit where needed);

; set DataToggle to bit 2 of [.direction].

; set DataToggle to bit 2 of [.direction].

        and     eax, 300h       ; keep PID code

        and     eax, 300h       ; keep PID code

        mov     edx, [.direction]

        mov     edx, [.direction]

        test    edx, edx

        test    edx, edx

        jz      .haspid

        jz      .haspid

        and     edx, 3

        and     edx, 3

.haspid:

.haspid:

        or      eax, 0C00h

        or      eax, 0C00h

        mov     edx, [.packetSize]

        mov     edx, [.packetSize]

        shl     edx, 16

        shl     edx, 16

        or      eax, edx

        or      eax, edx

; 4. Restore the returned value saved in step 2.

; 4. Restore the returned value saved in step 2.

        pop     eax

        pop     eax

.nothing:

.nothing:

        ret

        ret

endp

endp

; This procedure is called from several places in main USB code

; This procedure is called from several places in main USB code

; and activates the transfer which was previously allocated by

; and activates the transfer which was previously allocated by

; ehci_alloc_transfer.

; ehci_alloc_transfer.

; ecx -> last descriptor for the transfer, ebx -> usb_pipe

; ecx -> last descriptor for the transfer, ebx -> usb_pipe

proc ehci_insert_transfer

proc ehci_insert_transfer

        mov     eax, [esp+4]

        mov     eax, [esp+4]

.activate:

.activate:

        cmp     eax, ecx

        cmp     eax, ecx

        mov     eax, [eax+usb_gtd.NextVirt]

        mov     eax, [eax+usb_gtd.NextVirt]

        jnz     .activate

        jnz     .activate

        ret

        ret

endp

endp

        mov     edx, [eax+usb_device_data.Hub]

        mov     edx, [eax+usb_device_data.Hub]

        jmp     .find_hs_hub

        jmp     .find_hs_hub

.found_hs_hub:

.found_hs_hub:

        mov     edx, [edx+usb_hub.ConfigPipe]

        mov     edx, [edx+usb_hub.ConfigPipe]

        inc     ecx

        inc     ecx

        shl     ecx, 23

        shl     ecx, 23

        and     edx, 7Fh

        and     edx, 7Fh

        shl     edx, 16

        shl     edx, 16

        or      edx, ecx        ; ehci_pipe.Flags

        or      edx, ecx        ; ehci_pipe.Flags

        pop     eax

        pop     eax

        or      eax, 1 shl 27   ; ehci_pipe.Token

        or      eax, 1 shl 27   ; ehci_pipe.Token

.common:

.common:

; 5. Create pseudo-pipe in the stack.

; 5. Create pseudo-pipe in the stack.

; See ehci_init_pipe: only .Controller, .Token, .Flags fields are used.

; See ehci_init_pipe: only .Controller, .Token, .Flags fields are used.

        mov     ecx, esp

        mov     ecx, esp

        push    edx     ; ehci_pipe.Flags

        push    edx     ; ehci_pipe.Flags

        push    eax     ; ehci_pipe.Token

        push    eax     ; ehci_pipe.Token

; 6. Notify the protocol layer.

; 6. Notify the protocol layer.

        call    usb_new_device

        call    usb_new_device

; 7. Cleanup the stack after step 5 and return.

; 7. Cleanup the stack after step 5 and return.

        pop     ecx ebx ; restore used registers

        pop     ecx ebx ; restore used registers

        ret

        ret

endp

endp

.tdloop:

.tdloop:

; 3. For every descriptor, test active flag and check for end-of-queue;

; 3. For every descriptor, test active flag and check for end-of-queue;

; if either of conditions holds, exit from the internal loop.

; if either of conditions holds, exit from the internal loop.

        cmp     ebx, [esp]

        cmp     ebx, [esp]

        jz      .tddone

        jz      .tddone

        js      .tddone

        js      .tddone

; Release the queue lock while processing one descriptor:

; Release the queue lock while processing one descriptor:

; callback function could (and often would) schedule another transfer.

; callback function could (and often would) schedule another transfer.

        push    ecx

        push    ecx

        call    mutex_unlock

        call    mutex_unlock

proc ehci_process_updated_td

proc ehci_process_updated_td

;       mov     eax, [ebx+usb_gtd.Pipe]

;       mov     eax, [ebx+usb_gtd.Pipe]

;       cmp     [eax+usb_pipe.Type], INTERRUPT_PIPE

;       cmp     [eax+usb_pipe.Type], INTERRUPT_PIPE

;       jnz     @f

;       jnz     @f

;       DEBUGF 1,'K : finalized TD for pipe %x:\n',eax

;       DEBUGF 1,'K : finalized TD for pipe %x:\n',eax

;       DEBUGF 1,'K : %x %x %x %x\n',[eax],[eax+4],[eax+8],[eax+12]

;       DEBUGF 1,'K : %x %x %x %x\n',[eax],[eax+4],[eax+8],[eax+12]

;       DEBUGF 1,'K : %x %x %x %x\n',[eax+16],[eax+20],[eax+24],[eax+28]

;       DEBUGF 1,'K : %x %x %x %x\n',[eax+16],[eax+20],[eax+24],[eax+28]

;@@:

;@@:

; 1. Remove this descriptor from the list of descriptors for this pipe.

; 1. Remove this descriptor from the list of descriptors for this pipe.

        call    usb_unlink_td

        call    usb_unlink_td

; 2. Calculate actual number of bytes transferred.

; 2. Calculate actual number of bytes transferred.

        lea     edx, [eax+eax]

        lea     edx, [eax+eax]

        shr     edx, 17

        shr     edx, 17

        sub     edx, [ebx+usb_gtd.Length]

        sub     edx, [ebx+usb_gtd.Length]

        neg     edx

        neg     edx

; 3. Check whether we need some special processing beyond notifying the driver.

; 3. Check whether we need some special processing beyond notifying the driver.

; If special processing is not needed, advance to 4 with ecx = 0.

; If special processing is not needed, advance to 4 with ecx = 0.

; Otherwise, go to 6.

; Otherwise, go to 6.

        xor     ecx, ecx

        xor     ecx, ecx

        test    al, 40h

        test    al, 40h

        jnz     .error

        jnz     .error

        jnz     .notify

        jnz     .notify

        cmp     edx, [ebx+usb_gtd.Length]

        cmp     edx, [ebx+usb_gtd.Length]

        jnz     .special

        jnz     .special

.notify:

.notify:

; 4. Either the descriptor in ebx was processed without errors,

; 4. Either the descriptor in ebx was processed without errors,

        stdcall ehci_free_td, ebx

        stdcall ehci_free_td, ebx

        pop     ebx

        pop     ebx

        ret

        ret

.error:

.error:

        push    ebx

        push    ebx

        DEBUGF 1,'K : TD failed:\n'

        DEBUGF 1,'K : TD failed:\n'

        DEBUGF 1,'K : %x %x %x %x\n',[ebx],[ebx+4],[ebx+8],[ebx+12]

        DEBUGF 1,'K : %x %x %x %x\n',[ebx],[ebx+4],[ebx+8],[ebx+12]

        DEBUGF 1,'K : %x %x %x %x\n',[ebx+16],[ebx+20],[ebx+24],[ebx+28]

        DEBUGF 1,'K : %x %x %x %x\n',[ebx+16],[ebx+20],[ebx+24],[ebx+28]

        pop     ebx

        pop     ebx

        DEBUGF 1,'K : pipe now:\n'

        DEBUGF 1,'K : pipe now:\n'

        mov     ecx, [ebx+usb_gtd.Pipe]

        mov     ecx, [ebx+usb_gtd.Pipe]

        DEBUGF 1,'K : %x %x %x %x\n',[ecx],[ecx+4],[ecx+8],[ecx+12]

        DEBUGF 1,'K : %x %x %x %x\n',[ecx],[ecx+4],[ecx+8],[ecx+12]

        DEBUGF 1,'K : %x %x %x %x\n',[ecx+16],[ecx+20],[ecx+24],[ecx+28]

        DEBUGF 1,'K : %x %x %x %x\n',[ecx+16],[ecx+20],[ecx+24],[ecx+28]

        DEBUGF 1,'K : %x %x %x %x\n',[ecx+32],[ecx+36],[ecx+40],[ecx+44]

        DEBUGF 1,'K : %x %x %x %x\n',[ecx+32],[ecx+36],[ecx+40],[ecx+44]

.special:

.special:

; 6. Special processing is needed.

; 6. Special processing is needed.

.know_error:

.know_error:

; 6d. If error code is USB_STATUS_UNDERRUN and the last TD allows short packets,

; 6d. If error code is USB_STATUS_UNDERRUN and the last TD allows short packets,

; it is not an error; in this case, go to 4 with ecx = 0.

; it is not an error; in this case, go to 4 with ecx = 0.

        cmp     ecx, USB_STATUS_UNDERRUN

        cmp     ecx, USB_STATUS_UNDERRUN

        jnz     @f

        jnz     @f

        jz      @f

        jz      @f

        xor     ecx, ecx

        xor     ecx, ecx

        pop     edx     ; length

        pop     edx     ; length

        jmp     .notify

        jmp     .notify

@@:

@@:

; Control pipes normally recover at the next SETUP transaction (first stage

; Control pipes normally recover at the next SETUP transaction (first stage

; of any control transfer), so we hope on the best and just advance the queue

; of any control transfer), so we hope on the best and just advance the queue

; to the next transfer. (According to the standard, "A control pipe may also

; to the next transfer. (According to the standard, "A control pipe may also

; support functional stall as well, but this is not recommended.").

; support functional stall as well, but this is not recommended.").

        mov     edx, [ebx+usb_gtd.Pipe]

        mov     edx, [ebx+usb_gtd.Pipe]

        or      al, 1

        or      al, 1

        cmp     [edx+usb_pipe.Type], CONTROL_PIPE

        cmp     [edx+usb_pipe.Type], CONTROL_PIPE

        jz      .control

        jz      .control

; Bulk/interrupt transfer; halt the queue.

; Bulk/interrupt transfer; halt the queue.

        pop     edx

        pop     edx

        jmp     .notify

        jmp     .notify

; Control transfer.

; Control transfer.

.control:

.control:

        pop     edx

        pop     edx

        jmp     .notify

        jmp     .notify

endp

endp

; This procedure unlinks the pipe from the corresponding pipe list.

; This procedure unlinks the pipe from the corresponding pipe list.

; esi -> usb_controller, ebx -> usb_pipe

; esi -> usb_controller, ebx -> usb_pipe

proc ehci_unlink_pipe

proc ehci_unlink_pipe

        cmp     [ebx+usb_pipe.Type], INTERRUPT_PIPE

        cmp     [ebx+usb_pipe.Type], INTERRUPT_PIPE

        test    word [ebx+ehci_pipe.Flags-ehci_pipe.SoftwarePart+2], 3FFFh

        test    word [ebx+ehci_pipe.Flags-sizeof.ehci_pipe+2], 3FFFh

        jnz     .interrupt_fs

        jnz     .interrupt_fs

        call    ehci_hs_interrupt_list_unlink

        call    ehci_hs_interrupt_list_unlink

        jmp     .interrupt_common

        jmp     .interrupt_common

.interrupt_fs:

.interrupt_fs:

        mov     [edx+usb_pipe.PrevVirt], eax

        mov     [edx+usb_pipe.PrevVirt], eax

        mov     [eax+usb_pipe.NextVirt], edx

        mov     [eax+usb_pipe.NextVirt], edx

        mov     edx, esi

        mov     edx, esi

        sub     edx, eax

        sub     edx, eax

        cmp     edx, sizeof.ehci_controller

        cmp     edx, sizeof.ehci_controller

        jb      .prev_is_static

        jb      .prev_is_static

        ret

        ret

.prev_is_static:

.prev_is_static:

        mov     [eax+ehci_static_ep.NextQH-ehci_static_ep.SoftwarePart], edx

        mov     [eax+ehci_static_ep.NextQH-ehci_static_ep.SoftwarePart], edx

        ret

        ret

endp

endp

proc ehci_alloc_td

proc ehci_alloc_td

        push    ebx

        push    ebx

        stdcall usb_allocate_common, sizeof.ehci_gtd

        stdcall usb_allocate_common, (sizeof.ehci_gtd + sizeof.usb_gtd + 1Fh) and not 1Fh

        test    eax, eax

        test    eax, eax

        add     eax, ehci_gtd.SoftwarePart

        add     eax, sizeof.ehci_gtd

@@:

@@:

        pop     ebx

        pop     ebx

        ret

        ret

endp

endp

; This procedure is called from several places from main USB code and

; This procedure is called from several places from main USB code and

; frees all additional data associated with the transfer descriptor.

; frees all additional data associated with the transfer descriptor.

proc ehci_free_td

proc ehci_free_td

        sub     dword [esp+4], ehci_gtd.SoftwarePart

        sub     dword [esp+4], sizeof.ehci_gtd