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


; Support for USB (non-root) hubs:
; powering up/resetting/disabling ports,
; watching for adding/removing devices.
 
; =============================================================================
; ================================= Constants =================================
; =============================================================================
; Hub constants
; USB hub descriptor type
USB_HUB_DESCRIPTOR = 29h
 
; Features for CLEAR_FEATURE commands to the hub.
C_HUB_LOCAL_POWER   = 0
C_HUB_OVER_CURRENT  = 1
 
; Bits in result of GET_STATUS command for a port.
; Also suitable for CLEAR_FEATURE/SET_FEATURE commands, where applicable,
; except TEST/INDICATOR.
PORT_CONNECTION     = 0
PORT_ENABLE         = 1
PORT_SUSPEND        = 2
PORT_OVER_CURRENT   = 3
PORT_RESET          = 4
PORT_POWER          = 8
PORT_LOW_SPEED      = 9
PORT_HIGH_SPEED     = 10
PORT_TEST_BIT       = 11
PORT_INDICATOR_BIT  = 12
C_PORT_CONNECTION   = 16
C_PORT_ENABLE       = 17
C_PORT_SUSPEND      = 18
C_PORT_OVER_CURRENT = 19
C_PORT_RESET        = 20
PORT_TEST_FEATURE   = 21
PORT_INDICATOR_FEATURE = 22
 
; Internal constants
; Bits in usb_hub.Actions
HUB_WAIT_POWERED      = 1
; ports were powered, wait until power is stable
HUB_WAIT_CONNECT      = 2
; some device was connected, wait initial debounce interval
HUB_RESET_IN_PROGRESS = 4
; reset in progress, so buffer for config requests is owned
; by reset process; this includes all stages from initial disconnect test
; to end of setting address (fail on any stage should lead to disabling port,
; which requires a config request)
HUB_RESET_WAITING     = 8
; the port is ready for reset, but another device somewhere on the bus
; is resetting. Implies HUB_RESET_IN_PROGRESS
HUB_RESET_SIGNAL      = 10h
; reset signalling is active for some port in the hub
; Implies HUB_RESET_IN_PROGRESS
HUB_RESET_RECOVERY    = 20h
; reset recovery is active for some port in the hub
; Implies HUB_RESET_IN_PROGRESS
 
; Well, I think that those 5 flags WAIT_CONNECT and RESET_* require additional
; comments. So that is the overview of what happens with a new device assuming
; no errors.
; * device is connected;
; * hub notifies us about connect event; after some processing
;   usb_hub_port_change finally processes that event, setting the flag
;   HUB_WAIT_CONNECT and storing time when the device was connected;
; * 100 ms delay;
; * usb_hub_process_deferred clears HUB_WAIT_CONNECT,
;   sets HUB_RESET_IN_PROGRESS, stores the port index in ConfigBuffer and asks
;   the hub whether there was a disconnect event for that port during those
;   100 ms (on the hardware level notifications are obtained using polling
;   with some intervals, so it is possible that the corresponding notification
;   has not arrived yet);
; * usb_hub_connect_port_status checks that there was no disconnect event
;   and sets HUB_RESET_WAITING flag (HUB_RESET_IN_PROGRESS is still set,
;   ConfigBuffer still contains the port index);
; * usb_hub_process_deferred checks whether there is another device currently
;   resetting. If so, it waits until reset is done
;   (with HUB_RESET_WAITING and HUB_RESET_IN_PROGRESS bits set);
; * usb_hub_process_deferred clears HUB_RESET_WAITING, sets HUB_RESET_SIGNAL
;   and initiates reset signalling on the port;
; * usb_hub_process_deferred checks the status every tick;
;   when reset signalling is stopped by the hub, usb_hub_resetting_port_status
;   callback clears HUB_RESET_SIGNAL and sets HUB_RESET_RECOVERY;
; * 10 ms (at least) delay;
; * usb_hub_process_deferred clears HUB_RESET_RECOVERY and notifies other code
;   that the new device is ready to be configured;
; * when it is possible to reset another device, the protocol layer
;   clears HUB_RESET_IN_PROGRESS bit.
 
; =============================================================================
; ================================ Structures =================================
; =============================================================================
; This structure contains all used data for one hub.
struct usb_hub
; All configured hubs are organized in the global usb_hub_list.
; Two following fields give next/prev items in that list.
; While the hub is unconfigured, they point to usb_hub itself.
Next                    dd      ?
Prev                    dd      ?
Controller              dd      ?
; Pointer to usb_controller for the bus.
;
; Handles of two pipes: configuration control pipe for zero endpoint opened by
; the common code and status interrupt pipe opened by us.
ConfigPipe              dd      ?
StatusPipe              dd      ?
NumPorts                dd      ?
; Number of downstream ports; from 1 to 255.
MaxPacketSize           dd      ?
; Maximum packet size for interrupt endpoint.
; Usually equals ceil((1+NumPorts)/8), but some hubs give additional bytes.
Actions                 dd      ?
; Bitfield with HUB_* constants.
PoweredOnTime           dd      ?
; Time (in ticks) when all downstream ports were powered up.
ResetTime               dd      ?
; Time (in ticks) when the current port was reset;
; when a port is resetting, contains the last tick of status check;
; when reset recovery for a port is active, contains the time when
; reset was completed.
;
; There are two possible reasons for configuration requests:
; synchronous, when certain time is passed after something,
; and asynchronous, when the hub is notifying about some change and
; config request needs to be issued in order to query details.
; Use two different buffers to avoid unnecessary dependencies.
ConfigBuffer            rb      8
; Buffer for configuration requests for synchronous events.
ChangeConfigBuffer      rb      8
; Buffer for configuration requests for status changes.
AccStatusChange         db      ?
; Accumulated status change. See 11.12.3 of USB2 spec or comments in code.
HubCharacteristics      dw      ?
; Copy of usb_hub_descr.wHubCharacteristics.
PowerOnInterval         db      ?
; Copy of usb_hub_descr.bPwrOn2PwrGood.
;
; Two following fields are written at once by GET_STATUS request
; and must remain in this order.
StatusData              dw      ?
; Bitfield with 1 shl PORT_* indicating status of the current port.
StatusChange            dw      ?
; Bitfield with 1 shl PORT_* indicating change in status of the current port.
; Two following fields are written at once by GET_STATUS request
; and must remain in this order.
; The meaning is the same as of StatusData/StatusChange; two following fields
; are used by the synchronous requests to avoid unnecessary interactions with
; the asynchronous handler.
ResetStatusData         dw      ?
ResetStatusChange       dw      ?
StatusChangePtr         dd      ?
; Pointer to StatusChangeBuf.
ConnectedDevicesPtr     dd      ?
; Pointer to ConnectedDevices.
ConnectedTimePtr        dd      ?
; Pointer to ConnectedTime.
;
; Variable-length parts:
; DeviceRemovable rb (NumPorts+8)/8
;  Bit i+1 = device at port i (zero-based) is non-removable.
; StatusChangeBuf rb (NumPorts+8)/8
;  Buffer for status interrupt pipe. Bit 0 = hub status change,
;  other bits = status change of the corresponding ports.
; ConnectedDevices rd NumPorts
;  Pointers to config pipes for connected devices or zero if no device connected.
; ConnectedTime rd NumPorts
;  For initial debounce interval:
;   time (in ticks) when a device was connected at that port.
;  Normally: -1
ends
 
; Hub descriptor.
struct usb_hub_descr usb_descr
bNbrPorts               db      ?
; Number of downstream ports.
wHubCharacteristics     dw      ?
; Bit 0: 0 = all ports are powered at once, 1 = individual port power switching
; Bit 1: reserved, must be zero
; Bit 2: 1 = the hub is part of a compound device
; Bits 3-4: 00 = global overcurrent protection,
;           01 = individual port overcurrent protection,
;           1x = no overcurrent protection
; Bits 5-6: Transaction Translator Think Time, 8*(value+1) full-speed bit times
; Bit 7: 1 = port indicators supported
; Other bits are reserved.
bPwrOn2PwrGood          db      ?
; Time in 2ms intervals between powering up a port and a port becoming ready.
bHubContrCurrent        db      ?
; Maximum current requirements of the Hub Controller electronics in mA.
; DeviceRemovable - variable length
;  Bit 0 is reserved, bit i+1 = device at port i is non-removable.
; PortPwrCtrlMask - variable length
;  Obsolete, exists for compatibility. We ignore it.
ends
 
iglobal
align 4
; Implementation of struct USBFUNC for hubs.
usb_hub_callbacks:
        dd      usb_hub_callbacks_end - usb_hub_callbacks
        dd      usb_hub_init
        dd      usb_hub_disconnect
usb_hub_callbacks_end:
usb_hub_pseudosrv       dd      usb_hub_callbacks
endg
 
; This procedure is called when new hub is detected.
; It initializes the device.
; Technically, initialization implies sending several USB queries,
; so it is split in several procedures. The first is usb_hub_init,
; other are callbacks which will be called at some time in the future,
; when the device will respond.
; edx = usb_interface_descr, ecx = length rest
proc usb_hub_init
        push    ebx esi         ; save used registers to be stdcall
virtual at esp
                rd      2       ; saved registers
                dd      ?       ; return address
.pipe           dd      ?       ; handle of the config pipe
.config         dd      ?       ; pointer to usb_config_descr
.interface      dd      ?       ; pointer to usb_interface_descr
end virtual
; 1. Check that the maximal nesting is not exceeded:
; 5 non-root hubs is the maximum according to the spec.
        mov     ebx, [.pipe]
        push    5
        mov     eax, ebx
.count_parents:
        mov     eax, [eax+usb_pipe.DeviceData]
        mov     eax, [eax+usb_device_data.Hub]
        test    eax, eax
        jz      .depth_ok
        mov     eax, [eax+usb_hub.ConfigPipe]
        dec     dword [esp]
        jnz     .count_parents
        pop     eax
        dbgstr 'Hub chain is too long'
        jmp     .return0
.depth_ok:
        pop     eax
; Hubs use one IN interrupt endpoint for polling the device
; 2. Locate the descriptor of the interrupt endpoint.
; Loop over all descriptors owned by this interface.
.lookep:
; 2a. Skip the current descriptor.
        movzx   eax, [edx+usb_descr.bLength]
        add     edx, eax
        sub     ecx, eax
        jb      .errorep
; 2b. Length of data left must be at least sizeof.usb_endpoint_descr.
        cmp     ecx, sizeof.usb_endpoint_descr
        jb      .errorep
; 2c. If we have found another interface descriptor but not found our endpoint,
; this is an error: all subsequent descriptors belong to that interface
; (or further interfaces).
        cmp     [edx+usb_endpoint_descr.bDescriptorType], USB_INTERFACE_DESCR
        jz      .errorep
; 2d. Ignore all interface-related descriptors except endpoint descriptor.
        cmp     [edx+usb_endpoint_descr.bDescriptorType], USB_ENDPOINT_DESCR
        jnz     .lookep
; 2e. Length of endpoint descriptor must be at least sizeof.usb_endpoint_descr.
        cmp     [edx+usb_endpoint_descr.bLength], sizeof.usb_endpoint_descr
        jb      .errorep
; 2f. Ignore all endpoints except for INTERRUPT IN.
        cmp     [edx+usb_endpoint_descr.bEndpointAddress], 0
        jge     .lookep
        mov     al, [edx+usb_endpoint_descr.bmAttributes]
        and     al, 3
        cmp     al, INTERRUPT_PIPE
        jnz     .lookep
; We have located the descriptor for INTERRUPT IN endpoint,
; the pointer is in edx.
; 3. Allocate memory for the hub descriptor.
; Maximum length (assuming 255 downstream ports) is 40 bytes.
; Allocate 4 extra bytes to keep wMaxPacketSize.
; 3a. Save registers.
        push    edx
; 3b. Call the allocator.
        movi    eax, 44
        call    malloc
; 3c. Restore registers.
        pop     ecx
; 3d. If failed, say something to the debug board and return error.
        test    eax, eax
        jz      .nomemory
; 3e. Store the pointer in esi. xchg eax,r32 is one byte shorter than mov.
        xchg    esi, eax
