Subversion Repositories Kolibri OS

; Functions for USB pipe manipulation: opening/closing, sending data etc.

;

; =============================================================================

; ================================= Constants =================================

; =============================================================================

; USB pipe types

CONTROL_PIPE = 0

ISOCHRONOUS_PIPE = 1

BULK_PIPE = 2

INTERRUPT_PIPE = 3

; Status codes for transfer callbacks.

; Taken from OHCI as most verbose controller in this sense.

USB_STATUS_OK           = 0     ; no error

USB_STATUS_CRC          = 1     ; CRC error

USB_STATUS_BITSTUFF     = 2     ; bit stuffing violation

USB_STATUS_TOGGLE       = 3     ; data toggle mismatch

USB_STATUS_STALL        = 4     ; device returned STALL

USB_STATUS_NORESPONSE   = 5     ; device not responding

USB_STATUS_PIDCHECK     = 6     ; invalid PID check bits

USB_STATUS_WRONGPID     = 7     ; unexpected PID value

USB_STATUS_OVERRUN      = 8     ; too many data from endpoint

USB_STATUS_UNDERRUN     = 9     ; too few data from endpoint

USB_STATUS_BUFOVERRUN   = 12    ; overflow of internal controller buffer

USB_STATUS_BUFUNDERRUN  = 13    ; underflow of internal controller buffer

USB_STATUS_CLOSED       = 16    ; pipe closed

                                ; either explicitly with USBClosePipe

                                ; or implicitly due to device disconnect

; flags for usb_pipe.Flags

USB_FLAG_CLOSED     = 1         ; pipe is closed, no new transfers

; pipe is closed, return error instead of submitting any new transfer

USB_FLAG_CAN_FREE   = 2

; pipe is closed via explicit call to USBClosePipe, so it can be freed without

; any driver notification; if this flag is not set, then the pipe is closed due

; to device disconnect, so it must remain valid until return from disconnect

; callback provided by the driver

USB_FLAG_EXTRA_WAIT = 4

; The pipe was in wait list, while another event occured;

; when the first wait will be done, reinsert the pipe to wait list

USB_FLAG_CLOSED_BIT = 0 ; USB_FLAG_CLOSED = 1 shl USB_FLAG_CLOSED_BIT

; =============================================================================

; ================================ Structures =================================

; =============================================================================

; Pipe descriptor.

; * An USB pipe is described by two structures, for hardware and for software.

; * This is the software part. The hardware part is defined in a driver

;   of the corresponding controller.

; * The hardware part is located immediately before usb_pipe,

;   both are allocated at once by controller-specific code

;   (it knows the total length, which depends on the hardware part).

struct usb_pipe

Controller      dd      ?

; Pointer to usb_controller structure corresponding to this pipe.

; Must be the first dword after hardware part, see *hci_new_device.

;

; Every endpoint is included into one of processing lists:

; * Bulk list contains all Bulk endpoints.

; * Control list contains all Control endpoints.

; * Several Periodic lists serve Interrupt endpoints with different interval.

;   - There are N=2^n "leaf" periodic lists for N ms interval, one is processed

;     in the frames 0,N,2N,..., another is processed in the frames

;     1,1+N,1+2N,... and so on. The hardware starts processing of periodic

;     endpoints in every frame from the list identified by lower n bits of the

;     frame number; the addresses of these N lists are written to the

;     controller data area during the initialization.

;   - We assume that n=5, N=32 to simplify the code and compact the data.

;     OHCI works in this way. UHCI and EHCI actually have n=10, N=1024,

;     but this is an overkill for interrupt endpoints; the large value of N is

;     useful only for isochronous transfers in UHCI and EHCI. UHCI/EHCI code

;     initializes "leaf" lists k,k+32,k+64,...,k+(1024-32) to the same value,

;     giving essentially N=32.

;     This restriction means that the actual maximum interval of polling any

;     interrupt endpoint is 32ms, which seems to be a reasonable value.

;   - Similarly, there are 16 lists for 16-ms interval, 8 lists for 8-ms

;     interval and so on. Finally, there is one list for 1ms interval. Their

;     addresses are not directly known to the controller.

;   - The hardware serves endpoints following a physical link from the hardware

;     part.

;   - The hardware links are organized as follows. If the list item is not the

;     last, it's hardware link points to the next item. The hardware link of

;     the last item points to the first item of the "next" list.

