WebSVN – Kolibri OS – Diff – /kernel/trunk/bus/usb/pipe.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2013-2015. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 5363 $
 
 
; Functions for USB pipe manipulation: opening/closing, sending data etc.
;
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
}
if USB_STDCALL_VERIFY
STDCALL_VERIFY_EXTRA = 20h
else
STDCALL_VERIFY_EXTRA = 0
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
tt_vars         rd      24      ; should be enough for ehci_select_tt_interrupt_list
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.
        test    [ebx+usb_pipe.Flags], USB_FLAG_DISABLED
        jnz     @f
        mov     eax, [esi+usb_controller.HardwareFunc]
        call    [eax+usb_hardware_func.DisablePipe]
@@:
        mov     eax, [esi+usb_controller.HardwareFunc]
        call    [eax+usb_hardware_func.UnlinkPipe]
        mov     edx, [ebx+usb_pipe.NextVirt]
        mov     eax, [ebx+usb_pipe.PrevVirt]
        mov     [edx+usb_pipe.PrevVirt], eax
        mov     [eax+usb_pipe.NextVirt], edx
; 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 all transfers are aborted
; either due to call to usb_abort_pipe or due to pipe closing.
; It notifies all callbacks and frees all transfer descriptors.
; ebx -> usb_pipe, esi -> usb_controller, edi -> usb_hardware_func
; three stack parameters: status code for callback functions
; and descriptors where to start and stop.
proc usb_pipe_aborted
virtual at esp
                dd      ?       ; return address
.status         dd      ?       ; USB_STATUS_CLOSED or USB_STATUS_CANCELLED
.first_td       dd      ?
.last_td        dd      ?
end virtual
; Loop over all transfers, calling the driver with the given status
; and freeing all descriptors except the last one.
.loop:
        mov     edx, [.first_td]
        cmp     edx, [.last_td]
        jz      .done
        mov     ecx, [edx+usb_gtd.Callback]
        test    ecx, ecx
        jz      .no_callback
        stdcall_verify ecx, ebx, [.status+12+STDCALL_VERIFY_EXTRA], \
                [edx+usb_gtd.Buffer], 0, [edx+usb_gtd.UserData]
        mov     edx, [.first_td]
.no_callback:
        mov     eax, [edx+usb_gtd.NextVirt]
        mov     [.first_td], eax
        stdcall [edi+usb_hardware_func.FreeTD], edx
        jmp     .loop
.done:
        ret     12
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. Notify all registered callbacks with status USB_STATUS_CLOSED, if any,
; and free all transfer descriptors, including the last one.
        lea     ecx, [ebx+usb_pipe.Lock]
        call    mutex_lock
        mov     edx, [ebx+usb_pipe.LastTD]
        test    edx, edx
        jz      .no_transfer
        mov     eax, [edx+usb_gtd.NextVirt]
        push    edx
        push    eax
        call    mutex_unlock
        push    USB_STATUS_CLOSED
        call    usb_pipe_aborted
; It is safe to free LastTD here:
; usb_*_transfer_async do not enqueue new transfers if USB_FLAG_CLOSED is set.
        stdcall [edi+usb_hardware_func.FreeTD], [ebx+usb_pipe.LastTD]
        jmp     @f
.no_transfer:
        call    mutex_unlock
@@:
; 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
        mov     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. Kill the timer, if active.
; (Usually not; possible if device is disconnected
; while processing SET_ADDRESS request).
        mov     eax, [ebx+usb_pipe.DeviceData]
        cmp     [eax+usb_device_data.Timer], 0
        jz      @f
        stdcall cancel_timer_hs, [eax+usb_device_data.Timer]
        mov     [eax+usb_device_data.Timer], 0
@@:
; 7. 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'
; 8. 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
; 9. Free the usb_device_data structure.
        sub     eax, usb_device_data.ClosedPipeList - usb_pipe.NextSibling
        call    free
; 10. Return.
.nothing:
        pop     edi
        ret
endp
 
; This procedure is called when a pipe with USB_FLAG_DISABLED 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_disabled
        push    edi
        mov     edi, [esi+usb_controller.HardwareFunc]
; 1. Acquire pipe lock.
        lea     ecx, [ebx+usb_pipe.Lock]
        call    mutex_lock
; 2. Clear USB_FLAG_DISABLED in pipe state.
        and     [ebx+usb_pipe.Flags], not USB_FLAG_DISABLED
; 3. Sanity check: ignore uninitialized pipes.
        cmp     [ebx+usb_pipe.LastTD], 0
        jz      .no_transfer
; 4. Acquire the first and last to-be-cancelled transfer descriptor,
; save them in stack for the step 6,
; ask the controller driver to enable the pipe for hardware,
; removing transfers between first and last to-be-cancelled descriptors.
        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
        lea     ecx, [esi+usb_controller.PeriodicLock]
@@:
        call    mutex_lock
        mov     eax, [ebx+usb_pipe.BaseList]
        mov     edx, [eax+usb_pipe.NextVirt]
        mov     [ebx+usb_pipe.NextVirt], edx
        mov     [ebx+usb_pipe.PrevVirt], eax
        mov     [edx+usb_pipe.PrevVirt], ebx
        mov     [eax+usb_pipe.NextVirt], ebx
        mov     eax, [ebx+usb_pipe.LastTD]
        mov     edx, [eax+usb_gtd.NextVirt]
        mov     [eax+usb_gtd.NextVirt], eax
        mov     [eax+usb_gtd.PrevVirt], eax
        push    eax
        push    edx
        push    ecx
        call    [edi+usb_hardware_func.EnablePipe]
        pop     ecx
        call    mutex_unlock
; 5. Release pipe lock acquired at step 1.
; Callbacks called at step 6 can insert new transfers,
; so we cannot call usb_pipe_aborted while holding pipe lock.
        lea     ecx, [ebx+usb_pipe.Lock]
        call    mutex_unlock
; 6. Notify all registered callbacks with status USB_STATUS_CANCELLED, if any.
; Two arguments describing transfers range were pushed at step 4.
        push    USB_STATUS_CANCELLED
        call    usb_pipe_aborted
        pop     edi
        ret
.no_transfer:
        call    mutex_unlock
        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 USBAbortPipe.
proc usb_abort_pipe
        push    ebx esi ; save used registers to be stdcall
virtual at esp
                rd      2 ; saved registers
                dd      ? ; return address
.pipe           dd      ?
end virtual
        mov     ebx, [.pipe]
; 1. Acquire pipe lock.
        lea     ecx, [ebx+usb_pipe.Lock]
        call    mutex_lock