; 4. Open a pipe for the status endpoint with descriptor found in step 1.
        movzx   eax, [ecx+usb_endpoint_descr.bEndpointAddress]
        movzx   edx, [ecx+usb_endpoint_descr.bInterval]
        movzx   ecx, [ecx+usb_endpoint_descr.wMaxPacketSize]
        test    ecx, (1 shl 11) - 1
        jz      .free
        push    ecx
        stdcall usb_open_pipe, ebx, eax, ecx, INTERRUPT_PIPE, edx
        pop     ecx
; If failed, free the memory allocated in step 3,
; say something to the debug board and return error.
        test    eax, eax
        jz      .free
; 5. Send control query for the hub descriptor,
; pass status pipe as a callback parameter,
; allow short packets.
        and     ecx, (1 shl 11) - 1
        mov     [esi+40], ecx
        mov     dword [esi], 0xA0 + \   ; class-specific request
                (USB_GET_DESCRIPTOR shl 8) + \
                (0 shl 16) + \          ; descriptor index 0
                (USB_HUB_DESCRIPTOR shl 24)
        mov     dword [esi+4], 40 shl 16
        stdcall usb_control_async, ebx, esi, esi, 40, usb_hub_got_config, eax, 1
; 6. If failed, free the memory allocated in step 3,
; say something to the debug board and return error.
        test    eax, eax
        jz      .free
; Otherwise, return 1. usb_hub_got_config will overwrite it later.
        xor     eax, eax
        inc     eax
        jmp     .nothing
.free:
        xchg    eax, esi
        call    free
        jmp     .return0
.errorep:
        dbgstr 'Invalid config descriptor for a hub'
        jmp     .return0
.nomemory:
        dbgstr 'No memory for USB hub data'
.return0:
        xor     eax, eax
.nothing:
        pop     esi ebx         ; restore used registers to be stdcall
        retn    12
endp
 
; This procedure is called when the request for the hub descriptor initiated
; by usb_hub_init is finished, either successfully or unsuccessfully.
proc usb_hub_got_config stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
        push    ebx             ; save used registers to be stdcall
; 1. If failed, say something to the debug board, free the buffer
; and stop the initialization.
        cmp     [status], 0
        jnz     .invalid
; 2. The length must be at least sizeof.usb_hub_descr.
; Note that [length] includes 8 bytes of setup packet.
        cmp     [length], 8 + sizeof.usb_hub_descr
        jb      .invalid
; 3. Sanity checks for the hub descriptor.
        mov     eax, [buffer]
if USB_DUMP_DESCRIPTORS
        mov     ecx, [length]
        sub     ecx, 8
        DEBUGF 1,'K : hub config:'
        push    eax
@@:
        DEBUGF 1,' %x',[eax]:2
        inc     eax
        dec     ecx
        jnz     @b
        DEBUGF 1,'\n'
        pop     eax
end if
        cmp     [eax+usb_hub_descr.bLength], sizeof.usb_hub_descr
        jb      .invalid
        cmp     [eax+usb_hub_descr.bDescriptorType], USB_HUB_DESCRIPTOR
        jnz     .invalid
        movzx   ecx, [eax+usb_hub_descr.bNbrPorts]
        test    ecx, ecx
        jz      .invalid
; 4. We use sizeof.usb_hub_descr bytes plus DeviceRemovable info;
; size of DeviceRemovable is (NumPorts+1) bits, this gives
; floor(NumPorts/8)+1 bytes. Check that all data are present in the
; descriptor and were successfully read.
        mov     edx, ecx
        shr     edx, 3
        add     edx, sizeof.usb_hub_descr + 1
        cmp     [eax+usb_hub_descr.bLength], dl
        jb      .invalid
        sub     [length], 8
        cmp     [length], edx
        jb      .invalid
; 5. Allocate the memory for usb_hub structure.
; Total size of variable-length data is ALIGN_UP(floor(NumPorts/8)+1+MaxPacketSize,4)+8*NumPorts.
        add     edx, [eax+40]
        add     edx, sizeof.usb_hub - sizeof.usb_hub_descr + 3
        and     edx, not 3
        lea     eax, [edx+ecx*8]
        push    ecx edx
        call    malloc
        pop     edx ecx
        test    eax, eax
        jz      .nomemory
        xchg    eax, ebx
; 6. Fill usb_hub structure.
        mov     [ebx+usb_hub.NumPorts], ecx
        add     edx, ebx
        mov     [ebx+usb_hub.ConnectedDevicesPtr], edx
        mov     eax, [pipe]
        mov     [ebx+usb_hub.ConfigPipe], eax
        mov     edx, [eax+usb_pipe.Controller]
        mov     [ebx+usb_hub.Controller], edx
        mov     eax, [calldata]
        mov     [ebx+usb_hub.StatusPipe], eax
        push    esi edi
        mov     esi, [buffer]
        mov     eax, [esi+40]
        mov     [ebx+usb_hub.MaxPacketSize], eax
; The following commands load bNbrPorts, wHubCharacteristics, bPwrOn2PwrGood.
        mov     edx, dword [esi+usb_hub_descr.bNbrPorts]
        mov     dl, 0
; The following command zeroes AccStatusChange and stores
; HubCharacteristics and PowerOnInterval.
        mov     dword [ebx+usb_hub.AccStatusChange], edx
        xor     eax, eax
        mov     [ebx+usb_hub.Actions], eax
; Copy DeviceRemovable data.
        lea     edi, [ebx+sizeof.usb_hub]
        add     esi, sizeof.usb_hub_descr
        mov     edx, ecx
        shr     ecx, 3
        inc     ecx
        rep movsb
        mov     [ebx+usb_hub.StatusChangePtr], edi
; Zero ConnectedDevices.
        mov     edi, [ebx+usb_hub.ConnectedDevicesPtr]
        mov     ecx, edx
        rep stosd
        mov     [ebx+usb_hub.ConnectedTimePtr], edi
; Set ConnectedTime to -1.
        dec     eax
        mov     ecx, edx
        rep stosd
        pop     edi esi
; 7. Replace value of 1 returned from usb_hub_init to the real value.
; Note: hubs are part of the core USB code, so this code can work with
; internals of other parts. Another way, the only possible one for external
; drivers, is to use two memory allocations: one (returned from AddDevice and
; fixed after that) for pointer, another for real data. That would work also,
; but wastes one allocation.
        mov     eax, [pipe]
        mov     eax, [eax+usb_pipe.DeviceData]
        add     eax, [eax+usb_device_data.Interfaces]
.scan:
        cmp     [eax+usb_interface_data.DriverData], 1
        jnz     @f
        cmp     [eax+usb_interface_data.DriverFunc], usb_hub_pseudosrv - USBSRV.usb_func
        jz      .scan_found
@@:
        add     eax, sizeof.usb_interface_data
        jmp     .scan
.scan_found:
        mov     [eax+usb_interface_data.DriverData], ebx
; 8. Insert the hub structure to the tail of the overall list of all hubs.
        mov     ecx, usb_hubs_list
        mov     edx, [ecx+usb_hub.Prev]
        mov     [ecx+usb_hub.Prev], ebx
        mov     [edx+usb_hub.Next], ebx
        mov     [ebx+usb_hub.Prev], edx
        mov     [ebx+usb_hub.Next], ecx
; 9. Start powering up all ports.
        DEBUGF 1,'K : found hub with %d ports\n',[ebx+usb_hub.NumPorts]
        lea     eax, [ebx+usb_hub.ConfigBuffer]
        xor     ecx, ecx
        mov     dword [eax], 23h + \    ; class-specific request to hub port
                (USB_SET_FEATURE shl 8) + \
                (PORT_POWER shl 16)
        mov     edx, [ebx+usb_hub.NumPorts]
        mov     dword [eax+4], edx
        stdcall usb_control_async, [ebx+usb_hub.ConfigPipe], eax, ecx, ecx, usb_hub_port_powered, ebx, ecx
.freebuf:
; 10. Free the buffer for hub descriptor and return.
        mov     eax, [buffer]
        call    free
        pop     ebx             ; restore used registers to be stdcall
        ret
.nomemory:
        dbgstr 'No memory for USB hub data'
        jmp     .freebuf
.invalid:
        dbgstr 'Invalid hub descriptor'
        jmp     .freebuf
endp
 
; This procedure is called when the request to power up some port is completed,
; either successfully or unsuccessfully.
proc usb_hub_port_powered stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
; 1. Check whether the operation was successful.
; If not, say something to the debug board and ssstop the initialization.
        cmp     [status], 0
        jnz     .invalid
; 2. Check whether all ports were powered.
; If so, go to 4. Otherwise, proceed to 3.
        mov     eax, [calldata]
        dec     dword [eax+usb_hub.ConfigBuffer+4]
        jz      .done
; 3. Power up the next port and return.
        lea     edx, [eax+usb_hub.ConfigBuffer]
        xor     ecx, ecx
        stdcall usb_control_async, [eax+usb_hub.ConfigPipe], edx, ecx, ecx, usb_hub_port_powered, eax, ecx
.nothing:
        ret
.done:
; 4. All ports were powered.
; The hub requires some delay until power will be stable, the delay value
; is provided in the hub descriptor; we have copied that value to
; usb_hub.PowerOnInterval. Note the time and set the corresponding flag
; for usb_hub_process_deferred.
        mov     ecx, [timer_ticks]
        mov     [eax+usb_hub.PoweredOnTime], ecx
        or      [eax+usb_hub.Actions], HUB_WAIT_POWERED
        jmp     .nothing
.invalid:
        dbgstr 'Error while powering hub ports'
        jmp     .nothing
endp
 
; Requests notification about any changes in hub/ports configuration.
; Called when initial configuration is done and when a previous notification
; has been processed.
proc usb_hub_wait_change
        stdcall usb_normal_transfer_async, [eax+usb_hub.StatusPipe], \
                [eax+usb_hub.StatusChangePtr], [eax+usb_hub.MaxPacketSize], usb_hub_changed, eax, 1
        ret
endp
 
; This procedure is called when something has changed on the hub.
proc usb_hub_changed stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
;       DEBUGF 1,'K : [%d] int pipe for hub %x\n',[timer_ticks],[calldata]
; 1. Check whether our request has failed.
; If so, say something to the debug board and stop processing notifications.
        xor     ecx, ecx
        cmp     [status], ecx
        jnz     .failed
; 2. If no data were retrieved, restart waiting.
        mov     eax, [calldata]
        cmp     [length], ecx
        jz      .continue
; 3. If size of data retrieved is less than maximal, pad with zeroes;
; this corresponds to 'state of other ports was not changed'
        mov     ecx, [eax+usb_hub.NumPorts]
        shr     ecx, 3
        inc     ecx
        sub     ecx, [length]
        jbe     .restart
        push    eax edi
        mov     edi, [buffer]
        add     edi, [length]
        xor     eax, eax
        rep stosb
        pop     edi eax
.restart:
; State of some elements of the hub was changed.
; Find the first element that was changed,
; ask the hub about nature of the change,
; clear the corresponding change,
; reask the hub about status+change (it is possible that another change
; occurs between the first ask and clearing the change; we won't see that
; change, so we need to query the status after clearing the change),
; continue two previous steps until nothing changes,
; process all changes which were registered.
; When all changes for one element will be processed, return to here and look
; for other changed elements.
        mov     edx, [eax+usb_hub.StatusChangePtr]
; We keep all observed changes in the special var usb_hub.AccStatusChange;
; it will be logical OR of all observed StatusChange's.
; 4. No observed changes yet, zero usb_hub.AccStatusChange.
        xor     ecx, ecx
        mov     [eax+usb_hub.AccStatusChange], cl
; 5. Test whether there was a change in the hub itself.
; If so, query hub state.
        btr     dword [edx], ecx
        jnc     .no_hub_change
.next_hub_change:
;       DEBUGF 1,'K : [%d] querying status of hub %x\n',[timer_ticks],eax
        lea     edx, [eax+usb_hub.ChangeConfigBuffer]
        lea     ecx, [eax+usb_hub.StatusData]
        mov     dword [edx], 0A0h + \   ; class-specific request from hub itself
                (USB_GET_STATUS shl 8)
        mov     dword [edx+4], 4 shl 16 ; get 4 bytes
        stdcall usb_control_async, [eax+usb_hub.ConfigPipe], edx, ecx, 4, usb_hub_status, eax, 0
        jmp     .nothing
.no_hub_change:
; 6. Find the first port with changed state and clear the corresponding bit
; (so next scan after .restart will not consider this port again).
; If found, go to 8. Otherwise, advance to 7.
        inc     ecx