;   - The "next" list for k-th and (k+M)-th periodic lists for interval 2M ms

;     is the k-th periodic list for interval M ms, M >= 1. In this scheme,

;     if two "previous" lists are served in the frames k,k+2M,k+4M,...

;     and k+M,k+3M,k+5M,... correspondingly, the "next" list is served in

;     the frames k,k+M,k+2M,k+3M,k+4M,k+5M,..., which is exactly what we want.

;   - The links between Periodic, Control, Bulk lists and the processing of

;     Isochronous endpoints are controller-specific.

; * The head of every processing list is a static entry which does not

;   correspond to any real pipe. It is described by usb_static_ep

;   structure, not usb_pipe. For OHCI and UHCI, sizeof.usb_static_ep plus

;   sizeof hardware part is 20h, the total number of lists is

;   32+16+8+4+2+1+1+1 = 65, so all these structures fit in one page,

;   leaving space for other data. This is another reason for 32ms limit.

; * Static endpoint descriptors are kept in *hci_controller structure.

; * All items in every processing list, including the static head, are

;   organized in a double-linked list using .NextVirt and .PrevVirt fields.

; * [[item.NextVirt].PrevVirt] = [[item.PrevVirt].NextVirt] for all items.

NextVirt        dd      ?

; Next endpoint in the processing list.

; See also PrevVirt field and the description before NextVirt field.

PrevVirt        dd      ?

; Previous endpoint in the processing list.

; See also NextVirt field and the description before NextVirt field.

;

; Every pipe has the associated transfer queue, that is, the double-linked

; list of Transfer Descriptors aka TD. For Control, Bulk and Interrupt

; endpoints this list consists of usb_gtd structures

; (GTD = General Transfer Descriptors), for Isochronous endpoints

; this list consists of usb_itd structures, which are not developed yet.

; The pipe needs to know only the last TD; the first TD can be

; obtained as [[pipe.LastTD].NextVirt].

LastTD          dd      ?

; Last TD in the transfer queue.

;

; All opened pipes corresponding to the same physical device are organized in

; the double-linked list using .NextSibling and .PrevSibling fields.

; The head of this list is kept in usb_device_data structure (OpenedPipeList).

; This list is used when the device is disconnected and all pipes for the

; device should be closed.

; Also, all pipes closed due to disconnect must remain valid at least until

; driver-provided disconnect function returns; all should-be-freed-but-not-now

; pipes for one device are organized in another double-linked list with

; the head in usb_device_data.ClosedPipeList; this list uses the same link

; fields, one pipe can never be in both lists.

NextSibling     dd      ?

; Next pipe for the physical device.

PrevSibling     dd      ?

; Previous pipe for the physical device.

;

; When hardware part of pipe is changed, some time is needed before further

; actions so that hardware reacts on this change. During that time,

; all changed pipes are organized in single-linked list with the head

; usb_controller.WaitPipeList* and link field NextWait.

; Currently there are two possible reasons to change:

; change of address/packet size in initial configuration,

; close of the pipe. They are distinguished by USB_FLAG_CLOSED.

NextWait        dd      ?

Lock            MUTEX

; Mutex that guards operations with transfer queue for this pipe.

Type            db      ?

; Type of pipe, one of {CONTROL,ISOCHRONOUS,BULK,INTERRUPT}_PIPE.

Flags           db      ?

; Combination of flags, USB_FLAG_*.

                rb      2       ; dword alignment

DeviceData      dd      ?

; Pointer to usb_device_data, common for all pipes for one device.

ends

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

struct usb_static_ep

; software fields

Bandwidth       dd      ?

; valid only for interrupt/isochronous USB1 lists

; The offsets of the following two fields must be the same in this structure

; and in usb_pipe.

NextVirt        dd      ?

PrevVirt        dd      ?

ends

; This structure represents one transfer descriptor

; ('g' stands for "general" as opposed to isochronous usb_itd).

; Note that one transfer can have several descriptors:

; a control transfer has three stages.

; Additionally, every controller has a limit on transfer length with

; one descriptor (packet size for UHCI, 1K for OHCI, 4K for EHCI),

; large transfers must be split into individual packets according to that limit.

struct usb_gtd

Callback        dd      ?

; Zero for intermediate descriptors, pointer to callback function

; for final descriptor. See the docs for description of the callback.

UserData        dd      ?

; Dword which is passed to Callback as is, not used by USB code itself.

; Two following fields organize all descriptors for one pipe in