; 2. If the pipe is already closed or abort is in progress,
; just release pipe lock and return.
        test    [ebx+usb_pipe.Flags], USB_FLAG_CLOSED + USB_FLAG_DISABLED
        jnz     .nothing
; 3. Mark the pipe as aborting.
        or      [ebx+usb_pipe.Flags], USB_FLAG_DISABLED
; 4. We cannot do anything except adding new transfers concurrently with hardware.
; Ask the controller driver to (temporarily) remove the pipe from hardware queue.
        mov     esi, [ebx+usb_pipe.Controller]
; 4a. Acquire queue lock.
        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
        lea     ecx, [esi+usb_controller.PeriodicLock]
@@:
        call    mutex_lock
        push    ecx
; 4b. Call the driver.
        mov     eax, [esi+usb_controller.HardwareFunc]
        call    [eax+usb_hardware_func.DisablePipe]
; 4c. Remove the pipe from software list.
        mov     eax, [ebx+usb_pipe.NextVirt]
        mov     edx, [ebx+usb_pipe.PrevVirt]
        mov     [eax+usb_pipe.PrevVirt], edx
        mov     [edx+usb_pipe.NextVirt], eax
; 4c. Register the pipe in corresponding wait list.
        test    [ebx+usb_pipe.Type], 1
        jz      .control_bulk
        call    usb_subscribe_periodic
        jmp     @f
.control_bulk:
        call    usb_subscribe_control
@@:
; 4d. Release queue lock.
        pop     ecx
        call    mutex_unlock
; 4e. Notify the USB thread about new work.
        push    ebx esi edi
        call    usb_wakeup
        pop     edi esi ebx
; That's all for now. To be continued in usb_pipe_disabled.
; 5. Release pipe lock acquired at step 1 and return.
.nothing:
        lea     ecx, [ebx+usb_pipe.Lock]
        call    mutex_unlock
        pop     esi ebx
        ret     4
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
 
; One part of transfer is completed, run the associated callback
; or update total length in the next part of transfer.
; in: ebx -> usb_gtd, ecx = status, edx = length
proc usb_process_gtd
; 1. Test whether it is the last descriptor in the transfer
; <=> it has an associated callback.
        mov     eax, [ebx+usb_gtd.Callback]
        test    eax, eax
        jz      .nocallback
; 2. It has an associated callback; call it with corresponding parameters.
        stdcall_verify eax, [ebx+usb_gtd.Pipe], ecx, \
                [ebx+usb_gtd.Buffer], edx, [ebx+usb_gtd.UserData]
        ret
.nocallback:
; 3. It is an intermediate descriptor. Add its length to the length
; in the following descriptor.
        mov     eax, [ebx+usb_gtd.NextVirt]
        add     [eax+usb_gtd.Length], edx
        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