.test_port_change:
        btr     [edx], ecx
        jc      .found_port_change
        inc     ecx
        cmp     ecx, [eax+usb_hub.NumPorts]
        jbe     .test_port_change
.continue:
; 7. All changes have been processed. Wait for next notification.
        call    usb_hub_wait_change
.nothing:
        ret
.found_port_change:
        mov     dword [eax+usb_hub.ChangeConfigBuffer+4], ecx
.next_port_change:
; 8. Query port state. Continue work in usb_hub_port_status callback.
;       movzx   ecx, [eax+usb_hub.ChangeConfigBuffer+4]
;       dec     ecx
;       DEBUGF 1,'K : [%d] querying status of hub %x port %d\n',[timer_ticks],eax,ecx
        lea     edx, [eax+usb_hub.ChangeConfigBuffer]
        mov     dword [edx], 0A3h + \   ; class-specific request from hub port
                (USB_GET_STATUS shl 8)
        mov     byte [edx+6], 4         ; data length = 4 bytes
        lea     ecx, [eax+usb_hub.StatusData]
        stdcall usb_control_async, [eax+usb_hub.ConfigPipe], edx, ecx, 4, usb_hub_port_status, eax, 0
        jmp     .nothing
.failed:
        cmp     [status], USB_STATUS_CLOSED
        jz      .nothing
        dbgstr 'Querying hub notification failed'
        jmp     .nothing
endp
 
; This procedure is called when the request of hub status is completed,
; either successfully or unsuccessfully.
proc usb_hub_status stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
; 1. Check whether our request has failed.
; If so, say something to the debug board and stop processing notifications.
        cmp     [status], 0
        jnz     .failed
; 2. Accumulate observed changes.
        mov     eax, [calldata]
        mov     dl, byte [eax+usb_hub.StatusChange]
        or      [eax+usb_hub.AccStatusChange], dl
.next_change:
; 3. Find the first change. If found, advance to 4. Otherwise, go to 5.
        mov     cl, C_HUB_OVER_CURRENT
        btr     dword [eax+usb_hub.StatusChange], 1
        jc      .clear_hub_change
        mov     cl, C_HUB_LOCAL_POWER
        btr     dword [eax+usb_hub.StatusChange], 0
        jnc     .final
.clear_hub_change:
; 4. Clear the change and continue in usb_hub_change_cleared callback.
        lea     edx, [eax+usb_hub.ChangeConfigBuffer]
        mov     dword [edx], 20h + \    ; class-specific request to hub itself
                (USB_CLEAR_FEATURE shl 8)
        mov     [edx+2], cl     ; feature selector
        and     dword [edx+4], 0
        stdcall usb_control_async, [eax+usb_hub.ConfigPipe], edx, 0, 0, usb_hub_change_cleared, eax, 0
.nothing:
        ret
.final:
; 5. All changes cleared and accumulated, now process them.
; Note: that needs work.
        DEBUGF 1,'K : hub status %x\n',[eax+usb_hub.AccStatusChange]:2
        test    [eax+usb_hub.AccStatusChange], 1
        jz      .no_local_power
        test    [eax+usb_hub.StatusData], 1
        jz      .local_power_lost
        dbgstr 'Hub local power is now good'
        jmp     .no_local_power
.local_power_lost:
        dbgstr 'Hub local power is now lost'
.no_local_power:
        test    [eax+usb_hub.AccStatusChange], 2
        jz      .no_overcurrent
        test    [eax+usb_hub.StatusData], 2
        jz      .no_overcurrent
        dbgstr 'Hub global overcurrent'
.no_overcurrent:
; 6. Process possible changes for other ports.
        jmp     usb_hub_changed.restart
.failed:
        dbgstr 'Querying hub status failed'
        jmp     .nothing
endp
 
; This procedure is called when the request to clear hub change is completed,
; either successfully or unsuccessfully.
proc usb_hub_change_cleared stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
; 1. Check whether our request has failed.
; If so, say something to the debug board and stop processing notifications.
        cmp     [status], 0
        jnz     .failed
; 2. If there is a change which was observed, but not yet cleared,
; go to the code which clears it.
        mov     eax, [calldata]
        cmp     [eax+usb_hub.StatusChange], 0
        jnz     usb_hub_status.next_change
; 3. Otherwise, go to the code which queries the status.
        jmp     usb_hub_changed.next_hub_change
.failed:
        dbgstr 'Clearing hub change failed'
        ret
endp
 
; This procedure is called when the request of port status is completed,
; either successfully or unsuccessfully.
proc usb_hub_port_status stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
; 1. Check whether our request has failed.
; If so, say something to the debug board and stop processing notifications.
        cmp     [status], 0
        jnz     .failed
; 2. Accumulate observed changes.
        mov     eax, [calldata]
;       movzx   ecx, [eax+usb_hub.ChangeConfigBuffer+4]
;       dec     ecx
;       DEBUGF 1,'K : [%d] hub %x port %d status %x change %x\n',[timer_ticks],eax,ecx,[eax+usb_hub.StatusData]:4,[eax+usb_hub.StatusChange]:4
        mov     dl, byte [eax+usb_hub.StatusChange]
        or      [eax+usb_hub.AccStatusChange], dl
.next_change:
; 3. Find the first change. If found, advance to 4. Otherwise, go to 5.
; Ignore change in reset status; it is cleared by synchronous code
; (usb_hub_process_deferred), so avoid unnecessary interference.
;       mov     cl, C_PORT_RESET
        btr     dword [eax+usb_hub.StatusChange], PORT_RESET
;       jc      .clear_port_change
        mov     cl, C_PORT_OVER_CURRENT
        btr     dword [eax+usb_hub.StatusChange], PORT_OVER_CURRENT
        jc      .clear_port_change
        mov     cl, C_PORT_SUSPEND
        btr     dword [eax+usb_hub.StatusChange], PORT_SUSPEND
        jc      .clear_port_change
        mov     cl, C_PORT_ENABLE
        btr     dword [eax+usb_hub.StatusChange], PORT_ENABLE
        jc      .clear_port_change
        mov     cl, C_PORT_CONNECTION
        btr     dword [eax+usb_hub.StatusChange], PORT_CONNECTION
        jnc     .final
.clear_port_change:
; 4. Clear the change and continue in usb_hub_port_changed callback.
        call    usb_hub_clear_port_change
        jmp     .nothing
.final:
; All changes cleared and accumulated, now process them.
        movzx   ecx, byte [eax+usb_hub.ChangeConfigBuffer+4]
        dec     ecx
        DEBUGF 1,'K : final: hub %x port %d status %x change %x\n',eax,ecx,[eax+usb_hub.StatusData]:4,[eax+usb_hub.AccStatusChange]:2
; 5. Process connect/disconnect events.
; 5a. Test whether there is such event.
        test    byte [eax+usb_hub.AccStatusChange], 1 shl PORT_CONNECTION
        jz      .nodisconnect
; 5b. If there was a connected device, notify the main code about disconnect.
        push    ebx
        mov     edx, [eax+usb_hub.ConnectedDevicesPtr]
        xor     ebx, ebx
        xchg    ebx, [edx+ecx*4]
        test    ebx, ebx
        jz      @f
        push    eax ecx
        call    usb_device_disconnected
        pop     ecx eax
@@:
        pop     ebx
; 5c. If the disconnect event corresponds to the port which is currently
; resetting, then another request from synchronous code could be in the fly,
; so aborting reset immediately would lead to problems with those requests.
; Thus, just set the corresponding status and let the synchronous code process.
        test    byte [eax+usb_hub.Actions], (HUB_RESET_SIGNAL or HUB_RESET_RECOVERY)
        jz      @f
        mov     edx, [eax+usb_hub.Controller]
        cmp     [edx+usb_controller.ResettingPort], cl
        jnz     @f
        mov     [edx+usb_controller.ResettingStatus], -1
@@:
; 5d. If the current status is 'connected', store the current time as connect
; time and set the corresponding bit for usb_hub_process_deferred.
; Otherwise, set connect time to -1.
; If current time is -1, pretend that the event occured one tick later and
; store zero.
        mov     edx, [eax+usb_hub.ConnectedTimePtr]
        test    byte [eax+usb_hub.StatusData], 1 shl PORT_CONNECTION
        jz      .disconnected
        or      [eax+usb_hub.Actions], HUB_WAIT_CONNECT
        push    eax
        call    usb_hub_store_connected_time
        pop     eax
        jmp     @f
.disconnected:
        or      dword [edx+ecx*4], -1
@@:
.nodisconnect:
; 6. Process port disabling.
        test    [eax+usb_hub.AccStatusChange], 1 shl PORT_ENABLE
        jz      .nodisable
        test    byte [eax+usb_hub.StatusData], 1 shl PORT_ENABLE
        jnz     .nodisable
; Note: that needs work.
        dbgstr 'Port disabled'
.nodisable:
; 7. Process port overcurrent.
        test    [eax+usb_hub.AccStatusChange], 1 shl PORT_OVER_CURRENT
        jz      .noovercurrent
        test    byte [eax+usb_hub.StatusData], 1 shl PORT_OVER_CURRENT
        jz      .noovercurrent
; Note: that needs work.
        dbgstr 'Port over-current'
.noovercurrent:
; 8. Process possible changes for other ports.
        jmp     usb_hub_changed.restart
.failed:
        dbgstr 'Querying port status failed'
.nothing:
        ret
endp
 
; Helper procedure to store current time in ConnectedTime,
; advancing -1 to zero if needed.
proc usb_hub_store_connected_time
        mov     eax, [timer_ticks]
; transform -1 to 0, leave other values as is
        cmp     eax, -1
        sbb     eax, -1
        mov     [edx+ecx*4], eax
        ret
endp
 
; Helper procedure for several parts of hub code.
; Sends a request to clear the given feature of the port.
; eax -> usb_hub, cl = feature;
; as is should be called from async code, sync code should set
; edx to ConfigBuffer and call usb_hub_clear_port_change.buffer;
; port number (1-based) should be filled in [edx+4] by previous requests.
proc usb_hub_clear_port_change
        lea     edx, [eax+usb_hub.ChangeConfigBuffer]
.buffer:
;       push    edx
;       movzx   edx, byte [edx+4]
;       dec     edx
;       DEBUGF 1,'K : [%d] hub %x port %d clear feature %d\n',[timer_ticks],eax,edx,cl
;       pop     edx
        mov     dword [edx], 23h + \    ; class-specific request to hub port
                (USB_CLEAR_FEATURE shl 8)
        mov     byte [edx+2], cl
        and     dword [edx+4], 0xFF
        stdcall usb_control_async, [eax+usb_hub.ConfigPipe], edx, edx, 0, usb_hub_port_changed, eax, 0
        ret
endp
 
; This procedure is called when the request to clear port change is completed,
; either successfully or unsuccessfully.
proc usb_hub_port_changed stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
; 1. Check whether our request has failed.
; If so, say something to the debug board and stop processing notifications.
        cmp     [status], 0
        jnz     .failed
; 2. If the request was originated by synchronous code, no further processing
; is required.
        mov     eax, [calldata]
        lea     edx, [eax+usb_hub.ConfigBuffer]
        cmp     [buffer], edx
        jz      .nothing
; 3. If there is a change which was observed, but not yet cleared,
; go to the code which clears it.
        cmp     [eax+usb_hub.StatusChange], 0
        jnz     usb_hub_port_status.next_change
; 4. Otherwise, go to the code which queries the status.
        jmp     usb_hub_changed.next_port_change
.failed:
        dbgstr 'Clearing port change failed'
.nothing:
        ret
endp
 
; This procedure is called in the USB thread from usb_thread_proc,
; contains synchronous code which should be activated at certain time
; (e.g. reset a recently connected device after debounce interval 100ms).
; Returns the number of ticks when it should be called next time.
proc usb_hub_process_deferred
; 1. Top-of-stack will contain return value; initialize to infinite timeout.
        push    -1
; 2. If wait for stable power is active, then
; either reschedule wakeup (if time is not over)
; or start processing notifications.
        test    byte [esi+usb_hub.Actions], HUB_WAIT_POWERED
        jz      .no_powered
        movzx   eax, [esi+usb_hub.PowerOnInterval]