; the linked list.

NextVirt        dd      ?

PrevVirt        dd      ?

Pipe            dd      ?

; Pointer to the parent usb_pipe.

Buffer          dd      ?

; Pointer to data for this descriptor.

Length          dd      ?

; Length of data for this descriptor.

ends

; =============================================================================

; =================================== Code ====================================

; =============================================================================

USB_STDCALL_VERIFY = 1

macro stdcall_verify [arg]

{

common

if USB_STDCALL_VERIFY

        pushad

        stdcall arg

        call    verify_regs

        popad

else

        stdcall arg

end if

}

; Initialization of usb_static_ep structure,

; called from controller-specific initialization; edi -> usb_static_ep

proc usb_init_static_endpoint

        mov     [edi+usb_static_ep.NextVirt], edi

        mov     [edi+usb_static_ep.PrevVirt], edi

        ret

endp

; Part of API for drivers, see documentation for USBOpenPipe.

proc usb_open_pipe stdcall uses ebx esi edi,\

 config_pipe:dword, endpoint:dword, maxpacket:dword, type:dword, interval:dword

locals

targetsmask     dd      ?       ; S-Mask for USB2

bandwidth       dd      ?

target          dd      ?

endl

; 1. Verify type of pipe: it must be one of *_PIPE constants.

; Isochronous pipes are not supported yet.

        mov     eax, [type]

        cmp     eax, INTERRUPT_PIPE

        ja      .badtype

        cmp     al, ISOCHRONOUS_PIPE

        jnz     .goodtype

.badtype:

        dbgstr 'unsupported type of USB pipe'

        jmp     .return0

.goodtype:

; 2. Allocate memory for pipe and transfer queue.

; Empty transfer queue consists of one inactive TD.

        mov     ebx, [config_pipe]

        mov     esi, [ebx+usb_pipe.Controller]

        mov     edx, [esi+usb_controller.HardwareFunc]

        call    [edx+usb_hardware_func.AllocPipe]

        test    eax, eax

        jz      .nothing

        mov     edi, eax

        mov     edx, [esi+usb_controller.HardwareFunc]

        call    [edx+usb_hardware_func.AllocTD]

        test    eax, eax

        jz      .free_and_return0

; 3. Initialize transfer queue: pointer to transfer descriptor,

; pointers in transfer descriptor, queue lock.

        mov     [edi+usb_pipe.LastTD], eax

        mov     [eax+usb_gtd.NextVirt], eax

        mov     [eax+usb_gtd.PrevVirt], eax

        mov     [eax+usb_gtd.Pipe], edi

        lea     ecx, [edi+usb_pipe.Lock]

        call    mutex_init

; 4. Initialize software part of pipe structure, except device-related fields.

        mov     al, byte [type]

        mov     [edi+usb_pipe.Type], al

        xor     eax, eax

        mov     [edi+usb_pipe.Flags], al

        mov     [edi+usb_pipe.DeviceData], eax

        mov     [edi+usb_pipe.Controller], esi

        or      [edi+usb_pipe.NextWait], -1

; 5. Initialize device-related fields:

; for zero endpoint, set .NextSibling = .PrevSibling = this;

; for other endpoins, copy device data, take the lock guarding pipe list

; for the device and verify that disconnect processing has not yet started

; for the device. (Since disconnect processing also takes that lock,

; either it has completed or it will not start until we release the lock.)

; Note: usb_device_disconnected should not see the new pipe until

; initialization is complete, so that lock will be held during next steps

; (disconnect processing should either not see it at all, or see fully

; initialized pipe).

        cmp     [endpoint], eax

        jz      .zero_endpoint

        mov     ecx, [ebx+usb_pipe.DeviceData]

        mov     [edi+usb_pipe.DeviceData], ecx

        call    mutex_lock

        test    [ebx+usb_pipe.Flags], USB_FLAG_CLOSED

        jz      .common

.fail:

; If disconnect processing has completed, unlock the mutex, free memory

; allocated in step 2 and return zero.

        call    mutex_unlock

        mov     edx, [esi+usb_controller.HardwareFunc]

        stdcall [edx+usb_hardware_func.FreeTD], [edi+usb_pipe.LastTD]

.free_and_return0:

        mov     edx, [esi+usb_controller.HardwareFunc]

        stdcall [edx+usb_hardware_func.FreePipe], edi

.return0:

        xor     eax, eax

        jmp     .nothing