Rev 4850	Rev 5363
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2013-2014. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2013-2015. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 4850 $	8	$Revision: 5363 $
9		9
10		10
11	; Functions for USB pipe manipulation: opening/closing, sending data etc.	11	; Functions for USB pipe manipulation: opening/closing, sending data etc.
12	;	12	;
13	USB_STDCALL_VERIFY = 1	13	USB_STDCALL_VERIFY = 1
14	macro stdcall_verify [arg]	14	macro stdcall_verify [arg]
15	{	15	{
16	common	16	common
17	if USB_STDCALL_VERIFY	17	if USB_STDCALL_VERIFY
18	pushad	18	pushad
19	stdcall arg	19	stdcall arg
20	call verify_regs	20	call verify_regs
21	popad	21	popad
22	else	22	else
23	stdcall arg	23	stdcall arg
24	end if	24	end if
25	}	25	}
26	if USB_STDCALL_VERIFY	26	if USB_STDCALL_VERIFY
27	STDCALL_VERIFY_EXTRA = 20h	27	STDCALL_VERIFY_EXTRA = 20h
28	else	28	else
29	STDCALL_VERIFY_EXTRA = 0	29	STDCALL_VERIFY_EXTRA = 0
30	end if	30	end if
31		31
32	; Initialization of usb_static_ep structure,	32	; Initialization of usb_static_ep structure,
33	; called from controller-specific initialization; edi -> usb_static_ep	33	; called from controller-specific initialization; edi -> usb_static_ep
34	proc usb_init_static_endpoint	34	proc usb_init_static_endpoint
35	mov [edi+usb_static_ep.NextVirt], edi	35	mov [edi+usb_static_ep.NextVirt], edi
36	mov [edi+usb_static_ep.PrevVirt], edi	36	mov [edi+usb_static_ep.PrevVirt], edi
37	ret	37	ret
38	endp	38	endp
39		39
40	; Part of API for drivers, see documentation for USBOpenPipe.	40	; Part of API for drivers, see documentation for USBOpenPipe.
41	proc usb_open_pipe stdcall uses ebx esi edi,\	41	proc usb_open_pipe stdcall uses ebx esi edi,\
42	config_pipe:dword, endpoint:dword, maxpacket:dword, type:dword, interval:dword	42	config_pipe:dword, endpoint:dword, maxpacket:dword, type:dword, interval:dword
43	locals	43	locals
44	tt_vars rd 24 ; should be enough for ehci_select_tt_interrupt_list	44	tt_vars rd 24 ; should be enough for ehci_select_tt_interrupt_list
45	targetsmask dd ? ; S-Mask for USB2	45	targetsmask dd ? ; S-Mask for USB2
46	bandwidth dd ?	46	bandwidth dd ?
47	target dd ?	47	target dd ?
48	endl	48	endl
49	; 1. Verify type of pipe: it must be one of *_PIPE constants.	49	; 1. Verify type of pipe: it must be one of *_PIPE constants.
50	; Isochronous pipes are not supported yet.	50	; Isochronous pipes are not supported yet.
51	mov eax, [type]	51	mov eax, [type]
52	cmp eax, INTERRUPT_PIPE	52	cmp eax, INTERRUPT_PIPE
53	ja .badtype	53	ja .badtype
54	cmp al, ISOCHRONOUS_PIPE	54	cmp al, ISOCHRONOUS_PIPE
55	jnz .goodtype	55	jnz .goodtype
56	.badtype:	56	.badtype:
57	dbgstr 'unsupported type of USB pipe'	57	dbgstr 'unsupported type of USB pipe'
58	jmp .return0	58	jmp .return0
59	.goodtype:	59	.goodtype:
60	; 2. Allocate memory for pipe and transfer queue.	60	; 2. Allocate memory for pipe and transfer queue.
61	; Empty transfer queue consists of one inactive TD.	61	; Empty transfer queue consists of one inactive TD.
62	mov ebx, [config_pipe]	62	mov ebx, [config_pipe]
63	mov esi, [ebx+usb_pipe.Controller]	63	mov esi, [ebx+usb_pipe.Controller]
64	mov edx, [esi+usb_controller.HardwareFunc]	64	mov edx, [esi+usb_controller.HardwareFunc]
65	call [edx+usb_hardware_func.AllocPipe]	65	call [edx+usb_hardware_func.AllocPipe]
66	test eax, eax	66	test eax, eax
67	jz .nothing	67	jz .nothing
68	mov edi, eax	68	mov edi, eax
69	mov edx, [esi+usb_controller.HardwareFunc]	69	mov edx, [esi+usb_controller.HardwareFunc]
70	call [edx+usb_hardware_func.AllocTD]	70	call [edx+usb_hardware_func.AllocTD]
71	test eax, eax	71	test eax, eax
72	jz .free_and_return0	72	jz .free_and_return0
73	; 3. Initialize transfer queue: pointer to transfer descriptor,	73	; 3. Initialize transfer queue: pointer to transfer descriptor,
74	; pointers in transfer descriptor, queue lock.	74	; pointers in transfer descriptor, queue lock.
75	mov [edi+usb_pipe.LastTD], eax	75	mov [edi+usb_pipe.LastTD], eax
76	mov [eax+usb_gtd.NextVirt], eax	76	mov [eax+usb_gtd.NextVirt], eax
77	mov [eax+usb_gtd.PrevVirt], eax	77	mov [eax+usb_gtd.PrevVirt], eax
78	mov [eax+usb_gtd.Pipe], edi	78	mov [eax+usb_gtd.Pipe], edi
79	lea ecx, [edi+usb_pipe.Lock]	79	lea ecx, [edi+usb_pipe.Lock]
80	call mutex_init	80	call mutex_init
81	; 4. Initialize software part of pipe structure, except device-related fields.	81	; 4. Initialize software part of pipe structure, except device-related fields.
82	mov al, byte [type]	82	mov al, byte [type]
83	mov [edi+usb_pipe.Type], al	83	mov [edi+usb_pipe.Type], al
84	xor eax, eax	84	xor eax, eax
85	mov [edi+usb_pipe.Flags], al	85	mov [edi+usb_pipe.Flags], al
86	mov [edi+usb_pipe.DeviceData], eax	86	mov [edi+usb_pipe.DeviceData], eax
87	mov [edi+usb_pipe.Controller], esi	87	mov [edi+usb_pipe.Controller], esi
88	or [edi+usb_pipe.NextWait], -1	88	or [edi+usb_pipe.NextWait], -1
89	; 5. Initialize device-related fields:	89	; 5. Initialize device-related fields:
90	; for zero endpoint, set .NextSibling = .PrevSibling = this;	90	; for zero endpoint, set .NextSibling = .PrevSibling = this;
91	; for other endpoins, copy device data, take the lock guarding pipe list	91	; for other endpoins, copy device data, take the lock guarding pipe list
92	; for the device and verify that disconnect processing has not yet started	92	; for the device and verify that disconnect processing has not yet started
93	; for the device. (Since disconnect processing also takes that lock,	93	; for the device. (Since disconnect processing also takes that lock,
94	; either it has completed or it will not start until we release the lock.)	94	; either it has completed or it will not start until we release the lock.)
95	; Note: usb_device_disconnected should not see the new pipe until	95	; Note: usb_device_disconnected should not see the new pipe until
96	; initialization is complete, so that lock will be held during next steps	96	; initialization is complete, so that lock will be held during next steps
97	; (disconnect processing should either not see it at all, or see fully	97	; (disconnect processing should either not see it at all, or see fully
98	; initialized pipe).	98	; initialized pipe).
99	cmp [endpoint], eax	99	cmp [endpoint], eax
100	jz .zero_endpoint	100	jz .zero_endpoint
101	mov ecx, [ebx+usb_pipe.DeviceData]	101	mov ecx, [ebx+usb_pipe.DeviceData]
102	mov [edi+usb_pipe.DeviceData], ecx	102	mov [edi+usb_pipe.DeviceData], ecx
103	call mutex_lock	103	call mutex_lock
104	test [ebx+usb_pipe.Flags], USB_FLAG_CLOSED	104	test [ebx+usb_pipe.Flags], USB_FLAG_CLOSED
105	jz .common	105	jz .common
106	.fail:	106	.fail:
107	; If disconnect processing has completed, unlock the mutex, free memory	107	; If disconnect processing has completed, unlock the mutex, free memory
108	; allocated in step 2 and return zero.	108	; allocated in step 2 and return zero.
109	call mutex_unlock	109	call mutex_unlock
110	mov edx, [esi+usb_controller.HardwareFunc]	110	mov edx, [esi+usb_controller.HardwareFunc]
111	stdcall [edx+usb_hardware_func.FreeTD], [edi+usb_pipe.LastTD]	111	stdcall [edx+usb_hardware_func.FreeTD], [edi+usb_pipe.LastTD]
112	.free_and_return0:	112	.free_and_return0:
113	mov edx, [esi+usb_controller.HardwareFunc]	113	mov edx, [esi+usb_controller.HardwareFunc]
114	stdcall [edx+usb_hardware_func.FreePipe], edi	114	stdcall [edx+usb_hardware_func.FreePipe], edi
115	.return0:	115	.return0:
116	xor eax, eax	116	xor eax, eax
117	jmp .nothing	117	jmp .nothing
118	.zero_endpoint:	118	.zero_endpoint:
119	mov [edi+usb_pipe.NextSibling], edi	119	mov [edi+usb_pipe.NextSibling], edi
120	mov [edi+usb_pipe.PrevSibling], edi	120	mov [edi+usb_pipe.PrevSibling], edi
121	.common:	121	.common:
122	; 6. Initialize hardware part of pipe structure.	122	; 6. Initialize hardware part of pipe structure.
123	; 6a. Acquire the corresponding mutex.	123	; 6a. Acquire the corresponding mutex.
124	lea ecx, [esi+usb_controller.ControlLock]	124	lea ecx, [esi+usb_controller.ControlLock]
125	cmp [type], BULK_PIPE	125	cmp [type], BULK_PIPE
126	jb @f ; control pipe	126	jb @f ; control pipe
127	lea ecx, [esi+usb_controller.BulkLock]	127	lea ecx, [esi+usb_controller.BulkLock]
128	jz @f ; bulk pipe	128	jz @f ; bulk pipe
129	lea ecx, [esi+usb_controller.PeriodicLock]	129	lea ecx, [esi+usb_controller.PeriodicLock]
130	@@:	130	@@:
131	call mutex_lock	131	call mutex_lock
132	; 6b. Let the controller-specific code do its job.	132	; 6b. Let the controller-specific code do its job.
133	push ecx	133	push ecx
134	mov edx, [esi+usb_controller.HardwareFunc]	134	mov edx, [esi+usb_controller.HardwareFunc]
135	mov eax, [edi+usb_pipe.LastTD]	135	mov eax, [edi+usb_pipe.LastTD]
136	mov ecx, [config_pipe]	136	mov ecx, [config_pipe]
137	call [edx+usb_hardware_func.InitPipe]	137	call [edx+usb_hardware_func.InitPipe]
138	pop ecx	138	pop ecx
139	; 6c. Release the mutex.	139	; 6c. Release the mutex.
140	push eax	140	push eax
141	call mutex_unlock	141	call mutex_unlock
142	pop eax	142	pop eax
143	; 6d. If controller-specific code indicates failure,	143	; 6d. If controller-specific code indicates failure,
144	; release the lock taken in step 5, free memory allocated in step 2	144	; release the lock taken in step 5, free memory allocated in step 2
145	; and return zero.	145	; and return zero.
146	test eax, eax	146	test eax, eax
147	jz .fail	147	jz .fail
148	; 7. The pipe is initialized. If this is not the first pipe for the device,	148	; 7. The pipe is initialized. If this is not the first pipe for the device,
149	; insert it to the tail of pipe list for the device,	149	; insert it to the tail of pipe list for the device,
150	; increment number of pipes,	150	; increment number of pipes,
151	; release the lock taken at step 5.	151	; release the lock taken at step 5.
152	mov ecx, [edi+usb_pipe.DeviceData]	152	mov ecx, [edi+usb_pipe.DeviceData]
153	test ecx, ecx	153	test ecx, ecx
154	jz @f	154	jz @f
155	mov eax, [ebx+usb_pipe.PrevSibling]	155	mov eax, [ebx+usb_pipe.PrevSibling]
156	mov [edi+usb_pipe.NextSibling], ebx	156	mov [edi+usb_pipe.NextSibling], ebx
157	mov [edi+usb_pipe.PrevSibling], eax	157	mov [edi+usb_pipe.PrevSibling], eax
158	mov [ebx+usb_pipe.PrevSibling], edi	158	mov [ebx+usb_pipe.PrevSibling], edi
159	mov [eax+usb_pipe.NextSibling], edi	159	mov [eax+usb_pipe.NextSibling], edi
160	inc [ecx+usb_device_data.NumPipes]	160	inc [ecx+usb_device_data.NumPipes]
161	call mutex_unlock	161	call mutex_unlock
162	@@:	162	@@:
163	; 8. Return pointer to usb_pipe.	163	; 8. Return pointer to usb_pipe.
164	mov eax, edi	164	mov eax, edi
165	.nothing:	165	.nothing:
166	ret	166	ret
167	endp	167	endp
168		168
169	; This procedure is called several times during initial device configuration,	169	; This procedure is called several times during initial device configuration,
170	; when usb_device_data structure is reallocated.	170	; when usb_device_data structure is reallocated.
171	; It (re)initializes all pointers in usb_device_data.	171	; It (re)initializes all pointers in usb_device_data.
172	; ebx -> usb_pipe	172	; ebx -> usb_pipe
173	proc usb_reinit_pipe_list	173	proc usb_reinit_pipe_list
174	push eax	174	push eax
175	; 1. (Re)initialize the lock guarding pipe list.	175	; 1. (Re)initialize the lock guarding pipe list.
176	mov ecx, [ebx+usb_pipe.DeviceData]	176	mov ecx, [ebx+usb_pipe.DeviceData]
177	call mutex_init	177	call mutex_init
178	; 2. Initialize list of opened pipes: two entries, the head and ebx.	178	; 2. Initialize list of opened pipes: two entries, the head and ebx.
179	add ecx, usb_device_data.OpenedPipeList - usb_pipe.NextSibling	179	add ecx, usb_device_data.OpenedPipeList - usb_pipe.NextSibling
180	mov [ecx+usb_pipe.NextSibling], ebx	180	mov [ecx+usb_pipe.NextSibling], ebx
181	mov [ecx+usb_pipe.PrevSibling], ebx	181	mov [ecx+usb_pipe.PrevSibling], ebx
182	mov [ebx+usb_pipe.NextSibling], ecx	182	mov [ebx+usb_pipe.NextSibling], ecx
183	mov [ebx+usb_pipe.PrevSibling], ecx	183	mov [ebx+usb_pipe.PrevSibling], ecx
184	; 3. Initialize list of closed pipes: empty list, only the head is present.	184	; 3. Initialize list of closed pipes: empty list, only the head is present.
185	add ecx, usb_device_data.ClosedPipeList - usb_device_data.OpenedPipeList	185	add ecx, usb_device_data.ClosedPipeList - usb_device_data.OpenedPipeList
186	mov [ecx+usb_pipe.NextSibling], ecx	186	mov [ecx+usb_pipe.NextSibling], ecx
187	mov [ecx+usb_pipe.PrevSibling], ecx	187	mov [ecx+usb_pipe.PrevSibling], ecx
188	pop eax	188	pop eax
189	ret	189	ret
190	endp	190	endp
191		191
192	; Part of API for drivers, see documentation for USBClosePipe.	192	; Part of API for drivers, see documentation for USBClosePipe.
193	proc usb_close_pipe	193	proc usb_close_pipe
194	push ebx esi ; save used registers to be stdcall	194	push ebx esi ; save used registers to be stdcall
195	virtual at esp	195	virtual at esp
196	rd 2 ; saved registers	196	rd 2 ; saved registers
197	dd ? ; return address	197	dd ? ; return address
198	.pipe dd ?	198	.pipe dd ?
199	end virtual	199	end virtual
200	; 1. Lock the pipe list for the device.	200	; 1. Lock the pipe list for the device.
201	mov ebx, [.pipe]	201	mov ebx, [.pipe]
202	mov esi, [ebx+usb_pipe.Controller]	202	mov esi, [ebx+usb_pipe.Controller]
203	mov ecx, [ebx+usb_pipe.DeviceData]	203	mov ecx, [ebx+usb_pipe.DeviceData]
204	call mutex_lock	204	call mutex_lock
205	; 2. Set the flag "the driver has abandoned this pipe, free it at any time".	205	; 2. Set the flag "the driver has abandoned this pipe, free it at any time".
206	lea ecx, [ebx+usb_pipe.Lock]	206	lea ecx, [ebx+usb_pipe.Lock]
207	call mutex_lock	207	call mutex_lock
208	or [ebx+usb_pipe.Flags], USB_FLAG_CAN_FREE	208	or [ebx+usb_pipe.Flags], USB_FLAG_CAN_FREE
209	call mutex_unlock	209	call mutex_unlock
210	; 3. Call the worker function.	210	; 3. Call the worker function.
211	call usb_close_pipe_nolock	211	call usb_close_pipe_nolock
212	; 4. Unlock the pipe list for the device.	212	; 4. Unlock the pipe list for the device.
213	mov ecx, [ebx+usb_pipe.DeviceData]	213	mov ecx, [ebx+usb_pipe.DeviceData]
214	call mutex_unlock	214	call mutex_unlock
215	; 5. Wakeup the USB thread so that it can proceed with releasing that pipe.	215	; 5. Wakeup the USB thread so that it can proceed with releasing that pipe.
216	push edi	216	push edi
217	call usb_wakeup	217	call usb_wakeup
218	pop edi	218	pop edi
219	; 6. Return.	219	; 6. Return.
220	pop esi ebx ; restore used registers to be stdcall	220	pop esi ebx ; restore used registers to be stdcall
221	retn 4	221	retn 4
222	endp	222	endp
223		223
224	; Worker function for pipe closing. Called by usb_close_pipe API and	224	; Worker function for pipe closing. Called by usb_close_pipe API and
225	; from disconnect processing.	225	; from disconnect processing.
226	; The lock guarding pipe list for the device should be held by the caller.	226	; The lock guarding pipe list for the device should be held by the caller.
227	; ebx -> usb_pipe, esi -> usb_controller	227	; ebx -> usb_pipe, esi -> usb_controller
228	proc usb_close_pipe_nolock	228	proc usb_close_pipe_nolock
229	; 1. Set the flag "pipe is closed, ignore new transfers".	229	; 1. Set the flag "pipe is closed, ignore new transfers".
230	; If it was already set, do nothing.	230	; If it was already set, do nothing.
231	lea ecx, [ebx+usb_pipe.Lock]	231	lea ecx, [ebx+usb_pipe.Lock]
232	call mutex_lock	232	call mutex_lock
233	bts dword [ebx+usb_pipe.Flags], USB_FLAG_CLOSED_BIT	233	bts dword [ebx+usb_pipe.Flags], USB_FLAG_CLOSED_BIT
234	jc .closed	234	jc .closed
235	call mutex_unlock	235	call mutex_unlock
236	; 2. Remove the pipe from the list of opened pipes.	236	; 2. Remove the pipe from the list of opened pipes.
237	mov eax, [ebx+usb_pipe.NextSibling]	237	mov eax, [ebx+usb_pipe.NextSibling]
238	mov edx, [ebx+usb_pipe.PrevSibling]	238	mov edx, [ebx+usb_pipe.PrevSibling]
239	mov [eax+usb_pipe.PrevSibling], edx	239	mov [eax+usb_pipe.PrevSibling], edx
240	mov [edx+usb_pipe.NextSibling], eax	240	mov [edx+usb_pipe.NextSibling], eax
241	; 3. Unlink the pipe from hardware structures.	241	; 3. Unlink the pipe from hardware structures.
242	; 3a. Acquire the corresponding lock.	242	; 3a. Acquire the corresponding lock.
243	lea edx, [esi+usb_controller.WaitPipeListAsync]	243	lea edx, [esi+usb_controller.WaitPipeListAsync]
244	lea ecx, [esi+usb_controller.ControlLock]	244	lea ecx, [esi+usb_controller.ControlLock]
245	cmp [ebx+usb_pipe.Type], BULK_PIPE	245	cmp [ebx+usb_pipe.Type], BULK_PIPE
246	jb @f ; control pipe	246	jb @f ; control pipe
247	lea ecx, [esi+usb_controller.BulkLock]	247	lea ecx, [esi+usb_controller.BulkLock]
248	jz @f ; bulk pipe	248	jz @f ; bulk pipe
249	add edx, usb_controller.WaitPipeListPeriodic - usb_controller.WaitPipeListAsync	249	add edx, usb_controller.WaitPipeListPeriodic - usb_controller.WaitPipeListAsync
250	lea ecx, [esi+usb_controller.PeriodicLock]	250	lea ecx, [esi+usb_controller.PeriodicLock]
251	@@:	251	@@:
252	push edx	252	push edx
253	call mutex_lock	253	call mutex_lock
254	push ecx	254	push ecx
255	; 3b. Let the controller-specific code do its job.	255	; 3b. Let the controller-specific code do its job.
256	test [ebx+usb_pipe.Flags], USB_FLAG_DISABLED	256	test [ebx+usb_pipe.Flags], USB_FLAG_DISABLED
257	jnz @f	257	jnz @f
258	mov eax, [esi+usb_controller.HardwareFunc]	258	mov eax, [esi+usb_controller.HardwareFunc]
259	call [eax+usb_hardware_func.DisablePipe]	259	call [eax+usb_hardware_func.DisablePipe]
260	@@:	260	@@:
261	mov eax, [esi+usb_controller.HardwareFunc]	261	mov eax, [esi+usb_controller.HardwareFunc]
262	call [eax+usb_hardware_func.UnlinkPipe]	262	call [eax+usb_hardware_func.UnlinkPipe]
263	mov edx, [ebx+usb_pipe.NextVirt]	263	mov edx, [ebx+usb_pipe.NextVirt]
264	mov eax, [ebx+usb_pipe.PrevVirt]	264	mov eax, [ebx+usb_pipe.PrevVirt]
265	mov [edx+usb_pipe.PrevVirt], eax	265	mov [edx+usb_pipe.PrevVirt], eax
266	mov [eax+usb_pipe.NextVirt], edx	266	mov [eax+usb_pipe.NextVirt], edx
267	; 3c. Release the corresponding lock.	267	; 3c. Release the corresponding lock.
268	pop ecx	268	pop ecx
269	call mutex_unlock	269	call mutex_unlock
270	; 4. Put the pipe into wait queue.	270	; 4. Put the pipe into wait queue.
271	pop edx	271	pop edx
272	cmp [ebx+usb_pipe.NextWait], -1	272	cmp [ebx+usb_pipe.NextWait], -1
273	jz .insert_new	273	jz .insert_new
274	or [ebx+usb_pipe.Flags], USB_FLAG_EXTRA_WAIT	274	or [ebx+usb_pipe.Flags], USB_FLAG_EXTRA_WAIT
275	jmp .inserted	275	jmp .inserted
276	.insert_new:	276	.insert_new:
277	mov eax, [edx]	277	mov eax, [edx]
278	mov [ebx+usb_pipe.NextWait], eax	278	mov [ebx+usb_pipe.NextWait], eax
279	mov [edx], ebx	279	mov [edx], ebx
280	.inserted:	280	.inserted:
281	; 5. Return.	281	; 5. Return.
282	ret	282	ret
283	.closed:	283	.closed:
284	call mutex_unlock	284	call mutex_unlock
285	xor eax, eax	285	xor eax, eax
286	ret	286	ret
287	endp	287	endp
288		288
289	; This procedure is called when all transfers are aborted	289	; This procedure is called when all transfers are aborted
290	; either due to call to usb_abort_pipe or due to pipe closing.	290	; either due to call to usb_abort_pipe or due to pipe closing.
291	; It notifies all callbacks and frees all transfer descriptors.	291	; It notifies all callbacks and frees all transfer descriptors.
292	; ebx -> usb_pipe, esi -> usb_controller, edi -> usb_hardware_func	292	; ebx -> usb_pipe, esi -> usb_controller, edi -> usb_hardware_func
293	; three stack parameters: status code for callback functions	293	; three stack parameters: status code for callback functions
294	; and descriptors where to start and stop.	294	; and descriptors where to start and stop.
295	proc usb_pipe_aborted	295	proc usb_pipe_aborted
296	virtual at esp	296	virtual at esp
297	dd ? ; return address	297	dd ? ; return address
298	.status dd ? ; USB_STATUS_CLOSED or USB_STATUS_CANCELLED	298	.status dd ? ; USB_STATUS_CLOSED or USB_STATUS_CANCELLED
299	.first_td dd ?	299	.first_td dd ?
300	.last_td dd ?	300	.last_td dd ?
301	end virtual	301	end virtual
302	; Loop over all transfers, calling the driver with the given status	302	; Loop over all transfers, calling the driver with the given status
303	; and freeing all descriptors except the last one.	303	; and freeing all descriptors except the last one.
304	.loop:	304	.loop:
305	mov edx, [.first_td]	305	mov edx, [.first_td]
306	cmp edx, [.last_td]	306	cmp edx, [.last_td]
307	jz .done	307	jz .done
308	mov ecx, [edx+usb_gtd.Callback]	308	mov ecx, [edx+usb_gtd.Callback]
309	test ecx, ecx	309	test ecx, ecx
310	jz .no_callback	310	jz .no_callback
311	stdcall_verify ecx, ebx, [.status+12+STDCALL_VERIFY_EXTRA], \	311	stdcall_verify ecx, ebx, [.status+12+STDCALL_VERIFY_EXTRA], \
312	[edx+usb_gtd.Buffer], 0, [edx+usb_gtd.UserData]	312	[edx+usb_gtd.Buffer], 0, [edx+usb_gtd.UserData]
313	mov edx, [.first_td]	313	mov edx, [.first_td]
314	.no_callback:	314	.no_callback:
315	mov eax, [edx+usb_gtd.NextVirt]	315	mov eax, [edx+usb_gtd.NextVirt]
316	mov [.first_td], eax	316	mov [.first_td], eax
317	stdcall [edi+usb_hardware_func.FreeTD], edx	317	stdcall [edi+usb_hardware_func.FreeTD], edx
318	jmp .loop	318	jmp .loop
319	.done:	319	.done:
320	ret 12	320	ret 12
321	endp	321	endp
322		322
323	; This procedure is called when a pipe with USB_FLAG_CLOSED is removed from the	323	; This procedure is called when a pipe with USB_FLAG_CLOSED is removed from the
324	; corresponding wait list. It means that the hardware has fully forgot about it.	324	; corresponding wait list. It means that the hardware has fully forgot about it.
325	; ebx -> usb_pipe, esi -> usb_controller	325	; ebx -> usb_pipe, esi -> usb_controller
326	proc usb_pipe_closed	326	proc usb_pipe_closed
327	push edi	327	push edi
328	mov edi, [esi+usb_controller.HardwareFunc]	328	mov edi, [esi+usb_controller.HardwareFunc]
329	; 1. Notify all registered callbacks with status USB_STATUS_CLOSED, if any,	329	; 1. Notify all registered callbacks with status USB_STATUS_CLOSED, if any,
330	; and free all transfer descriptors, including the last one.	330	; and free all transfer descriptors, including the last one.
331	lea ecx, [ebx+usb_pipe.Lock]	331	lea ecx, [ebx+usb_pipe.Lock]
332	call mutex_lock	332	call mutex_lock
333	mov edx, [ebx+usb_pipe.LastTD]	333	mov edx, [ebx+usb_pipe.LastTD]
334	test edx, edx	334	test edx, edx
335	jz .no_transfer	335	jz .no_transfer
336	mov eax, [edx+usb_gtd.NextVirt]	336	mov eax, [edx+usb_gtd.NextVirt]
337	push edx	337	push edx
338	push eax	338	push eax
339	call mutex_unlock	339	call mutex_unlock
340	push USB_STATUS_CLOSED	340	push USB_STATUS_CLOSED
341	call usb_pipe_aborted	341	call usb_pipe_aborted
342	; It is safe to free LastTD here:	342	; It is safe to free LastTD here:
343	; usb_*_transfer_async do not enqueue new transfers if USB_FLAG_CLOSED is set.	343	; usb_*_transfer_async do not enqueue new transfers if USB_FLAG_CLOSED is set.
344	stdcall [edi+usb_hardware_func.FreeTD], [ebx+usb_pipe.LastTD]	344	stdcall [edi+usb_hardware_func.FreeTD], [ebx+usb_pipe.LastTD]
345	jmp @f	345	jmp @f
346	.no_transfer:	346	.no_transfer:
347	call mutex_unlock	347	call mutex_unlock
348	@@:	348	@@:
349	; 2. Decrement number of pipes for the device.	349	; 2. Decrement number of pipes for the device.
350	; If this pipe is the last pipe, go to 5.	350	; If this pipe is the last pipe, go to 5.
351	mov ecx, [ebx+usb_pipe.DeviceData]	351	mov ecx, [ebx+usb_pipe.DeviceData]
352	call mutex_lock	352	call mutex_lock
353	dec [ecx+usb_device_data.NumPipes]	353	dec [ecx+usb_device_data.NumPipes]
354	jz .last_pipe	354	jz .last_pipe
355	call mutex_unlock	355	call mutex_unlock
356	; 3. If the flag "the driver has abandoned this pipe" is set,	356	; 3. If the flag "the driver has abandoned this pipe" is set,
357	; free memory and return.	357	; free memory and return.
358	test [ebx+usb_pipe.Flags], USB_FLAG_CAN_FREE	358	test [ebx+usb_pipe.Flags], USB_FLAG_CAN_FREE
359	jz .nofree	359	jz .nofree
360	stdcall [edi+usb_hardware_func.FreePipe], ebx	360	stdcall [edi+usb_hardware_func.FreePipe], ebx
361	pop edi	361	pop edi
362	ret	362	ret
363	; 4. Otherwise, add it to the list of closed pipes and return.	363	; 4. Otherwise, add it to the list of closed pipes and return.
364	.nofree:	364	.nofree:
365	add ecx, usb_device_data.ClosedPipeList - usb_pipe.NextSibling	365	add ecx, usb_device_data.ClosedPipeList - usb_pipe.NextSibling
366	mov edx, [ecx+usb_pipe.PrevSibling]	366	mov edx, [ecx+usb_pipe.PrevSibling]
367	mov [ebx+usb_pipe.NextSibling], ecx	367	mov [ebx+usb_pipe.NextSibling], ecx
368	mov [ebx+usb_pipe.PrevSibling], edx	368	mov [ebx+usb_pipe.PrevSibling], edx
369	mov [ecx+usb_pipe.PrevSibling], ebx	369	mov [ecx+usb_pipe.PrevSibling], ebx
370	mov [edx+usb_pipe.NextSibling], ebx	370	mov [edx+usb_pipe.NextSibling], ebx
371	pop edi	371	pop edi
372	ret	372	ret
373	.last_pipe:	373	.last_pipe:
374	; That was the last pipe for the device.	374	; That was the last pipe for the device.
375	; 5. Notify device driver(s) about disconnect.	375	; 5. Notify device driver(s) about disconnect.
376	call mutex_unlock	376	call mutex_unlock
377	mov eax, [ecx+usb_device_data.NumInterfaces]	377	mov eax, [ecx+usb_device_data.NumInterfaces]
378	test eax, eax	378	test eax, eax
379	jz .notify_done	379	jz .notify_done
380	add ecx, [ecx+usb_device_data.Interfaces]	380	add ecx, [ecx+usb_device_data.Interfaces]
381	.notify_loop:	381	.notify_loop:
382	mov edx, [ecx+usb_interface_data.DriverFunc]	382	mov edx, [ecx+usb_interface_data.DriverFunc]
383	test edx, edx	383	test edx, edx
384	jz @f	384	jz @f
385	mov edx, [edx+USBSRV.usb_func]	385	mov edx, [edx+USBSRV.usb_func]
386	cmp [edx+USBFUNC.strucsize], USBFUNC.device_disconnect + 4	386	cmp [edx+USBFUNC.strucsize], USBFUNC.device_disconnect + 4
387	jb @f	387	jb @f
388	mov edx, [edx+USBFUNC.device_disconnect]	388	mov edx, [edx+USBFUNC.device_disconnect]
389	test edx, edx	389	test edx, edx
390	jz @f	390	jz @f
391	push eax ecx	391	push eax ecx
392	stdcall_verify edx, [ecx+usb_interface_data.DriverData]	392	stdcall_verify edx, [ecx+usb_interface_data.DriverData]
393	pop ecx eax	393	pop ecx eax
394	@@:	394	@@:
395	add ecx, sizeof.usb_interface_data	395	add ecx, sizeof.usb_interface_data
396	dec eax	396	dec eax
397	jnz .notify_loop	397	jnz .notify_loop
398	.notify_done:	398	.notify_done:
399	; 6. Kill the timer, if active.	399	; 6. Kill the timer, if active.
400	; (Usually not; possible if device is disconnected	400	; (Usually not; possible if device is disconnected
401	; while processing SET_ADDRESS request).	401	; while processing SET_ADDRESS request).
402	mov eax, [ebx+usb_pipe.DeviceData]	402	mov eax, [ebx+usb_pipe.DeviceData]
403	cmp [eax+usb_device_data.Timer], 0	403	cmp [eax+usb_device_data.Timer], 0
404	jz @f	404	jz @f
405	stdcall cancel_timer_hs, [eax+usb_device_data.Timer]	405	stdcall cancel_timer_hs, [eax+usb_device_data.Timer]
406	mov [eax+usb_device_data.Timer], 0	406	mov [eax+usb_device_data.Timer], 0
407	@@:	407	@@:
408	; 7. Bus address, if assigned, can now be reused.	408	; 7. Bus address, if assigned, can now be reused.
409	call [edi+usb_hardware_func.GetDeviceAddress]	409	call [edi+usb_hardware_func.GetDeviceAddress]
410	test eax, eax	410	test eax, eax
411	jz @f	411	jz @f
412	bts [esi+usb_controller.ExistingAddresses], eax	412	bts [esi+usb_controller.ExistingAddresses], eax
413	@@:	413	@@:
414	dbgstr 'USB device disconnected'	414	dbgstr 'USB device disconnected'
415	; 8. All drivers have returned from disconnect callback,	415	; 8. All drivers have returned from disconnect callback,
416	; so all drivers should not use any device-related pipes.	416	; so all drivers should not use any device-related pipes.
417	; Free the remaining pipes.	417	; Free the remaining pipes.
418	mov eax, [ebx+usb_pipe.DeviceData]	418	mov eax, [ebx+usb_pipe.DeviceData]
419	add eax, usb_device_data.ClosedPipeList - usb_pipe.NextSibling	419	add eax, usb_device_data.ClosedPipeList - usb_pipe.NextSibling
420	push eax	420	push eax
421	mov eax, [eax+usb_pipe.NextSibling]	421	mov eax, [eax+usb_pipe.NextSibling]
422	.free_loop:	422	.free_loop:
423	cmp eax, [esp]	423	cmp eax, [esp]
424	jz .free_done	424	jz .free_done
425	push [eax+usb_pipe.NextSibling]	425	push [eax+usb_pipe.NextSibling]
426	stdcall [edi+usb_hardware_func.FreePipe], eax	426	stdcall [edi+usb_hardware_func.FreePipe], eax
427	pop eax	427	pop eax
428	jmp .free_loop	428	jmp .free_loop
429	.free_done:	429	.free_done:
430	stdcall [edi+usb_hardware_func.FreePipe], ebx	430	stdcall [edi+usb_hardware_func.FreePipe], ebx
431	pop eax	431	pop eax
432	; 9. Free the usb_device_data structure.	432	; 9. Free the usb_device_data structure.
433	sub eax, usb_device_data.ClosedPipeList - usb_pipe.NextSibling	433	sub eax, usb_device_data.ClosedPipeList - usb_pipe.NextSibling
434	call free	434	call free
435	; 10. Return.	435	; 10. Return.
436	.nothing:	436	.nothing:
437	pop edi	437	pop edi
438	ret	438	ret
439	endp	439	endp
440		440
441	; This procedure is called when a pipe with USB_FLAG_DISABLED is removed from the	441	; This procedure is called when a pipe with USB_FLAG_DISABLED is removed from the
442	; corresponding wait list. It means that the hardware has fully forgot about it.	442	; corresponding wait list. It means that the hardware has fully forgot about it.
443	; ebx -> usb_pipe, esi -> usb_controller	443	; ebx -> usb_pipe, esi -> usb_controller
444	proc usb_pipe_disabled	444	proc usb_pipe_disabled
445	push edi	445	push edi
446	mov edi, [esi+usb_controller.HardwareFunc]	446	mov edi, [esi+usb_controller.HardwareFunc]
447	; 1. Acquire pipe lock.	447	; 1. Acquire pipe lock.
448	lea ecx, [ebx+usb_pipe.Lock]	448	lea ecx, [ebx+usb_pipe.Lock]
449	call mutex_lock	449	call mutex_lock
450	; 2. Clear USB_FLAG_DISABLED in pipe state.	450	; 2. Clear USB_FLAG_DISABLED in pipe state.
451	and [ebx+usb_pipe.Flags], not USB_FLAG_DISABLED	451	and [ebx+usb_pipe.Flags], not USB_FLAG_DISABLED
452	; 3. Sanity check: ignore uninitialized pipes.	452	; 3. Sanity check: ignore uninitialized pipes.
453	cmp [ebx+usb_pipe.LastTD], 0	453	cmp [ebx+usb_pipe.LastTD], 0
454	jz .no_transfer	454	jz .no_transfer
455	; 4. Acquire the first and last to-be-cancelled transfer descriptor,	455	; 4. Acquire the first and last to-be-cancelled transfer descriptor,
456	; save them in stack for the step 6,	456	; save them in stack for the step 6,
457	; ask the controller driver to enable the pipe for hardware,	457	; ask the controller driver to enable the pipe for hardware,
458	; removing transfers between first and last to-be-cancelled descriptors.	458	; removing transfers between first and last to-be-cancelled descriptors.
459	lea ecx, [esi+usb_controller.ControlLock]	459	lea ecx, [esi+usb_controller.ControlLock]
460	cmp [ebx+usb_pipe.Type], BULK_PIPE	460	cmp [ebx+usb_pipe.Type], BULK_PIPE
461	jb @f ; control pipe	461	jb @f ; control pipe
462	lea ecx, [esi+usb_controller.BulkLock]	462	lea ecx, [esi+usb_controller.BulkLock]
463	jz @f ; bulk pipe	463	jz @f ; bulk pipe
464	lea ecx, [esi+usb_controller.PeriodicLock]	464	lea ecx, [esi+usb_controller.PeriodicLock]
465	@@:	465	@@:
466	call mutex_lock	466	call mutex_lock
467	mov eax, [ebx+usb_pipe.BaseList]	467	mov eax, [ebx+usb_pipe.BaseList]
468	mov edx, [eax+usb_pipe.NextVirt]	468	mov edx, [eax+usb_pipe.NextVirt]
469	mov [ebx+usb_pipe.NextVirt], edx	469	mov [ebx+usb_pipe.NextVirt], edx
470	mov [ebx+usb_pipe.PrevVirt], eax	470	mov [ebx+usb_pipe.PrevVirt], eax
471	mov [edx+usb_pipe.PrevVirt], ebx	471	mov [edx+usb_pipe.PrevVirt], ebx
472	mov [eax+usb_pipe.NextVirt], ebx	472	mov [eax+usb_pipe.NextVirt], ebx
473	mov eax, [ebx+usb_pipe.LastTD]	473	mov eax, [ebx+usb_pipe.LastTD]
474	mov edx, [eax+usb_gtd.NextVirt]	474	mov edx, [eax+usb_gtd.NextVirt]
475	mov [eax+usb_gtd.NextVirt], eax	475	mov [eax+usb_gtd.NextVirt], eax
476	mov [eax+usb_gtd.PrevVirt], eax	476	mov [eax+usb_gtd.PrevVirt], eax
477	push eax	477	push eax
478	push edx	478	push edx
479	push ecx	479	push ecx
480	call [edi+usb_hardware_func.EnablePipe]	480	call [edi+usb_hardware_func.EnablePipe]
481	pop ecx	481	pop ecx
482	call mutex_unlock	482	call mutex_unlock
483	; 5. Release pipe lock acquired at step 1.	483	; 5. Release pipe lock acquired at step 1.
484	; Callbacks called at step 6 can insert new transfers,	484	; Callbacks called at step 6 can insert new transfers,
485	; so we cannot call usb_pipe_aborted while holding pipe lock.	485	; so we cannot call usb_pipe_aborted while holding pipe lock.
486	lea ecx, [ebx+usb_pipe.Lock]	486	lea ecx, [ebx+usb_pipe.Lock]
487	call mutex_unlock	487	call mutex_unlock
488	; 6. Notify all registered callbacks with status USB_STATUS_CANCELLED, if any.	488	; 6. Notify all registered callbacks with status USB_STATUS_CANCELLED, if any.
489	; Two arguments describing transfers range were pushed at step 4.	489	; Two arguments describing transfers range were pushed at step 4.
490	push USB_STATUS_CANCELLED	490	push USB_STATUS_CANCELLED
491	call usb_pipe_aborted	491	call usb_pipe_aborted
492	pop edi	492	pop edi
493	ret	493	ret
494	.no_transfer:	494	.no_transfer:
495	call mutex_unlock	495	call mutex_unlock
496	pop edi	496	pop edi
497	ret	497	ret
498	endp	498	endp
499		499
500	; Part of API for drivers, see documentation for USBNormalTransferAsync.	500	; Part of API for drivers, see documentation for USBNormalTransferAsync.

Subversion Repositories Kolibri OS

(root)/kernel/trunk/bus/usb/pipe.inc – Rev 4850 → 5363