; three following instructions are equivalent to edx = ceil(eax / 5) + 1
; 1 extra tick is added to make sure that the interval is at least as needed
; (it is possible that PoweredOnTime was set just before timer interrupt, and
; this test goes on just after timer interrupt)
        add     eax, 9
; two following instructions are equivalent to edx = floor(eax / 5)
; for any 0 <= eax < 40000000h
        mov     ecx, 33333334h
        mul     ecx
        mov     eax, [timer_ticks]
        sub     eax, [esi+usb_hub.PoweredOnTime]
        sub     eax, edx
        jge     .powered_on
        neg     eax
        pop     ecx
        push    eax
        jmp     .no_powered
.powered_on:
        and     [esi+usb_hub.Actions], not HUB_WAIT_POWERED
        mov     eax, esi
        call    usb_hub_wait_change
.no_powered:
; 3. If reset is pending, check whether we can start it and start it, if so.
        test    byte [esi+usb_hub.Actions], HUB_RESET_WAITING
        jz      .no_wait_reset
        mov     eax, [esi+usb_hub.Controller]
        cmp     [eax+usb_controller.ResettingPort], -1
        jnz     .no_wait_reset
        call    usb_hub_initiate_reset
.no_wait_reset:
; 4. If reset signalling is active, wait for end of reset signalling
; and schedule wakeup in 1 tick.
        test    byte [esi+usb_hub.Actions], HUB_RESET_SIGNAL
        jz      .no_resetting_port
; It has no sense to query status several times per tick.
        mov     eax, [timer_ticks]
        cmp     eax, [esi+usb_hub.ResetTime]
        jz      @f
        mov     [esi+usb_hub.ResetTime], eax
        movzx   ecx, byte [esi+usb_hub.ConfigBuffer+4]
        mov     eax, usb_hub_resetting_port_status
        call    usb_hub_query_port_status
@@:
        pop     eax
        push    1
.no_resetting_port:
; 5. If reset recovery is active and time is not over, reschedule wakeup.
        test    byte [esi+usb_hub.Actions], HUB_RESET_RECOVERY
        jz      .no_reset_recovery
        mov     eax, [timer_ticks]
        sub     eax, [esi+usb_hub.ResetTime]
        sub     eax, USB_RESET_RECOVERY_TIME
        jge     .reset_done
        neg     eax
        cmp     [esp], eax
        jb      @f
        mov     [esp], eax
@@:
        jmp     .no_reset_recovery
.reset_done:
; 6. If reset recovery is active and time is over, clear 'reset recovery' flag,
; notify other code about a new device and let it do further steps.
; If that fails, stop reset process for this port and disable that port.
        and     [esi+usb_hub.Actions], not HUB_RESET_RECOVERY
; Bits 9-10 of port status encode port speed.
; If PORT_LOW_SPEED is set, the device is low-speed. Otherwise,
; PORT_HIGH_SPEED bit distinguishes full-speed and high-speed devices.
; This corresponds to values of USB_SPEED_FS=0, USB_SPEED_LS=1, USB_SPEED_HS=2.
        mov     eax, dword [esi+usb_hub.ResetStatusData]
        shr     eax, PORT_LOW_SPEED
        and     eax, 3
        test    al, 1
        jz      @f
        mov     al, 1
@@:
;       movzx   ecx, [esi+usb_hub.ConfigBuffer+4]
;       dec     ecx
;       DEBUGF 1,'K : [%d] hub %x port %d speed %d\n',[timer_ticks],esi,ecx,eax
        push    esi
        mov     esi, [esi+usb_hub.Controller]
        cmp     [esi+usb_controller.ResettingStatus], -1
        jz      .disconnected_while_reset
        mov     edx, [esi+usb_controller.HardwareFunc]
        call    [edx+usb_hardware_func.NewDevice]
        pop     esi
        test    eax, eax
        jnz     .no_reset_recovery
        mov     eax, esi
        call    usb_hub_disable_resetting_port
        jmp     .no_reset_recovery
.disconnected_while_reset:
        pop     esi
        mov     eax, esi
        call    usb_hub_reset_aborted
.no_reset_recovery:
; 7. Handle recent connection events.
; Note: that should be done after step 6, because step 6 can clear
; HUB_RESET_IN_PROGRESS flag.
; 7a. Test whether there is such an event pending. If no, skip this step.
        test    byte [esi+usb_hub.Actions], HUB_WAIT_CONNECT
        jz      .no_wait_connect
; 7b. If we have started reset process for another port in the same hub,
; skip this step: the buffer for config requests can be used for that port.
        test    byte [esi+usb_hub.Actions], HUB_RESET_IN_PROGRESS
        jnz     .no_wait_connect
; 7c. Clear flag 'there are connection events which should be processed'.
; If there are another connection events, this flag will be set again.
        and     [esi+usb_hub.Actions], not HUB_WAIT_CONNECT
; 7d. Prepare for loop over all ports.
        xor     ecx, ecx
.test_wait_connect:
; 7e. For every port test for recent connection event.
; If none, continue the loop for the next port.
        mov     edx, [esi+usb_hub.ConnectedTimePtr]
        mov     eax, [edx+ecx*4]
        cmp     eax, -1
        jz      .next_wait_connect
        or      [esi+usb_hub.Actions], HUB_WAIT_CONNECT
; 7f. Test whether initial delay is over.
        sub     eax, [timer_ticks]
        neg     eax
        sub     eax, USB_CONNECT_DELAY
        jge     .connect_delay_over
; 7g. The initial delay is not over;
; set the corresponding flag again, reschedule wakeup and continue the loop.
        neg     eax
        cmp     [esp], eax
        jb      @f
        mov     [esp], eax
@@:
        jmp     .next_wait_connect
.connect_delay_over:
; The initial delay is over.
; It is possible that there was disconnect event during that delay, probably
; with connect event after that. If so, we should restart the waiting. However,
; on the hardware level connect/disconnect events from hubs are implemented
; using polling with interval selected by the hub, so it is possible that
; we have not yet observed that disconnect event.
; Thus, we query port status+change data before all further processing.
; 7h. Send the request for status+change data.
        push    ecx
; Hub requests expect 1-based port number, not zero-based we operate with.
        inc     ecx
        mov     eax, usb_hub_connect_port_status
        call    usb_hub_query_port_status
        pop     ecx
; 3i. If request has been submitted successfully, set the flag
; 'reset in progress, config buffer is owned by reset process' and break
; from the loop.
        test    eax, eax
        jz      .next_wait_connect
        or      [esi+usb_hub.Actions], HUB_RESET_IN_PROGRESS
        jmp     .no_wait_connect
.next_wait_connect:
; 7j. Continue the loop for next port.
        inc     ecx
        cmp     ecx, [esi+usb_hub.NumPorts]
        jb      .test_wait_connect
.no_wait_connect:
; 8. Pop return value from top-of-stack and return.
        pop     eax
        ret
endp
 
; Helper procedure for other code. Called when reset process is aborted.
proc usb_hub_reset_aborted
; Clear 'reset in progress' flag and test for other devices which could be
; waiting for reset.
        and     [eax+usb_hub.Actions], not HUB_RESET_IN_PROGRESS
        push    esi
        mov     esi, [eax+usb_hub.Controller]
        call    usb_test_pending_port
        pop     esi
        ret
endp
 
; Helper procedure for usb_hub_process_deferred.
; Sends a request to query port status.
; esi -> usb_hub, eax = callback, ecx = 1-based port.
proc usb_hub_query_port_status
;       dec     ecx
;       DEBUGF 1,'K : [%d] [main] hub %x port %d query status\n',[timer_ticks],esi,ecx
;       inc     ecx
        add     ecx, 4 shl 16           ; data length = 4
        lea     edx, [esi+usb_hub.ConfigBuffer]
        mov     dword [edx], 0A3h + \   ; class-specific request from hub port
                (USB_GET_STATUS shl 8)
        mov     dword [edx+4], ecx
        lea     ecx, [esi+usb_hub.ResetStatusData]
        stdcall usb_control_async, [esi+usb_hub.ConfigPipe], edx, ecx, 4, eax, esi, 0
        ret
endp
 
; This procedure is called when the request to query port status
; initiated by usb_hub_process_deferred for testing connection is completed,
; either successfully or unsuccessfully.
proc usb_hub_connect_port_status stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
        push    esi     ; save used register to be stdcall
        mov     eax, [calldata]
        mov     esi, [pipe]
;       movzx   ecx, [eax+usb_hub.ConfigBuffer+4]
;       dec     ecx
;       DEBUGF 1,'K : [%d] [connect test] hub %x port %d status %x change %x\n',[timer_ticks],eax,ecx,[eax+usb_hub.ResetStatusData]:4,[eax+usb_hub.ResetStatusChange]:4
; 1. In any case, clear 'reset in progress' flag.
; If everything is ok, it would be set again.
        and     [eax+usb_hub.Actions], not HUB_RESET_IN_PROGRESS
; 2. If the request has failed, stop reset process.
        cmp     [status], 0
        jnz     .nothing
        mov     edx, [eax+usb_hub.ConnectedTimePtr]
        movzx   ecx, byte [eax+usb_hub.ConfigBuffer+4]
        dec     ecx
; 3. Test whether there was a disconnect event.
        test    byte [eax+usb_hub.ResetStatusChange], 1 shl PORT_CONNECTION
        jz      .reset
; 4. There was a disconnect event.
; There is another handler of connect/disconnect events, usb_hub_port_status.
; However, we do not know whether it has already processed this event
; or it will process it sometime later.
; If ConnectedTime is -1, then another handler has already run,
; there was no connection event, so just leave the value as -1.
; Otherwise, there are two possibilities: either another handler has not yet
; run (which is quite likely), or there was a connection event and the other
; handler has run exactly while our request was processed (otherwise our
; request would not been submitted; this is quite unlikely due to timing
; requirements, but not impossible). In this case, set ConnectedTime to the
; current time: in the likely case it prevents usb_hub_process_deferred from immediate
; issuing of another requests (which would be just waste of time);
; in the unlikely case it is still correct (although slightly increases
; the debounce interval).
        cmp     dword [edx+ecx*4], -1
        jz      .nothing
        call    usb_hub_store_connected_time
        jmp     .nothing
.reset:
; 5. The device remained connected for the entire debounce interval;
; we can proceed with initialization.
; Clear connected time for this port and notify usb_hub_process_deferred that
; the new port is waiting for reset.
        or      dword [edx+ecx*4], -1
        or      [eax+usb_hub.Actions], HUB_RESET_IN_PROGRESS + HUB_RESET_WAITING
.nothing:
        pop     esi     ; restore used register to be stdcall
        ret
endp
 
; This procedure is called when the request to query port status
; initiated by usb_hub_process_deferred for testing reset status is completed,
; either successfully or unsuccessfully.
proc usb_hub_resetting_port_status stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
; 1. If the request has failed, do nothing.
        cmp     [status], 0
        jnz     .nothing
; 2. If reset signalling is still active, do nothing.
        mov     eax, [calldata]
;       movzx   ecx, [eax+usb_hub.ConfigBuffer+4]
;       dec     ecx
;       DEBUGF 1,'K : hub %x port %d ResetStatusData = %x change = %x\n',eax,ecx,[eax+usb_hub.ResetStatusData]:4,[eax+usb_hub.ResetStatusChange]:4
        test    byte [eax+usb_hub.ResetStatusData], 1 shl PORT_RESET
        jnz     .nothing
; 3. Store the current time to start reset recovery interval
; and clear 'reset signalling active' flag.
        mov     edx, [timer_ticks]
        mov     [eax+usb_hub.ResetTime], edx
        and     [eax+usb_hub.Actions], not HUB_RESET_SIGNAL
; 4. If the device has not been disconnected, set 'reset recovery active' bit.
; Otherwise, terminate reset process.
        test    byte [eax+usb_hub.ResetStatusChange], 1 shl PORT_CONNECTION
        jnz     .disconnected
        or      [eax+usb_hub.Actions], HUB_RESET_RECOVERY
.common:
; In any case, clear change of resetting status.
        lea     edx, [eax+usb_hub.ConfigBuffer]
        mov     cl, C_PORT_RESET
        call    usb_hub_clear_port_change.buffer
.nothing:
        ret
.disconnected:
        call    usb_hub_reset_aborted
        jmp     .common
endp
 