.zero_endpoint:

        mov     [edi+usb_pipe.NextSibling], edi

        mov     [edi+usb_pipe.PrevSibling], edi

.common:

; 6. Initialize hardware part of pipe structure.

; 6a. Acquire the corresponding mutex.

        lea     ecx, [esi+usb_controller.ControlLock]

        cmp     [type], BULK_PIPE

        jb      @f      ; control pipe

        lea     ecx, [esi+usb_controller.BulkLock]

        jz      @f      ; bulk pipe

        lea     ecx, [esi+usb_controller.PeriodicLock]

@@:

        call    mutex_lock

; 6b. Let the controller-specific code do its job.

        push    ecx

        mov     edx, [esi+usb_controller.HardwareFunc]

        mov     eax, [edi+usb_pipe.LastTD]

        mov     ecx, [config_pipe]

        call    [edx+usb_hardware_func.InitPipe]

        pop     ecx

; 6c. Release the mutex.

        push    eax

        call    mutex_unlock

        pop     eax

; 6d. If controller-specific code indicates failure,

; release the lock taken in step 5, free memory allocated in step 2

; and return zero.

        test    eax, eax

        jz      .fail

; 7. The pipe is initialized. If this is not the first pipe for the device,

; insert it to the tail of pipe list for the device,

; increment number of pipes,

; release the lock taken at step 5.

        mov     ecx, [edi+usb_pipe.DeviceData]

        test    ecx, ecx

        jz      @f

        mov     eax, [ebx+usb_pipe.PrevSibling]

        mov     [edi+usb_pipe.NextSibling], ebx

        mov     [edi+usb_pipe.PrevSibling], eax

        mov     [ebx+usb_pipe.PrevSibling], edi

        mov     [eax+usb_pipe.NextSibling], edi

        inc     [ecx+usb_device_data.NumPipes]

        call    mutex_unlock

@@:

; 8. Return pointer to usb_pipe.

        mov     eax, edi

.nothing:

        ret

endp

; This procedure is called several times during initial device configuration,

; when usb_device_data structure is reallocated.

; It (re)initializes all pointers in usb_device_data.

; ebx -> usb_pipe

proc usb_reinit_pipe_list

        push    eax

; 1. (Re)initialize the lock guarding pipe list.

        mov     ecx, [ebx+usb_pipe.DeviceData]

        call    mutex_init

; 2. Initialize list of opened pipes: two entries, the head and ebx.

        add     ecx, usb_device_data.OpenedPipeList - usb_pipe.NextSibling

        mov     [ecx+usb_pipe.NextSibling], ebx

        mov     [ecx+usb_pipe.PrevSibling], ebx

        mov     [ebx+usb_pipe.NextSibling], ecx

        mov     [ebx+usb_pipe.PrevSibling], ecx

; 3. Initialize list of closed pipes: empty list, only the head is present.

        add     ecx, usb_device_data.ClosedPipeList - usb_device_data.OpenedPipeList

        mov     [ecx+usb_pipe.NextSibling], ecx

        mov     [ecx+usb_pipe.PrevSibling], ecx

        pop     eax

        ret

endp

; Part of API for drivers, see documentation for USBClosePipe.

proc usb_close_pipe

        push    ebx esi ; save used registers to be stdcall

virtual at esp

        rd      2       ; saved registers

        dd      ?       ; return address

.pipe   dd      ?

end virtual

; 1. Lock the pipe list for the device.

        mov     ebx, [.pipe]

        mov     esi, [ebx+usb_pipe.Controller]

        mov     ecx, [ebx+usb_pipe.DeviceData]

        call    mutex_lock

; 2. Set the flag "the driver has abandoned this pipe, free it at any time".

        lea     ecx, [ebx+usb_pipe.Lock]

        call    mutex_lock

        or      [ebx+usb_pipe.Flags], USB_FLAG_CAN_FREE

        call    mutex_unlock

; 3. Call the worker function.

        call    usb_close_pipe_nolock

; 4. Unlock the pipe list for the device.

        mov     ecx, [ebx+usb_pipe.DeviceData]

        call    mutex_unlock

; 5. Wakeup the USB thread so that it can proceed with releasing that pipe.

        push    edi

        call    usb_wakeup

        pop     edi

; 6. Return.

        pop     esi ebx ; restore used registers to be stdcall

        retn    4

endp

; Worker function for pipe closing. Called by usb_close_pipe API and

; from disconnect processing.

; The lock guarding pipe list for the device should be held by the caller.

; ebx -> usb_pipe, esi -> usb_controller

proc usb_close_pipe_nolock

; 1. Set the flag "pipe is closed, ignore new transfers".

; If it was already set, do nothing.

        lea     ecx, [ebx+usb_pipe.Lock]

        call    mutex_lock

        bts     dword [ebx+usb_pipe.Flags], USB_FLAG_CLOSED_BIT

        jc      .closed

        call    mutex_unlock

; 2. Remove the pipe from the list of opened pipes.

        mov     eax, [ebx+usb_pipe.NextSibling]

        mov     edx, [ebx+usb_pipe.PrevSibling]

        mov     [eax+usb_pipe.PrevSibling], edx

        mov     [edx+usb_pipe.NextSibling], eax

; 3. Unlink the pipe from hardware structures.

; 3a. Acquire the corresponding lock.

        lea     edx, [esi+usb_controller.WaitPipeListAsync]

        lea     ecx, [esi+usb_controller.ControlLock]

        cmp     [ebx+usb_pipe.Type], BULK_PIPE

        jb      @f      ; control pipe

        lea     ecx, [esi+usb_controller.BulkLock]

        jz      @f      ; bulk pipe

        add     edx, usb_controller.WaitPipeListPeriodic - usb_controller.WaitPipeListAsync

        lea     ecx, [esi+usb_controller.PeriodicLock]

@@:

        push    edx

        call    mutex_lock

        push    ecx

; 3b. Let the controller-specific code do its job.

        mov     eax, [esi+usb_controller.HardwareFunc]

        call    [eax+usb_hardware_func.UnlinkPipe]

; 3c. Release the corresponding lock.

        pop     ecx

        call    mutex_unlock

; 4. Put the pipe into wait queue.

        pop     edx

        cmp     [ebx+usb_pipe.NextWait], -1

        jz      .insert_new

        or      [ebx+usb_pipe.Flags], USB_FLAG_EXTRA_WAIT

        jmp     .inserted

.insert_new:

        mov     eax, [edx]

        mov     [ebx+usb_pipe.NextWait], eax

        mov     [edx], ebx

.inserted:

; 5. Return.

        ret

.closed:

        call    mutex_unlock

        xor     eax, eax

        ret

endp

; This procedure is called when a pipe with USB_FLAG_CLOSED is removed from the

; corresponding wait list. It means that the hardware has fully forgot about it.

; ebx -> usb_pipe, esi -> usb_controller

proc usb_pipe_closed

        push    edi

        mov     edi, [esi+usb_controller.HardwareFunc]

; 1. Loop over all transfers, calling the driver with USB_STATUS_CLOSED

; and freeing all descriptors.

        mov     edx, [ebx+usb_pipe.LastTD]

        test    edx, edx

        jz      .no_transfer

        mov     edx, [edx+usb_gtd.NextVirt]

.transfer_loop:

        cmp     edx, [ebx+usb_pipe.LastTD]

        jz      .transfer_done

        mov     ecx, [edx+usb_gtd.Callback]

        test    ecx, ecx

        jz      .no_callback

        push    edx

        stdcall_verify ecx, ebx, USB_STATUS_CLOSED, \

                [edx+usb_gtd.Buffer], 0, [edx+usb_gtd.UserData]

        pop     edx

.no_callback:

        push    [edx+usb_gtd.NextVirt]

        stdcall [edi+usb_hardware_func.FreeTD], edx

        pop     edx

        jmp     .transfer_loop

.transfer_done:

        stdcall [edi+usb_hardware_func.FreeTD], edx

.no_transfer:

; 2. Decrement number of pipes for the device.

; If this pipe is the last pipe, go to 5.

        mov     ecx, [ebx+usb_pipe.DeviceData]

        call    mutex_lock

        dec     [ecx+usb_device_data.NumPipes]

        jz      .last_pipe

        call    mutex_unlock

; 3. If the flag "the driver has abandoned this pipe" is set,

; free memory and return.

        test    [ebx+usb_pipe.Flags], USB_FLAG_CAN_FREE

        jz      .nofree

        stdcall [edi+usb_hardware_func.FreePipe], ebx

        pop     edi

        ret

; 4. Otherwise, add it to the list of closed pipes and return.