; Helper procedure for usb_hub_process_deferred. Initiates reset signalling
; on the current port (given by 1-based value [ConfigBuffer+4]).
; esi -> usb_hub, eax -> usb_controller
proc usb_hub_initiate_reset
; 1. Store hub+port data in the controller structure.
        movzx   ecx, [esi+usb_hub.ConfigBuffer+4]
        dec     ecx
        mov     [eax+usb_controller.ResettingPort], cl
        mov     [eax+usb_controller.ResettingHub], esi
; 2. Store the current time and set 'reset signalling active' flag.
        mov     eax, [timer_ticks]
        mov     [esi+usb_hub.ResetTime], eax
        and     [esi+usb_hub.Actions], not HUB_RESET_WAITING
        or      [esi+usb_hub.Actions], HUB_RESET_SIGNAL
; 3. Send request to the hub to initiate request signalling.
        lea     edx, [esi+usb_hub.ConfigBuffer]
;       DEBUGF 1,'K : [%d] hub %x port %d initiate reset\n',[timer_ticks],esi,ecx
        mov     dword [edx], 23h + \
                (USB_SET_FEATURE shl 8) + \
                (PORT_RESET shl 16)
        and     dword [edx+4], 0xFF
        stdcall usb_control_async, [esi+usb_hub.ConfigPipe], edx, 0, 0, usb_hub_reset_started, esi, 0
        test    eax, eax
        jnz     @f
        mov     eax, esi
        call    usb_hub_reset_aborted
@@:
        ret
endp
 
; This procedure is called when the request to start reset signalling initiated
; by usb_hub_initiate_reset is completed, either successfully or unsuccessfully.
proc usb_hub_reset_started stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
; If the request is successful, do nothing.
; Otherwise, clear 'reset signalling' flag and abort reset process.
        mov     eax, [calldata]
;       movzx   ecx, [eax+usb_hub.ConfigBuffer+4]
;       dec     ecx
;       DEBUGF 1,'K : [%d] hub %x port %d reset started\n',[timer_ticks],eax,ecx
        cmp     [status], 0
        jz      .nothing
        and     [eax+usb_hub.Actions], not HUB_RESET_SIGNAL
        dbgstr 'Failed to reset hub port'
        call    usb_hub_reset_aborted
.nothing:
        ret
endp
 
; This procedure is called by the protocol layer if something has failed during
; initial stages of the configuration process, so the device should be disabled
; at hub level.
proc usb_hub_disable_resetting_port
        and     [eax+usb_hub.Actions], not HUB_RESET_IN_PROGRESS
;       movzx   ecx, [eax+usb_hub.ConfigBuffer+4]
;       dec     ecx
;       DEBUGF 1,'K : [%d] hub %x port %d disable\n',[timer_ticks],eax,ecx
        lea     edx, [eax+usb_hub.ConfigBuffer]
        mov     cl, PORT_ENABLE
        jmp     usb_hub_clear_port_change.buffer
endp
 
; This procedure is called when the hub is disconnected.
proc usb_hub_disconnect
virtual at esp
                dd      ?       ; return address
.hubdata        dd      ?
end virtual
; 1. If the hub is disconnected during initial configuration,
; 1 is stored as hub data and there is nothing to do.
        mov     eax, [.hubdata]
        cmp     eax, 1
        jz      .nothing
; 2. Remove the hub from the overall list.
        mov     ecx, [eax+usb_hub.Next]
        mov     edx, [eax+usb_hub.Prev]
        mov     [ecx+usb_hub.Prev], edx
        mov     [edx+usb_hub.Next], ecx
; 3. If some child is in reset process, abort reset.
        push    esi
        mov     esi, [eax+usb_hub.Controller]
        cmp     [esi+usb_controller.ResettingHub], eax
        jnz     @f
        cmp     [esi+usb_controller.ResettingPort], -1
        jz      @f
        push    eax
        call    usb_test_pending_port
        pop     eax
@@:
        pop     esi
; 4. Loop over all children and notify other code that they were disconnected.
        push    ebx
        xor     ecx, ecx
.disconnect_children:
        mov     ebx, [eax+usb_hub.ConnectedDevicesPtr]
        mov     ebx, [ebx+ecx*4]
        test    ebx, ebx
        jz      @f
        push    eax ecx
        call    usb_device_disconnected
        pop     ecx eax
@@:
        inc     ecx
        cmp     ecx, [eax+usb_hub.NumPorts]
        jb      .disconnect_children
; 4. Free memory allocated for the hub data.
        call    free
        pop     ebx
.nothing:
        retn    4
endp