.nofree:

        add     ecx, usb_device_data.ClosedPipeList - usb_pipe.NextSibling

        mov     edx, [ecx+usb_pipe.PrevSibling]

        mov     [ebx+usb_pipe.NextSibling], ecx

        mov     [ebx+usb_pipe.PrevSibling], edx

        mov     [ecx+usb_pipe.PrevSibling], ebx

        mov     [edx+usb_pipe.NextSibling], ebx

        pop     edi

        ret

.last_pipe:

; That was the last pipe for the device.

; 5. Notify device driver(s) about disconnect.

        call    mutex_unlock

        movzx   eax, [ecx+usb_device_data.NumInterfaces]

        test    eax, eax

        jz      .notify_done

        add     ecx, [ecx+usb_device_data.Interfaces]

.notify_loop:

        mov     edx, [ecx+usb_interface_data.DriverFunc]

        test    edx, edx

        jz      @f

        mov     edx, [edx+USBSRV.usb_func]

        cmp     [edx+USBFUNC.strucsize], USBFUNC.device_disconnect + 4

        jb      @f

        mov     edx, [edx+USBFUNC.device_disconnect]

        test    edx, edx

        jz      @f

        push    eax ecx

        stdcall_verify edx, [ecx+usb_interface_data.DriverData]

        pop     ecx eax

@@:

        add     ecx, sizeof.usb_interface_data

        dec     eax

        jnz     .notify_loop

.notify_done:

; 6. Bus address, if assigned, can now be reused.

        call    [edi+usb_hardware_func.GetDeviceAddress]

        test    eax, eax

        jz      @f

        bts     [esi+usb_controller.ExistingAddresses], eax

@@:

        dbgstr 'USB device disconnected'

; 7. All drivers have returned from disconnect callback,

; so all drivers should not use any device-related pipes.

; Free the remaining pipes.

        mov     eax, [ebx+usb_pipe.DeviceData]

        add     eax, usb_device_data.ClosedPipeList - usb_pipe.NextSibling

        push    eax

        mov     eax, [eax+usb_pipe.NextSibling]

.free_loop:

        cmp     eax, [esp]

        jz      .free_done

        push    [eax+usb_pipe.NextSibling]

        stdcall [edi+usb_hardware_func.FreePipe], eax

        pop     eax

        jmp     .free_loop

.free_done:

        stdcall [edi+usb_hardware_func.FreePipe], ebx

        pop     eax

; 8. Free the usb_device_data structure.

        sub     eax, usb_device_data.ClosedPipeList - usb_pipe.NextSibling

        call    free

; 9. Return.

.nothing:

        pop     edi

        ret

endp

; Part of API for drivers, see documentation for USBNormalTransferAsync.

proc usb_normal_transfer_async stdcall uses ebx edi,\

 pipe:dword, buffer:dword, size:dword, callback:dword, calldata:dword, flags:dword

; 1. Sanity check: callback must be nonzero.

; (It is important for other parts of code.)

        xor     eax, eax

        cmp     [callback], eax

        jz      .nothing

; 2. Lock the transfer queue.

        mov     ebx, [pipe]

        lea     ecx, [ebx+usb_pipe.Lock]

        call    mutex_lock

; 3. If the pipe has already been closed (presumably due to device disconnect),

; release the lock taken in step 2 and return zero.

        xor     eax, eax

        test    [ebx+usb_pipe.Flags], USB_FLAG_CLOSED

        jnz     .unlock

; 4. Allocate and initialize TDs for the transfer.

        mov     edx, [ebx+usb_pipe.Controller]

        mov     edi, [edx+usb_controller.HardwareFunc]

        stdcall [edi+usb_hardware_func.AllocTransfer], [buffer], [size], [flags], [ebx+usb_pipe.LastTD], 0

; If failed, release the lock taken in step 2 and return zero.

        test    eax, eax

        jz      .unlock

; 5. Store callback and its parameters in the last descriptor for this transfer.

        mov     ecx, [eax+usb_gtd.PrevVirt]

        mov     edx, [callback]

        mov     [ecx+usb_gtd.Callback], edx

        mov     edx, [calldata]

        mov     [ecx+usb_gtd.UserData], edx

        mov     edx, [buffer]

        mov     [ecx+usb_gtd.Buffer], edx

; 6. Advance LastTD pointer and activate transfer.

        push    [ebx+usb_pipe.LastTD]

        mov     [ebx+usb_pipe.LastTD], eax

        call    [edi+usb_hardware_func.InsertTransfer]

        pop     eax

; 7. Release the lock taken in step 2 and

; return pointer to the first descriptor for the new transfer.

.unlock:

        push    eax

        lea     ecx, [ebx+usb_pipe.Lock]

        call    mutex_unlock

        pop     eax

.nothing:

        ret

endp

; Part of API for drivers, see documentation for USBControlTransferAsync.

proc usb_control_async stdcall uses ebx edi,\

 pipe:dword, config:dword, buffer:dword, size:dword, callback:dword, calldata:dword, flags:dword

locals

last_td         dd      ?

endl

; 1. Sanity check: callback must be nonzero.

; (It is important for other parts of code.)

        cmp     [callback], 0

        jz      .return0

; 2. Lock the transfer queue.

        mov     ebx, [pipe]

        lea     ecx, [ebx+usb_pipe.Lock]

        call    mutex_lock

; 3. If the pipe has already been closed (presumably due to device disconnect),

; release the lock taken in step 2 and return zero.

        test    [ebx+usb_pipe.Flags], USB_FLAG_CLOSED

        jnz     .unlock_return0

; A control transfer contains two or three stages:

; Setup stage, optional Data stage, Status stage.

; 4. Allocate and initialize TDs for the Setup stage.

; Payload is 8 bytes from [config].

        mov     edx, [ebx+usb_pipe.Controller]

        mov     edi, [edx+usb_controller.HardwareFunc]

        stdcall [edi+usb_hardware_func.AllocTransfer], [config], 8, 0, [ebx+usb_pipe.LastTD], (2 shl 2) + 0

                ; short transfer is an error, direction is DATA0, token is SETUP

        mov     [last_td], eax

        test    eax, eax

        jz      .fail

; 5. Allocate and initialize TDs for the Data stage, if [size] is nonzero.

; Payload is [size] bytes from [buffer].

        mov     edx, [config]

        mov     ecx, (3 shl 2) + 1      ; DATA1, token is OUT

        cmp     byte [edx], 0

        jns     @f

        cmp     [size], 0

        jz      @f

        inc     ecx     ; token is IN

@@:

        cmp     [size], 0

        jz      .nodata

        push    ecx

        stdcall [edi+usb_hardware_func.AllocTransfer], [buffer], [size], [flags], eax, ecx

        pop     ecx

        test    eax, eax

        jz      .fail

        mov     [last_td], eax

.nodata:

; 6. Allocate and initialize TDs for the Status stage.

; No payload.

        xor     ecx, 3  ; IN becomes OUT, OUT becomes IN

        stdcall [edi+usb_hardware_func.AllocTransfer], 0, 0, 0, eax, ecx

        test    eax, eax

        jz      .fail

; 7. Store callback and its parameters in the last descriptor for this transfer.

        mov     ecx, [eax+usb_gtd.PrevVirt]

        mov     edx, [callback]

        mov     [ecx+usb_gtd.Callback], edx

        mov     edx, [calldata]

        mov     [ecx+usb_gtd.UserData], edx

        mov     edx, [buffer]

        mov     [ecx+usb_gtd.Buffer], edx

; 8. Advance LastTD pointer and activate transfer.

        push    [ebx+usb_pipe.LastTD]

        mov     [ebx+usb_pipe.LastTD], eax

        call    [edi+usb_hardware_func.InsertTransfer]

; 9. Release the lock taken in step 2 and

; return pointer to the first descriptor for the new transfer.

        lea     ecx, [ebx+usb_pipe.Lock]

        call    mutex_unlock

        pop     eax

        ret

.fail:

        mov     eax, [last_td]

        test    eax, eax

        jz      .unlock_return0

        stdcall usb_undo_tds, [ebx+usb_pipe.LastTD]

.unlock_return0:

        lea     ecx, [ebx+usb_pipe.Lock]

        call    mutex_unlock

.return0:

        xor     eax, eax

        ret

endp

; Part of API for drivers, see documentation for USBGetParam.

proc usb_get_param

virtual at esp

                dd      ?       ; return address

.pipe           dd      ?

.param          dd      ?

end virtual

        mov     edx, [.param]

        mov     ecx, [.pipe]

        mov     eax, [ecx+usb_pipe.DeviceData]

        test    edx, edx

        jz      .get_device_descriptor

        dec     edx

        jz      .get_config_descriptor

        dec     edx

        jz      .get_speed

        or      eax, -1

        ret     8