Rev 4302	Rev 4305
1	; Support for USB (non-root) hubs:	1	; Support for USB (non-root) hubs:
2	; powering up/resetting/disabling ports,	2	; powering up/resetting/disabling ports,
3	; watching for adding/removing devices.	3	; watching for adding/removing devices.
4		4
5	; =============================================================================	5	; =============================================================================
6	; ================================= Constants =================================	6	; ================================= Constants =================================
7	; =============================================================================	7	; =============================================================================
8	; Hub constants	8	; Hub constants
9	; USB hub descriptor type	9	; USB hub descriptor type
10	USB_HUB_DESCRIPTOR = 29h	10	USB_HUB_DESCRIPTOR = 29h
11		11
12	; Features for CLEAR_FEATURE commands to the hub.	12	; Features for CLEAR_FEATURE commands to the hub.
13	C_HUB_LOCAL_POWER = 0	13	C_HUB_LOCAL_POWER = 0
14	C_HUB_OVER_CURRENT = 1	14	C_HUB_OVER_CURRENT = 1
15		15
16	; Bits in result of GET_STATUS command for a port.	16	; Bits in result of GET_STATUS command for a port.
17	; Also suitable for CLEAR_FEATURE/SET_FEATURE commands, where applicable,	17	; Also suitable for CLEAR_FEATURE/SET_FEATURE commands, where applicable,
18	; except TEST/INDICATOR.	18	; except TEST/INDICATOR.
19	PORT_CONNECTION = 0	19	PORT_CONNECTION = 0
20	PORT_ENABLE = 1	20	PORT_ENABLE = 1
21	PORT_SUSPEND = 2	21	PORT_SUSPEND = 2
22	PORT_OVER_CURRENT = 3	22	PORT_OVER_CURRENT = 3
23	PORT_RESET = 4	23	PORT_RESET = 4
24	PORT_POWER = 8	24	PORT_POWER = 8
25	PORT_LOW_SPEED = 9	25	PORT_LOW_SPEED = 9
26	PORT_HIGH_SPEED = 10	26	PORT_HIGH_SPEED = 10
27	PORT_TEST_BIT = 11	27	PORT_TEST_BIT = 11
28	PORT_INDICATOR_BIT = 12	28	PORT_INDICATOR_BIT = 12
29	C_PORT_CONNECTION = 16	29	C_PORT_CONNECTION = 16
30	C_PORT_ENABLE = 17	30	C_PORT_ENABLE = 17
31	C_PORT_SUSPEND = 18	31	C_PORT_SUSPEND = 18
32	C_PORT_OVER_CURRENT = 19	32	C_PORT_OVER_CURRENT = 19
33	C_PORT_RESET = 20	33	C_PORT_RESET = 20
34	PORT_TEST_FEATURE = 21	34	PORT_TEST_FEATURE = 21
35	PORT_INDICATOR_FEATURE = 22	35	PORT_INDICATOR_FEATURE = 22
36		36
37	; Internal constants	37	; Internal constants
38	; Bits in usb_hub.Actions	38	; Bits in usb_hub.Actions
39	HUB_WAIT_POWERED = 1	39	HUB_WAIT_POWERED = 1
40	; ports were powered, wait until power is stable	40	; ports were powered, wait until power is stable
41	HUB_WAIT_CONNECT = 2	41	HUB_WAIT_CONNECT = 2
42	; some device was connected, wait initial debounce interval	42	; some device was connected, wait initial debounce interval
43	HUB_RESET_IN_PROGRESS = 4	43	HUB_RESET_IN_PROGRESS = 4
44	; reset in progress, so buffer for config requests is owned	44	; reset in progress, so buffer for config requests is owned
45	; by reset process; this includes all stages from initial disconnect test	45	; by reset process; this includes all stages from initial disconnect test
46	; to end of setting address (fail on any stage should lead to disabling port,	46	; to end of setting address (fail on any stage should lead to disabling port,
47	; which requires a config request)	47	; which requires a config request)
48	HUB_RESET_WAITING = 8	48	HUB_RESET_WAITING = 8
49	; the port is ready for reset, but another device somewhere on the bus	49	; the port is ready for reset, but another device somewhere on the bus
50	; is resetting. Implies HUB_RESET_IN_PROGRESS	50	; is resetting. Implies HUB_RESET_IN_PROGRESS
51	HUB_RESET_SIGNAL = 10h	51	HUB_RESET_SIGNAL = 10h
52	; reset signalling is active for some port in the hub	52	; reset signalling is active for some port in the hub
53	; Implies HUB_RESET_IN_PROGRESS	53	; Implies HUB_RESET_IN_PROGRESS
54	HUB_RESET_RECOVERY = 20h	54	HUB_RESET_RECOVERY = 20h
55	; reset recovery is active for some port in the hub	55	; reset recovery is active for some port in the hub
56	; Implies HUB_RESET_IN_PROGRESS	56	; Implies HUB_RESET_IN_PROGRESS
57		57
58	; Well, I think that those 5 flags WAIT_CONNECT and RESET_* require additional	58	; Well, I think that those 5 flags WAIT_CONNECT and RESET_* require additional
59	; comments. So that is the overview of what happens with a new device assuming	59	; comments. So that is the overview of what happens with a new device assuming
60	; no errors.	60	; no errors.
61	; * device is connected;	61	; * device is connected;
62	; * hub notifies us about connect event; after some processing	62	; * hub notifies us about connect event; after some processing
63	; usb_hub_port_change finally processes that event, setting the flag	63	; usb_hub_port_change finally processes that event, setting the flag
64	; HUB_WAIT_CONNECT and storing time when the device was connected;	64	; HUB_WAIT_CONNECT and storing time when the device was connected;
65	; * 100 ms delay;	65	; * 100 ms delay;
66	; * usb_hub_process_deferred clears HUB_WAIT_CONNECT,	66	; * usb_hub_process_deferred clears HUB_WAIT_CONNECT,
67	; sets HUB_RESET_IN_PROGRESS, stores the port index in ConfigBuffer and asks	67	; sets HUB_RESET_IN_PROGRESS, stores the port index in ConfigBuffer and asks
68	; the hub whether there was a disconnect event for that port during those	68	; the hub whether there was a disconnect event for that port during those
69	; 100 ms (on the hardware level notifications are obtained using polling	69	; 100 ms (on the hardware level notifications are obtained using polling
70	; with some intervals, so it is possible that the corresponding notification	70	; with some intervals, so it is possible that the corresponding notification
71	; has not arrived yet);	71	; has not arrived yet);
72	; * usb_hub_connect_port_status checks that there was no disconnect event	72	; * usb_hub_connect_port_status checks that there was no disconnect event
73	; and sets HUB_RESET_WAITING flag (HUB_RESET_IN_PROGRESS is still set,	73	; and sets HUB_RESET_WAITING flag (HUB_RESET_IN_PROGRESS is still set,
74	; ConfigBuffer still contains the port index);	74	; ConfigBuffer still contains the port index);
75	; * usb_hub_process_deferred checks whether there is another device currently	75	; * usb_hub_process_deferred checks whether there is another device currently
76	; resetting. If so, it waits until reset is done	76	; resetting. If so, it waits until reset is done
77	; (with HUB_RESET_WAITING and HUB_RESET_IN_PROGRESS bits set);	77	; (with HUB_RESET_WAITING and HUB_RESET_IN_PROGRESS bits set);
78	; * usb_hub_process_deferred clears HUB_RESET_WAITING, sets HUB_RESET_SIGNAL	78	; * usb_hub_process_deferred clears HUB_RESET_WAITING, sets HUB_RESET_SIGNAL
79	; and initiates reset signalling on the port;	79	; and initiates reset signalling on the port;
80	; * usb_hub_process_deferred checks the status every tick;	80	; * usb_hub_process_deferred checks the status every tick;
81	; when reset signalling is stopped by the hub, usb_hub_resetting_port_status	81	; when reset signalling is stopped by the hub, usb_hub_resetting_port_status
82	; callback clears HUB_RESET_SIGNAL and sets HUB_RESET_RECOVERY;	82	; callback clears HUB_RESET_SIGNAL and sets HUB_RESET_RECOVERY;
83	; * 10 ms (at least) delay;	83	; * 10 ms (at least) delay;
84	; * usb_hub_process_deferred clears HUB_RESET_RECOVERY and notifies other code	84	; * usb_hub_process_deferred clears HUB_RESET_RECOVERY and notifies other code
85	; that the new device is ready to be configured;	85	; that the new device is ready to be configured;
86	; * when it is possible to reset another device, the protocol layer	86	; * when it is possible to reset another device, the protocol layer
87	; clears HUB_RESET_IN_PROGRESS bit.	87	; clears HUB_RESET_IN_PROGRESS bit.
88		88
89	; =============================================================================	89	; =============================================================================
90	; ================================ Structures =================================	90	; ================================ Structures =================================
91	; =============================================================================	91	; =============================================================================
92	; This structure contains all used data for one hub.	92	; This structure contains all used data for one hub.
93	struct usb_hub	93	struct usb_hub
94	; All configured hubs are organized in the global usb_hub_list.	94	; All configured hubs are organized in the global usb_hub_list.
95	; Two following fields give next/prev items in that list.	95	; Two following fields give next/prev items in that list.
96	; While the hub is unconfigured, they point to usb_hub itself.	96	; While the hub is unconfigured, they point to usb_hub itself.
97	Next dd ?	97	Next dd ?
98	Prev dd ?	98	Prev dd ?
99	Controller dd ?	99	Controller dd ?
100	; Pointer to usb_controller for the bus.	100	; Pointer to usb_controller for the bus.
101	;	101	;
102	; Handles of two pipes: configuration control pipe for zero endpoint opened by	102	; Handles of two pipes: configuration control pipe for zero endpoint opened by
103	; the common code and status interrupt pipe opened by us.	103	; the common code and status interrupt pipe opened by us.
104	ConfigPipe dd ?	104	ConfigPipe dd ?
105	StatusPipe dd ?	105	StatusPipe dd ?
106	NumPorts dd ?	106	NumPorts dd ?
107	; Number of downstream ports; from 1 to 255.	107	; Number of downstream ports; from 1 to 255.
108	MaxPacketSize dd ?	108	MaxPacketSize dd ?
109	; Maximum packet size for interrupt endpoint.	109	; Maximum packet size for interrupt endpoint.
110	; Usually equals ceil((1+NumPorts)/8), but some hubs give additional bytes.	110	; Usually equals ceil((1+NumPorts)/8), but some hubs give additional bytes.
111	Actions dd ?	111	Actions dd ?
112	; Bitfield with HUB_* constants.	112	; Bitfield with HUB_* constants.
113	PoweredOnTime dd ?	113	PoweredOnTime dd ?
114	; Time (in ticks) when all downstream ports were powered up.	114	; Time (in ticks) when all downstream ports were powered up.
115	ResetTime dd ?	115	ResetTime dd ?
116	; Time (in ticks) when the current port was reset;	116	; Time (in ticks) when the current port was reset;
117	; when a port is resetting, contains the last tick of status check;	117	; when a port is resetting, contains the last tick of status check;
118	; when reset recovery for a port is active, contains the time when	118	; when reset recovery for a port is active, contains the time when
119	; reset was completed.	119	; reset was completed.
120	;	120	;
121	; There are two possible reasons for configuration requests:	121	; There are two possible reasons for configuration requests:
122	; synchronous, when certain time is passed after something,	122	; synchronous, when certain time is passed after something,
123	; and asynchronous, when the hub is notifying about some change and	123	; and asynchronous, when the hub is notifying about some change and
124	; config request needs to be issued in order to query details.	124	; config request needs to be issued in order to query details.
125	; Use two different buffers to avoid unnecessary dependencies.	125	; Use two different buffers to avoid unnecessary dependencies.
126	ConfigBuffer rb 8	126	ConfigBuffer rb 8
127	; Buffer for configuration requests for synchronous events.	127	; Buffer for configuration requests for synchronous events.
128	ChangeConfigBuffer rb 8	128	ChangeConfigBuffer rb 8
129	; Buffer for configuration requests for status changes.	129	; Buffer for configuration requests for status changes.
130	AccStatusChange db ?	130	AccStatusChange db ?
131	; Accumulated status change. See 11.12.3 of USB2 spec or comments in code.	131	; Accumulated status change. See 11.12.3 of USB2 spec or comments in code.
132	HubCharacteristics dw ?	132	HubCharacteristics dw ?
133	; Copy of usb_hub_descr.wHubCharacteristics.	133	; Copy of usb_hub_descr.wHubCharacteristics.
134	PowerOnInterval db ?	134	PowerOnInterval db ?
135	; Copy of usb_hub_descr.bPwrOn2PwrGood.	135	; Copy of usb_hub_descr.bPwrOn2PwrGood.
136	;	136	;
137	; Two following fields are written at once by GET_STATUS request	137	; Two following fields are written at once by GET_STATUS request
138	; and must remain in this order.	138	; and must remain in this order.
139	StatusData dw ?	139	StatusData dw ?
140	; Bitfield with 1 shl PORT_* indicating status of the current port.	140	; Bitfield with 1 shl PORT_* indicating status of the current port.
141	StatusChange dw ?	141	StatusChange dw ?
142	; Bitfield with 1 shl PORT_* indicating change in status of the current port.	142	; Bitfield with 1 shl PORT_* indicating change in status of the current port.
143	; Two following fields are written at once by GET_STATUS request	143	; Two following fields are written at once by GET_STATUS request
144	; and must remain in this order.	144	; and must remain in this order.
145	; The meaning is the same as of StatusData/StatusChange; two following fields	145	; The meaning is the same as of StatusData/StatusChange; two following fields
146	; are used by the synchronous requests to avoid unnecessary interactions with	146	; are used by the synchronous requests to avoid unnecessary interactions with
147	; the asynchronous handler.	147	; the asynchronous handler.
148	ResetStatusData dw ?	148	ResetStatusData dw ?
149	ResetStatusChange dw ?	149	ResetStatusChange dw ?
150	StatusChangePtr dd ?	150	StatusChangePtr dd ?
151	; Pointer to StatusChangeBuf.	151	; Pointer to StatusChangeBuf.
152	ConnectedDevicesPtr dd ?	152	ConnectedDevicesPtr dd ?
153	; Pointer to ConnectedDevices.	153	; Pointer to ConnectedDevices.
154	ConnectedTimePtr dd ?	154	ConnectedTimePtr dd ?
155	; Pointer to ConnectedTime.	155	; Pointer to ConnectedTime.
156	;	156	;
157	; Variable-length parts:	157	; Variable-length parts:
158	; DeviceRemovable rb (NumPorts+8)/8	158	; DeviceRemovable rb (NumPorts+8)/8
159	; Bit i+1 = device at port i (zero-based) is non-removable.	159	; Bit i+1 = device at port i (zero-based) is non-removable.
160	; StatusChangeBuf rb (NumPorts+8)/8	160	; StatusChangeBuf rb (NumPorts+8)/8
161	; Buffer for status interrupt pipe. Bit 0 = hub status change,	161	; Buffer for status interrupt pipe. Bit 0 = hub status change,
162	; other bits = status change of the corresponding ports.	162	; other bits = status change of the corresponding ports.
163	; ConnectedDevices rd NumPorts	163	; ConnectedDevices rd NumPorts
164	; Pointers to config pipes for connected devices or zero if no device connected.	164	; Pointers to config pipes for connected devices or zero if no device connected.
165	; ConnectedTime rd NumPorts	165	; ConnectedTime rd NumPorts
166	; For initial debounce interval:	166	; For initial debounce interval:
167	; time (in ticks) when a device was connected at that port.	167	; time (in ticks) when a device was connected at that port.
168	; Normally: -1	168	; Normally: -1
169	ends	169	ends
170		170
171	; Hub descriptor.	171	; Hub descriptor.
172	struct usb_hub_descr usb_descr	172	struct usb_hub_descr usb_descr
173	bNbrPorts db ?	173	bNbrPorts db ?
174	; Number of downstream ports.	174	; Number of downstream ports.
175	wHubCharacteristics dw ?	175	wHubCharacteristics dw ?
176	; Bit 0: 0 = all ports are powered at once, 1 = individual port power switching	176	; Bit 0: 0 = all ports are powered at once, 1 = individual port power switching
177	; Bit 1: reserved, must be zero	177	; Bit 1: reserved, must be zero
178	; Bit 2: 1 = the hub is part of a compound device	178	; Bit 2: 1 = the hub is part of a compound device
179	; Bits 3-4: 00 = global overcurrent protection,	179	; Bits 3-4: 00 = global overcurrent protection,
180	; 01 = individual port overcurrent protection,	180	; 01 = individual port overcurrent protection,
181	; 1x = no overcurrent protection	181	; 1x = no overcurrent protection
182	; Bits 5-6: Transaction Translator Think Time, 8*(value+1) full-speed bit times	182	; Bits 5-6: Transaction Translator Think Time, 8*(value+1) full-speed bit times
183	; Bit 7: 1 = port indicators supported	183	; Bit 7: 1 = port indicators supported
184	; Other bits are reserved.	184	; Other bits are reserved.
185	bPwrOn2PwrGood db ?	185	bPwrOn2PwrGood db ?
186	; Time in 2ms intervals between powering up a port and a port becoming ready.	186	; Time in 2ms intervals between powering up a port and a port becoming ready.
187	bHubContrCurrent db ?	187	bHubContrCurrent db ?
188	; Maximum current requirements of the Hub Controller electronics in mA.	188	; Maximum current requirements of the Hub Controller electronics in mA.
189	; DeviceRemovable - variable length	189	; DeviceRemovable - variable length
190	; Bit 0 is reserved, bit i+1 = device at port i is non-removable.	190	; Bit 0 is reserved, bit i+1 = device at port i is non-removable.
191	; PortPwrCtrlMask - variable length	191	; PortPwrCtrlMask - variable length
192	; Obsolete, exists for compatibility. We ignore it.	192	; Obsolete, exists for compatibility. We ignore it.
193	ends	193	ends
194		194
195	iglobal	195	iglobal
196	align 4	196	align 4
197	; Implementation of struct USBFUNC for hubs.	197	; Implementation of struct USBFUNC for hubs.
198	usb_hub_callbacks:	198	usb_hub_callbacks:
199	dd usb_hub_callbacks_end - usb_hub_callbacks	199	dd usb_hub_callbacks_end - usb_hub_callbacks
200	dd usb_hub_init	200	dd usb_hub_init
201	dd usb_hub_disconnect	201	dd usb_hub_disconnect
202	usb_hub_callbacks_end:	202	usb_hub_callbacks_end:
203	usb_hub_pseudosrv dd usb_hub_callbacks	203	usb_hub_pseudosrv dd usb_hub_callbacks
204	endg	204	endg
205		205
206	; This procedure is called when new hub is detected.	206	; This procedure is called when new hub is detected.
207	; It initializes the device.	207	; It initializes the device.
208	; Technically, initialization implies sending several USB queries,	208	; Technically, initialization implies sending several USB queries,
209	; so it is split in several procedures. The first is usb_hub_init,	209	; so it is split in several procedures. The first is usb_hub_init,
210	; other are callbacks which will be called at some time in the future,	210	; other are callbacks which will be called at some time in the future,
211	; when the device will respond.	211	; when the device will respond.
212	; edx = usb_interface_descr, ecx = length rest	212	; edx = usb_interface_descr, ecx = length rest
213	proc usb_hub_init	213	proc usb_hub_init
214	push ebx esi ; save used registers to be stdcall	214	push ebx esi ; save used registers to be stdcall
215	virtual at esp	215	virtual at esp
216	rd 2 ; saved registers	216	rd 2 ; saved registers
217	dd ? ; return address	217	dd ? ; return address
218	.pipe dd ? ; handle of the config pipe	218	.pipe dd ? ; handle of the config pipe
219	.config dd ? ; pointer to usb_config_descr	219	.config dd ? ; pointer to usb_config_descr
220	.interface dd ? ; pointer to usb_interface_descr	220	.interface dd ? ; pointer to usb_interface_descr
221	end virtual	221	end virtual
222	; 1. Check that the maximal nesting is not exceeded:	222	; 1. Check that the maximal nesting is not exceeded:
223	; 5 non-root hubs is the maximum according to the spec.	223	; 5 non-root hubs is the maximum according to the spec.
224	mov ebx, [.pipe]	224	mov ebx, [.pipe]
225	movi ecx, 5	225	push 5
226	mov eax, ebx	226	mov eax, ebx
227	.count_parents:	227	.count_parents:
228	mov eax, [eax+usb_pipe.DeviceData]	228	mov eax, [eax+usb_pipe.DeviceData]
229	mov eax, [eax+usb_device_data.Hub]	229	mov eax, [eax+usb_device_data.Hub]
230	test eax, eax	230	test eax, eax
231	jz .depth_ok	231	jz .depth_ok
232	mov eax, [eax+usb_hub.ConfigPipe]	232	mov eax, [eax+usb_hub.ConfigPipe]
233	dec ecx	233	dec dword [esp]
234	jnz .count_parents	234	jnz .count_parents
-		235	pop eax
235	dbgstr 'Hub chain is too long'	236	dbgstr 'Hub chain is too long'
236	jmp .return0	237	jmp .return0
237	.depth_ok:	238	.depth_ok:
-		239	pop eax
238	; Hubs use one IN interrupt endpoint for polling the device	240	; Hubs use one IN interrupt endpoint for polling the device
239	; 2. Locate the descriptor of the interrupt endpoint.	241	; 2. Locate the descriptor of the interrupt endpoint.
240	; Loop over all descriptors owned by this interface.	242	; Loop over all descriptors owned by this interface.
241	.lookep:	243	.lookep:
242	; 2a. Skip the current descriptor.	244	; 2a. Skip the current descriptor.
243	movzx eax, [edx+usb_descr.bLength]	245	movzx eax, [edx+usb_descr.bLength]
244	add edx, eax	246	add edx, eax
245	sub ecx, eax	247	sub ecx, eax
246	jb .errorep	248	jb .errorep
247	; 2b. Length of data left must be at least sizeof.usb_endpoint_descr.	249	; 2b. Length of data left must be at least sizeof.usb_endpoint_descr.
248	cmp ecx, sizeof.usb_endpoint_descr	250	cmp ecx, sizeof.usb_endpoint_descr
249	jb .errorep	251	jb .errorep
250	; 2c. If we have found another interface descriptor but not found our endpoint,	252	; 2c. If we have found another interface descriptor but not found our endpoint,
251	; this is an error: all subsequent descriptors belong to that interface	253	; this is an error: all subsequent descriptors belong to that interface
252	; (or further interfaces).	254	; (or further interfaces).
253	cmp [edx+usb_endpoint_descr.bDescriptorType], USB_INTERFACE_DESCR	255	cmp [edx+usb_endpoint_descr.bDescriptorType], USB_INTERFACE_DESCR
254	jz .errorep	256	jz .errorep
255	; 2d. Ignore all interface-related descriptors except endpoint descriptor.	257	; 2d. Ignore all interface-related descriptors except endpoint descriptor.
256	cmp [edx+usb_endpoint_descr.bDescriptorType], USB_ENDPOINT_DESCR	258	cmp [edx+usb_endpoint_descr.bDescriptorType], USB_ENDPOINT_DESCR
257	jnz .lookep	259	jnz .lookep
258	; 2e. Length of endpoint descriptor must be at least sizeof.usb_endpoint_descr.	260	; 2e. Length of endpoint descriptor must be at least sizeof.usb_endpoint_descr.
259	cmp [edx+usb_endpoint_descr.bLength], sizeof.usb_endpoint_descr	261	cmp [edx+usb_endpoint_descr.bLength], sizeof.usb_endpoint_descr
260	jb .errorep	262	jb .errorep
261	; 2f. Ignore all endpoints except for INTERRUPT IN.	263	; 2f. Ignore all endpoints except for INTERRUPT IN.
262	cmp [edx+usb_endpoint_descr.bEndpointAddress], 0	264	cmp [edx+usb_endpoint_descr.bEndpointAddress], 0
263	jge .lookep	265	jge .lookep
264	mov al, [edx+usb_endpoint_descr.bmAttributes]	266	mov al, [edx+usb_endpoint_descr.bmAttributes]
265	and al, 3	267	and al, 3
266	cmp al, INTERRUPT_PIPE	268	cmp al, INTERRUPT_PIPE
267	jnz .lookep	269	jnz .lookep
268	; We have located the descriptor for INTERRUPT IN endpoint,	270	; We have located the descriptor for INTERRUPT IN endpoint,
269	; the pointer is in edx.	271	; the pointer is in edx.
270	; 3. Allocate memory for the hub descriptor.	272	; 3. Allocate memory for the hub descriptor.
271	; Maximum length (assuming 255 downstream ports) is 40 bytes.	273	; Maximum length (assuming 255 downstream ports) is 40 bytes.
272	; Allocate 4 extra bytes to keep wMaxPacketSize.	274	; Allocate 4 extra bytes to keep wMaxPacketSize.
273	; 3a. Save registers.	275	; 3a. Save registers.
274	push edx	276	push edx
275	; 3b. Call the allocator.	277	; 3b. Call the allocator.
276	movi eax, 44	278	movi eax, 44
277	call malloc	279	call malloc
278	; 3c. Restore registers.	280	; 3c. Restore registers.
279	pop ecx	281	pop ecx
280	; 3d. If failed, say something to the debug board and return error.	282	; 3d. If failed, say something to the debug board and return error.
281	test eax, eax	283	test eax, eax
282	jz .nomemory	284	jz .nomemory
283	; 3e. Store the pointer in esi. xchg eax,r32 is one byte shorter than mov.	285	; 3e. Store the pointer in esi. xchg eax,r32 is one byte shorter than mov.
284	xchg esi, eax	286	xchg esi, eax
285	; 4. Open a pipe for the status endpoint with descriptor found in step 1.	287	; 4. Open a pipe for the status endpoint with descriptor found in step 1.
286	movzx eax, [ecx+usb_endpoint_descr.bEndpointAddress]	288	movzx eax, [ecx+usb_endpoint_descr.bEndpointAddress]
287	movzx edx, [ecx+usb_endpoint_descr.bInterval]	289	movzx edx, [ecx+usb_endpoint_descr.bInterval]
288	movzx ecx, [ecx+usb_endpoint_descr.wMaxPacketSize]	290	movzx ecx, [ecx+usb_endpoint_descr.wMaxPacketSize]
289	test ecx, (1 shl 11) - 1	291	test ecx, (1 shl 11) - 1
290	jz .free	292	jz .free
291	push ecx	293	push ecx
292	stdcall usb_open_pipe, ebx, eax, ecx, INTERRUPT_PIPE, edx	294	stdcall usb_open_pipe, ebx, eax, ecx, INTERRUPT_PIPE, edx
293	pop ecx	295	pop ecx
294	; If failed, free the memory allocated in step 3,	296	; If failed, free the memory allocated in step 3,
295	; say something to the debug board and return error.	297	; say something to the debug board and return error.
296	test eax, eax	298	test eax, eax
297	jz .free	299	jz .free
298	; 5. Send control query for the hub descriptor,	300	; 5. Send control query for the hub descriptor,
299	; pass status pipe as a callback parameter,	301	; pass status pipe as a callback parameter,
300	; allow short packets.	302	; allow short packets.
301	and ecx, (1 shl 11) - 1	303	and ecx, (1 shl 11) - 1
302	mov [esi+40], ecx	304	mov [esi+40], ecx
303	mov dword [esi], 0xA0 + \ ; class-specific request	305	mov dword [esi], 0xA0 + \ ; class-specific request
304	(USB_GET_DESCRIPTOR shl 8) + \	306	(USB_GET_DESCRIPTOR shl 8) + \
305	(0 shl 16) + \ ; descriptor index 0	307	(0 shl 16) + \ ; descriptor index 0
306	(USB_HUB_DESCRIPTOR shl 24)	308	(USB_HUB_DESCRIPTOR shl 24)
307	mov dword [esi+4], 40 shl 16	309	mov dword [esi+4], 40 shl 16
308	stdcall usb_control_async, ebx, esi, esi, 40, usb_hub_got_config, eax, 1	310	stdcall usb_control_async, ebx, esi, esi, 40, usb_hub_got_config, eax, 1
309	; 6. If failed, free the memory allocated in step 3,	311	; 6. If failed, free the memory allocated in step 3,
310	; say something to the debug board and return error.	312	; say something to the debug board and return error.
311	test eax, eax	313	test eax, eax
312	jz .free	314	jz .free
313	; Otherwise, return 1. usb_hub_got_config will overwrite it later.	315	; Otherwise, return 1. usb_hub_got_config will overwrite it later.
314	xor eax, eax	316	xor eax, eax
315	inc eax	317	inc eax
316	jmp .nothing	318	jmp .nothing
317	.free:	319	.free:
318	xchg eax, esi	320	xchg eax, esi
319	call free	321	call free
320	jmp .return0	322	jmp .return0
321	.errorep:	323	.errorep:
322	dbgstr 'Invalid config descriptor for a hub'	324	dbgstr 'Invalid config descriptor for a hub'
323	jmp .return0	325	jmp .return0
324	.nomemory:	326	.nomemory:
325	dbgstr 'No memory for USB hub data'	327	dbgstr 'No memory for USB hub data'
326	.return0:	328	.return0:
327	xor eax, eax	329	xor eax, eax
328	.nothing:	330	.nothing:
329	pop esi ebx ; restore used registers to be stdcall	331	pop esi ebx ; restore used registers to be stdcall
330	retn 12	332	retn 12
331	endp	333	endp
332		334
333	; This procedure is called when the request for the hub descriptor initiated	335	; This procedure is called when the request for the hub descriptor initiated
334	; by usb_hub_init is finished, either successfully or unsuccessfully.	336	; by usb_hub_init is finished, either successfully or unsuccessfully.
335	proc usb_hub_got_config stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword	337	proc usb_hub_got_config stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
336	push ebx ; save used registers to be stdcall	338	push ebx ; save used registers to be stdcall
337	; 1. If failed, say something to the debug board, free the buffer	339	; 1. If failed, say something to the debug board, free the buffer
338	; and stop the initialization.	340	; and stop the initialization.
339	cmp [status], 0	341	cmp [status], 0
340	jnz .invalid	342	jnz .invalid
341	; 2. The length must be at least sizeof.usb_hub_descr.	343	; 2. The length must be at least sizeof.usb_hub_descr.
342	; Note that [length] includes 8 bytes of setup packet.	344	; Note that [length] includes 8 bytes of setup packet.
343	cmp [length], 8 + sizeof.usb_hub_descr	345	cmp [length], 8 + sizeof.usb_hub_descr
344	jb .invalid	346	jb .invalid
345	; 3. Sanity checks for the hub descriptor.	347	; 3. Sanity checks for the hub descriptor.
346	mov eax, [buffer]	348	mov eax, [buffer]
347	if USB_DUMP_DESCRIPTORS	349	if USB_DUMP_DESCRIPTORS
348	mov ecx, [length]	350	mov ecx, [length]
349	sub ecx, 8	351	sub ecx, 8
350	DEBUGF 1,'K : hub config:'	352	DEBUGF 1,'K : hub config:'
351	push eax	353	push eax
352	@@:	354	@@:
353	DEBUGF 1,' %x',[eax]:2	355	DEBUGF 1,' %x',[eax]:2
354	inc eax	356	inc eax
355	dec ecx	357	dec ecx
356	jnz @b	358	jnz @b
357	DEBUGF 1,'\n'	359	DEBUGF 1,'\n'
358	pop eax	360	pop eax
359	end if	361	end if
360	cmp [eax+usb_hub_descr.bLength], sizeof.usb_hub_descr	362	cmp [eax+usb_hub_descr.bLength], sizeof.usb_hub_descr
361	jb .invalid	363	jb .invalid
362	cmp [eax+usb_hub_descr.bDescriptorType], USB_HUB_DESCRIPTOR	364	cmp [eax+usb_hub_descr.bDescriptorType], USB_HUB_DESCRIPTOR
363	jnz .invalid	365	jnz .invalid
364	movzx ecx, [eax+usb_hub_descr.bNbrPorts]	366	movzx ecx, [eax+usb_hub_descr.bNbrPorts]
365	test ecx, ecx	367	test ecx, ecx
366	jz .invalid	368	jz .invalid
367	; 4. We use sizeof.usb_hub_descr bytes plus DeviceRemovable info;	369	; 4. We use sizeof.usb_hub_descr bytes plus DeviceRemovable info;
368	; size of DeviceRemovable is (NumPorts+1) bits, this gives	370	; size of DeviceRemovable is (NumPorts+1) bits, this gives
369	; floor(NumPorts/8)+1 bytes. Check that all data are present in the	371	; floor(NumPorts/8)+1 bytes. Check that all data are present in the
370	; descriptor and were successfully read.	372	; descriptor and were successfully read.
371	mov edx, ecx	373	mov edx, ecx
372	shr edx, 3	374	shr edx, 3
373	add edx, sizeof.usb_hub_descr + 1	375	add edx, sizeof.usb_hub_descr + 1
374	cmp [eax+usb_hub_descr.bLength], dl	376	cmp [eax+usb_hub_descr.bLength], dl
375	jb .invalid	377	jb .invalid
376	sub [length], 8	378	sub [length], 8
377	cmp [length], edx	379	cmp [length], edx
378	jb .invalid	380	jb .invalid
379	; 5. Allocate the memory for usb_hub structure.	381	; 5. Allocate the memory for usb_hub structure.
380	; Total size of variable-length data is ALIGN_UP(floor(NumPorts/8)+1+MaxPacketSize,4)+8*NumPorts.	382	; Total size of variable-length data is ALIGN_UP(floor(NumPorts/8)+1+MaxPacketSize,4)+8*NumPorts.
381	add edx, [eax+40]	383	add edx, [eax+40]
382	add edx, sizeof.usb_hub - sizeof.usb_hub_descr + 3	384	add edx, sizeof.usb_hub - sizeof.usb_hub_descr + 3
383	and edx, not 3	385	and edx, not 3
384	lea eax, [edx+ecx*8]	386	lea eax, [edx+ecx*8]
385	push ecx edx	387	push ecx edx
386	call malloc	388	call malloc
387	pop edx ecx	389	pop edx ecx
388	test eax, eax	390	test eax, eax
389	jz .nomemory	391	jz .nomemory
390	xchg eax, ebx	392	xchg eax, ebx
391	; 6. Fill usb_hub structure.	393	; 6. Fill usb_hub structure.
392	mov [ebx+usb_hub.NumPorts], ecx	394	mov [ebx+usb_hub.NumPorts], ecx
393	add edx, ebx	395	add edx, ebx
394	mov [ebx+usb_hub.ConnectedDevicesPtr], edx	396	mov [ebx+usb_hub.ConnectedDevicesPtr], edx
395	mov eax, [pipe]	397	mov eax, [pipe]
396	mov [ebx+usb_hub.ConfigPipe], eax	398	mov [ebx+usb_hub.ConfigPipe], eax
397	mov edx, [eax+usb_pipe.Controller]	399	mov edx, [eax+usb_pipe.Controller]
398	mov [ebx+usb_hub.Controller], edx	400	mov [ebx+usb_hub.Controller], edx
399	mov eax, [calldata]	401	mov eax, [calldata]
400	mov [ebx+usb_hub.StatusPipe], eax	402	mov [ebx+usb_hub.StatusPipe], eax
401	push esi edi	403	push esi edi
402	mov esi, [buffer]	404	mov esi, [buffer]
403	mov eax, [esi+40]	405	mov eax, [esi+40]
404	mov [ebx+usb_hub.MaxPacketSize], eax	406	mov [ebx+usb_hub.MaxPacketSize], eax
405	; The following commands load bNbrPorts, wHubCharacteristics, bPwrOn2PwrGood.	407	; The following commands load bNbrPorts, wHubCharacteristics, bPwrOn2PwrGood.
406	mov edx, dword [esi+usb_hub_descr.bNbrPorts]	408	mov edx, dword [esi+usb_hub_descr.bNbrPorts]
407	mov dl, 0	409	mov dl, 0
408	; The following command zeroes AccStatusChange and stores	410	; The following command zeroes AccStatusChange and stores
409	; HubCharacteristics and PowerOnInterval.	411	; HubCharacteristics and PowerOnInterval.
410	mov dword [ebx+usb_hub.AccStatusChange], edx	412	mov dword [ebx+usb_hub.AccStatusChange], edx
411	xor eax, eax	413	xor eax, eax
412	mov [ebx+usb_hub.Actions], eax	414	mov [ebx+usb_hub.Actions], eax
413	; Copy DeviceRemovable data.	415	; Copy DeviceRemovable data.
414	lea edi, [ebx+sizeof.usb_hub]	416	lea edi, [ebx+sizeof.usb_hub]
415	add esi, sizeof.usb_hub_descr	417	add esi, sizeof.usb_hub_descr
416	mov edx, ecx	418	mov edx, ecx
417	shr ecx, 3	419	shr ecx, 3
418	inc ecx	420	inc ecx
419	rep movsb	421	rep movsb
420	mov [ebx+usb_hub.StatusChangePtr], edi	422	mov [ebx+usb_hub.StatusChangePtr], edi
421	; Zero ConnectedDevices.	423	; Zero ConnectedDevices.
422	mov edi, [ebx+usb_hub.ConnectedDevicesPtr]	424	mov edi, [ebx+usb_hub.ConnectedDevicesPtr]
423	mov ecx, edx	425	mov ecx, edx
424	rep stosd	426	rep stosd
425	mov [ebx+usb_hub.ConnectedTimePtr], edi	427	mov [ebx+usb_hub.ConnectedTimePtr], edi
426	; Set ConnectedTime to -1.	428	; Set ConnectedTime to -1.
427	dec eax	429	dec eax
428	mov ecx, edx	430	mov ecx, edx
429	rep stosd	431	rep stosd
430	pop edi esi	432	pop edi esi
431	; 7. Replace value of 1 returned from usb_hub_init to the real value.	433	; 7. Replace value of 1 returned from usb_hub_init to the real value.
432	; Note: hubs are part of the core USB code, so this code can work with	434	; Note: hubs are part of the core USB code, so this code can work with
433	; internals of other parts. Another way, the only possible one for external	435	; internals of other parts. Another way, the only possible one for external
434	; drivers, is to use two memory allocations: one (returned from AddDevice and	436	; drivers, is to use two memory allocations: one (returned from AddDevice and
435	; fixed after that) for pointer, another for real data. That would work also,	437	; fixed after that) for pointer, another for real data. That would work also,
436	; but wastes one allocation.	438	; but wastes one allocation.
437	mov eax, [pipe]	439	mov eax, [pipe]
438	mov eax, [eax+usb_pipe.DeviceData]	440	mov eax, [eax+usb_pipe.DeviceData]
439	add eax, [eax+usb_device_data.Interfaces]	441	add eax, [eax+usb_device_data.Interfaces]
440	.scan:	442	.scan:
441	cmp [eax+usb_interface_data.DriverData], 1	443	cmp [eax+usb_interface_data.DriverData], 1
442	jnz @f	444	jnz @f
443	cmp [eax+usb_interface_data.DriverFunc], usb_hub_pseudosrv - USBSRV.usb_func	445	cmp [eax+usb_interface_data.DriverFunc], usb_hub_pseudosrv - USBSRV.usb_func
444	jz .scan_found	446	jz .scan_found
445	@@:	447	@@:
446	add eax, sizeof.usb_interface_data	448	add eax, sizeof.usb_interface_data
447	jmp .scan	449	jmp .scan
448	.scan_found:	450	.scan_found:
449	mov [eax+usb_interface_data.DriverData], ebx	451	mov [eax+usb_interface_data.DriverData], ebx
450	; 8. Insert the hub structure to the tail of the overall list of all hubs.	452	; 8. Insert the hub structure to the tail of the overall list of all hubs.
451	mov ecx, usb_hubs_list	453	mov ecx, usb_hubs_list
452	mov edx, [ecx+usb_hub.Prev]	454	mov edx, [ecx+usb_hub.Prev]
453	mov [ecx+usb_hub.Prev], ebx	455	mov [ecx+usb_hub.Prev], ebx
454	mov [edx+usb_hub.Next], ebx	456	mov [edx+usb_hub.Next], ebx
455	mov [ebx+usb_hub.Prev], edx	457	mov [ebx+usb_hub.Prev], edx
456	mov [ebx+usb_hub.Next], ecx	458	mov [ebx+usb_hub.Next], ecx
457	; 9. Start powering up all ports.	459	; 9. Start powering up all ports.
458	DEBUGF 1,'K : found hub with %d ports\n',[ebx+usb_hub.NumPorts]	460	DEBUGF 1,'K : found hub with %d ports\n',[ebx+usb_hub.NumPorts]
459	lea eax, [ebx+usb_hub.ConfigBuffer]	461	lea eax, [ebx+usb_hub.ConfigBuffer]
460	xor ecx, ecx	462	xor ecx, ecx
461	mov dword [eax], 23h + \ ; class-specific request to hub port	463	mov dword [eax], 23h + \ ; class-specific request to hub port
462	(USB_SET_FEATURE shl 8) + \	464	(USB_SET_FEATURE shl 8) + \
463	(PORT_POWER shl 16)	465	(PORT_POWER shl 16)
464	mov edx, [ebx+usb_hub.NumPorts]	466	mov edx, [ebx+usb_hub.NumPorts]
465	mov dword [eax+4], edx	467	mov dword [eax+4], edx
466	stdcall usb_control_async, [ebx+usb_hub.ConfigPipe], eax, ecx, ecx, usb_hub_port_powered, ebx, ecx	468	stdcall usb_control_async, [ebx+usb_hub.ConfigPipe], eax, ecx, ecx, usb_hub_port_powered, ebx, ecx
467	.freebuf:	469	.freebuf:
468	; 10. Free the buffer for hub descriptor and return.	470	; 10. Free the buffer for hub descriptor and return.
469	mov eax, [buffer]	471	mov eax, [buffer]
470	call free	472	call free
471	pop ebx ; restore used registers to be stdcall	473	pop ebx ; restore used registers to be stdcall
472	ret	474	ret
473	.nomemory:	475	.nomemory:
474	dbgstr 'No memory for USB hub data'	476	dbgstr 'No memory for USB hub data'
475	jmp .freebuf	477	jmp .freebuf
476	.invalid:	478	.invalid:
477	dbgstr 'Invalid hub descriptor'	479	dbgstr 'Invalid hub descriptor'
478	jmp .freebuf	480	jmp .freebuf
479	endp	481	endp
480		482
481	; This procedure is called when the request to power up some port is completed,	483	; This procedure is called when the request to power up some port is completed,
482	; either successfully or unsuccessfully.	484	; either successfully or unsuccessfully.
483	proc usb_hub_port_powered stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword	485	proc usb_hub_port_powered stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
484	; 1. Check whether the operation was successful.	486	; 1. Check whether the operation was successful.
485	; If not, say something to the debug board and ssstop the initialization.	487	; If not, say something to the debug board and ssstop the initialization.
486	cmp [status], 0	488	cmp [status], 0
487	jnz .invalid	489	jnz .invalid
488	; 2. Check whether all ports were powered.	490	; 2. Check whether all ports were powered.
489	; If so, go to 4. Otherwise, proceed to 3.	491	; If so, go to 4. Otherwise, proceed to 3.
490	mov eax, [calldata]	492	mov eax, [calldata]
491	dec dword [eax+usb_hub.ConfigBuffer+4]	493	dec dword [eax+usb_hub.ConfigBuffer+4]
492	jz .done	494	jz .done
493	; 3. Power up the next port and return.	495	; 3. Power up the next port and return.
494	lea edx, [eax+usb_hub.ConfigBuffer]	496	lea edx, [eax+usb_hub.ConfigBuffer]
495	xor ecx, ecx	497	xor ecx, ecx
496	stdcall usb_control_async, [eax+usb_hub.ConfigPipe], edx, ecx, ecx, usb_hub_port_powered, eax, ecx	498	stdcall usb_control_async, [eax+usb_hub.ConfigPipe], edx, ecx, ecx, usb_hub_port_powered, eax, ecx
497	.nothing:	499	.nothing:
498	ret	500	ret

Subversion Repositories Kolibri OS

(root)/kernel/trunk/bus/usb/hub.inc – Rev 4302 → 4305