.get_device_descriptor:

        add     eax, usb_device_data.DeviceDescriptor

        ret     8

.get_config_descriptor:

        movzx   ecx, [eax+usb_device_data.DeviceDescrSize]

        lea     eax, [eax+ecx+usb_device_data.DeviceDescriptor]

        ret     8

.get_speed:

        movzx   eax, [eax+usb_device_data.Speed]

        ret     8

endp

; Initialize software part of usb_gtd. Called from controller-specific code

; somewhere in AllocTransfer with eax -> next (inactive) usb_gtd,

; ebx -> usb_pipe, ebp frame from call to AllocTransfer with [.td] ->

; current (initializing) usb_gtd.

; Returns ecx = [.td].

proc usb_init_transfer

virtual at ebp-4

.Size   dd      ?

        rd      2

.Buffer dd      ?

        dd      ?

.Flags  dd      ?

.td     dd      ?

end virtual

        mov     [eax+usb_gtd.Pipe], ebx

        mov     ecx, [.td]

        mov     [eax+usb_gtd.PrevVirt], ecx

        mov     edx, [ecx+usb_gtd.NextVirt]

        mov     [ecx+usb_gtd.NextVirt], eax

        mov     [eax+usb_gtd.NextVirt], edx

        mov     [edx+usb_gtd.PrevVirt], eax

        mov     edx, [.Size]

        mov     [ecx+usb_gtd.Length], edx

        xor     edx, edx

        mov     [ecx+usb_gtd.Callback], edx

        mov     [ecx+usb_gtd.UserData], edx

        ret

endp

; Free all TDs for the current transfer if something has failed

; during initialization (e.g. no memory for the next TD).

; Stdcall with one stack argument = first TD for the transfer

; and eax = last initialized TD for the transfer.

proc usb_undo_tds

        push    [eax+usb_gtd.NextVirt]

@@:

        cmp     eax, [esp+8]

        jz      @f

        push    [eax+usb_gtd.PrevVirt]

        stdcall [edi+usb_hardware_func.FreeTD], eax

        pop     eax

        jmp     @b

@@:

        pop     ecx

        mov     [eax+usb_gtd.NextVirt], ecx

        mov     [ecx+usb_gtd.PrevVirt], eax

        ret     4

endp

; Helper procedure for handling short packets in controller-specific code.

; Returns with CF cleared if this is the final packet in some stage:

; for control transfers that means one of Data and Status stages,

; for other transfers - the final packet in the only stage.

proc usb_is_final_packet

        cmp     [ebx+usb_gtd.Callback], 0

        jnz     .nothing

        mov     eax, [ebx+usb_gtd.NextVirt]

        cmp     [eax+usb_gtd.Callback], 0

        jz      .stc

        mov     eax, [ebx+usb_gtd.Pipe]

        cmp     [eax+usb_pipe.Type], CONTROL_PIPE

        jz      .nothing

.stc:

        stc

.nothing:

        ret

endp

; Helper procedure for controller-specific code:

; removes one TD from the transfer queue, ebx -> usb_gtd to remove.

proc usb_unlink_td

        mov     ecx, [ebx+usb_gtd.Pipe]

        add     ecx, usb_pipe.Lock

        call    mutex_lock

        mov     eax, [ebx+usb_gtd.PrevVirt]

        mov     edx, [ebx+usb_gtd.NextVirt]

        mov     [edx+usb_gtd.PrevVirt], eax

        mov     [eax+usb_gtd.NextVirt], edx

        call    mutex_unlock

        ret

endp

if USB_STDCALL_VERIFY

proc verify_regs

virtual at esp

        dd      ?       ; return address

.edi    dd      ?

.esi    dd      ?

.ebp    dd      ?

.esp    dd      ?

.ebx    dd      ?

.edx    dd      ?

.ecx    dd      ?

.eax    dd      ?

end virtual

        cmp     ebx, [.ebx]

        jz      @f

        dbgstr 'ERROR!!! ebx changed'

@@:

        cmp     esi, [.esi]

        jz      @f

        dbgstr 'ERROR!!! esi changed'

@@:

        cmp     edi, [.edi]

        jz      @f

        dbgstr 'ERROR!!! edi changed'

@@:

        cmp     ebp, [.ebp]

        jz      @f

        dbgstr 'ERROR!!! ebp changed'

@@:

        ret

endp

end if