WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/bus/usb/protocol.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2013-2014. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 5177 $
 
 
; Implementation of the USB protocol for device enumeration.
; Manage a USB device when it becomes ready for USB commands:
; configure, enumerate, load the corresponding driver(s),
; pass device information to the driver.
 
; =============================================================================
; ================================= Constants =================================
; =============================================================================
; USB standard request codes
USB_GET_STATUS        = 0
USB_CLEAR_FEATURE     = 1
USB_SET_FEATURE       = 3
USB_SET_ADDRESS       = 5
USB_GET_DESCRIPTOR    = 6
USB_SET_DESCRIPTOR    = 7
USB_GET_CONFIGURATION = 8
USB_SET_CONFIGURATION = 9
USB_GET_INTERFACE     = 10
USB_SET_INTERFACE     = 11
USB_SYNCH_FRAME       = 12
 
; USB standard descriptor types
USB_DEVICE_DESCR             = 1
USB_CONFIG_DESCR             = 2
USB_STRING_DESCR             = 3
USB_INTERFACE_DESCR          = 4
USB_ENDPOINT_DESCR           = 5
USB_DEVICE_QUALIFIER_DESCR   = 6
USB_OTHER_SPEED_CONFIG_DESCR = 7
USB_INTERFACE_POWER_DESCR    = 8
 
; Compile-time setting. If set, the code will dump all descriptors as they are
; read to the debug board.
USB_DUMP_DESCRIPTORS = 1
 
; According to the USB specification (9.2.6.3),
; any device must response to SET_ADDRESS in 50 ms, or 5 timer ticks.
; Of course, our world is far from ideal.
; I have seen devices that just NAK everything when being reset from working
; state, but start to work after second reset.
; Our strategy is as follows: give 2 seconds for the first attempt,
; this should be enough for normal devices and not too long to detect buggy ones.
; If the device continues NAKing, reset it and retry several times,
; doubling the interval: 2s -> 4s -> 8s -> 16s. Give up after that.
; Numbers are quite arbitrary.
TIMEOUT_SET_ADDRESS_INITIAL = 200
TIMEOUT_SET_ADDRESS_LAST    = 1600
 
; =============================================================================
; ================================ Structures =================================
; =============================================================================
; USB descriptors. See USB specification for detailed explanations.
; First two bytes of every descriptor have the same meaning.
struct usb_descr
bLength                 db      ?
; Size of this descriptor in bytes
bDescriptorType         db      ?
; One of USB_*_DESCR constants.
ends
 
; USB device descriptor
struct usb_device_descr usb_descr
bcdUSB                  dw      ?
; USB Specification Release number in BCD, e.g. 110h = USB 1.1
bDeviceClass            db      ?
; USB Device Class Code
bDeviceSubClass         db      ?
; USB Device Subclass Code
bDeviceProtocol         db      ?
; USB Device Protocol Code
bMaxPacketSize0         db      ?
; Maximum packet size for zero endpoint
idVendor                dw      ?
; Vendor ID
idProduct               dw      ?
; Product ID
bcdDevice               dw      ?
; Device release number in BCD
iManufacturer           db      ?
; Index of string descriptor describing manufacturer
iProduct                db      ?
; Index of string descriptor describing product
iSerialNumber           db      ?
; Index of string descriptor describing serial number
bNumConfigurations      db      ?
; Number of possible configurations
ends
 
; USB configuration descriptor
struct usb_config_descr usb_descr
wTotalLength            dw      ?
; Total length of data returned for this configuration
bNumInterfaces          db      ?
; Number of interfaces in this configuration
bConfigurationValue     db      ?
; Value for SET_CONFIGURATION control request
iConfiguration          db      ?
; Index of string descriptor describing this configuration
bmAttributes            db      ?
; Bit 6 is SelfPowered, bit 5 is RemoteWakeupSupported,
; bit 7 must be 1, other bits must be 0
bMaxPower               db      ?
; Maximum power consumption from the bus in 2mA units
ends
 
; USB interface descriptor
struct usb_interface_descr usb_descr
; The following two fields work in pair. Sometimes one interface can work
; in different modes; e.g. videostream from web-cameras requires different
; bandwidth depending on resolution/quality/compression settings.
; Each mode of each interface has its own descriptor with its own endpoints
; following; all descriptors for one interface have the same bInterfaceNumber,
; and different bAlternateSetting.
; By default, any interface operates in mode with bAlternateSetting = 0.
; Often this is the only mode. If there are another modes, the active mode
; is selected by SET_INTERFACE(bAlternateSetting) control request.
bInterfaceNumber        db      ?
bAlternateSetting       db      ?
bNumEndpoints           db      ?
; Number of endpoints used by this interface, excluding zero endpoint
bInterfaceClass         db      ?
; USB Interface Class Code
bInterfaceSubClass      db      ?
; USB Interface Subclass Code
bInterfaceProtocol      db      ?
; USB Interface Protocol Code
iInterface              db      ?
; Index of string descriptor describing this interface
ends
 
; USB endpoint descriptor
struct usb_endpoint_descr usb_descr
bEndpointAddress        db      ?
; Lower 4 bits form endpoint number,
; upper bit is 0 for OUT endpoints and 1 for IN endpoints,
; other bits must be zero
bmAttributes            db      ?
; Lower 2 bits form transfer type, one of *_PIPE,
; other bits must be zero for non-isochronous endpoints;
; refer to the USB specification for meaning in isochronous case
wMaxPacketSize          dw      ?
; Lower 11 bits form maximum packet size,
; next two bits specify the number of additional transactions per microframe
; for high-speed periodic endpoints, other bits must be zero.
bInterval               db      ?
; Interval for polling endpoint for data transfers.
; Isochronous and high-speed interrupt endpoints: poll every 2^(bInterval-1)
; (micro)frames
; Full/low-speed interrupt endpoints: poll every bInterval frames
; High-speed bulk/control OUT endpoints: maximum NAK rate
ends
 
; =============================================================================
; =================================== Code ====================================
; =============================================================================
 
; When a new device is ready to be configured, a controller-specific code
; calls usb_new_device.
; The sequence of further actions:
; * open pipe for the zero endpoint (usb_new_device);
;   maximum packet size is not known yet, but it must be at least 8 bytes,
;   so it is safe to send packets with <= 8 bytes
; * issue SET_ADDRESS control request (usb_new_device)
; * set the new device address in the pipe (usb_set_address_callback)
; * notify a controller-specific code that initialization of other ports
;   can be started (usb_set_address_callback)
; * issue GET_DESCRIPTOR control request for first 8 bytes of device descriptor
;   (usb_after_set_address)
; * first 8 bytes of device descriptor contain the true packet size for zero
;   endpoint, so set the true packet size (usb_get_descr8_callback)
; * first 8 bytes of a descriptor contain the full size of this descriptor,
;   issue GET_DESCRIPTOR control request for the full device descriptor
;   (usb_after_set_endpoint_size)
; * issue GET_DESCRIPTOR control request for first 8 bytes of configuration
;   descriptor (usb_get_descr_callback)
; * issue GET_DESCRIPTOR control request for full configuration descriptor
;   (usb_know_length_callback)
; * issue SET_CONFIGURATION control request (usb_set_config_callback)
; * parse configuration descriptor, load the corresponding driver(s),
;   pass the configuration descriptor to the driver and let the driver do
;   the further work (usb_got_config_callback)
 
; This function is called from controller-specific part
; when a new device is ready to be configured.
; in: ecx -> pseudo-pipe, part of usb_pipe
; in: esi -> usb_controller
; in: [esi+usb_controller.ResettingHub] is the pointer to usb_hub for device,
;     NULL if the device is connected to the root hub
; in: [esi+usb_controller.ResettingPort] is the port for the device, zero-based
; in: [esi+usb_controller.ResettingSpeed] is the speed of the device, one of
;     USB_SPEED_xx.
; out: eax = 0 <=> failed, the caller should disable the port.
proc usb_new_device
        push    ebx edi         ; save used registers to be stdcall
; 1. Check whether we're here because we were trying to reset
; already-registered device in hope to fix something serious.
; If so, skip allocation and go to 6.
        movzx   eax, [esi+usb_controller.ResettingPort]
        mov     edx, [esi+usb_controller.ResettingHub]
        test    edx, edx
        jz      .test_roothub
        mov     edx, [edx+usb_hub.ConnectedDevicesPtr]
        mov     ebx, [edx+eax*4]
        jmp     @f
.test_roothub:
        mov     ebx, [esi+usb_controller.DevicesByPort+eax*4]
@@:
        test    ebx, ebx
        jnz     .try_set_address
; 2. Allocate resources. Any device uses the following resources:
; - device address in the bus
; - memory for device data
; - pipe for zero endpoint
; If some allocation fails, we must undo our actions. Closing the pipe
; is a hard task, so we avoid it and open the pipe as the last resource.
; The order for other two allocations is quite arbitrary.
; 2a. Allocate a bus address.
        push    ecx
        call    usb_set_address_request
        pop     ecx
; 2b. If failed, just return zero.
        test    eax, eax
        jz      .nothing
; 2c. Allocate memory for device data.
; For now, we need sizeof.usb_device_data and extra 8 bytes for GET_DESCRIPTOR
; input and output, see usb_after_set_address. Later we will reallocate it
; to actual size needed for descriptors.
        movi    eax, sizeof.usb_device_data + 8
        push    ecx
        call    malloc
        pop     ecx
; 2d. If failed, free the bus address and return zero.
        test    eax, eax
        jz      .nomemory
; 2e. Open pipe for endpoint zero.
; For now, we do not know the actual maximum packet size;
; for full-speed devices it can be any of 8, 16, 32, 64 bytes,
; low-speed devices must have 8 bytes, high-speed devices must have 64 bytes.
; Thus, we must use some fake "maximum packet size" until the actual size
; will be known. However, the maximum packet size must be at least 8, and
; initial stages of the configuration process involves only packets of <= 8
; bytes, they will be transferred correctly as long as
; the fake "maximum packet size" is also at least 8.
; Thus, any number >= 8 is suitable for actual hardware.
; However, software emulation of EHCI in VirtualBox assumes that high-speed
; control transfers are those originating from pipes with max packet size = 64,
; even on early stages of the configuration process. This is incorrect,
; but we have no specific preferences, so let VirtualBox be happy and use 64
; as the fake "maximum packet size".
        push    eax
; We will need many zeroes.
; "push edi" is one byte, "push 0" is two bytes; save space, use edi.
        xor     edi, edi
        stdcall usb_open_pipe, ecx, edi, 64, edi, edi
; Put pointer to pipe into ebx. "xchg eax,reg" is one byte, mov is two bytes.
        xchg    eax, ebx
        pop     eax
; 2f. If failed, free the memory, the bus address and return zero.
        test    ebx, ebx
        jz      .freememory
; 3. Store pointer to device data in the pipe structure.
        mov     [ebx+usb_pipe.DeviceData], eax
; 4. Init device data, using usb_controller.Resetting* variables.
        mov     [eax+usb_device_data.Timer], edi
        mov     dword [eax+usb_device_data.DeviceDescriptor], TIMEOUT_SET_ADDRESS_INITIAL
        mov     [eax+usb_device_data.TTHub], edi
        mov     [eax+usb_device_data.TTPort], 0
        mov     [eax+usb_device_data.NumInterfaces], edi
        mov     [eax+usb_device_data.DeviceDescrSize], 0
        mov     dl, [esi+usb_controller.ResettingSpeed]
        mov     [eax+usb_device_data.Speed], dl
        mov     [eax+usb_device_data.NumPipes], 1
        push    ebx
        cmp     dl, USB_SPEED_HS
        jz      .nott
        mov     ebx, [esi+usb_controller.ResettingHub]
        test    ebx, ebx
        jz      .nott
        mov     cl, [esi+usb_controller.ResettingPort]
        mov     edx, [ebx+usb_hub.ConfigPipe]
        mov     edx, [edx+usb_pipe.DeviceData]
        cmp     [edx+usb_device_data.TTHub], 0
        jz      @f
        mov     cl, [edx+usb_device_data.TTPort]
        mov     ebx, [edx+usb_device_data.TTHub]
        jmp     .has_tt
@@:
        cmp     [edx+usb_device_data.Speed], USB_SPEED_HS
        jnz     .nott
.has_tt:
        mov     [eax+usb_device_data.TTHub], ebx
        mov     [eax+usb_device_data.TTPort], cl
.nott:
        pop     ebx
        mov     [eax+usb_device_data.ConfigDataSize], edi
        mov     [eax+usb_device_data.Interfaces], edi
        movzx   ecx, [esi+usb_controller.ResettingPort]
        mov     [eax+usb_device_data.Port], cl
        mov     edx, [esi+usb_controller.ResettingHub]
        mov     [eax+usb_device_data.Hub], edx
; 5. Store pointer to the config pipe in the hub data.
; Config pipe serves as device identifier.
; Root hubs use the array inside usb_controller structure,
; non-root hubs use the array immediately after usb_hub structure.
        test    edx, edx
        jz      .roothub
        mov     edx, [edx+usb_hub.ConnectedDevicesPtr]
        mov     [edx+ecx*4], ebx
        jmp     @f
.roothub:
        mov     [esi+usb_controller.DevicesByPort+ecx*4], ebx
@@:
        call    usb_reinit_pipe_list
; 6. Issue SET_ADDRESS control request, using buffer filled in step 2a.
; 6a. Configure timer to force reset after timeout.
; Note: we can't use self-destructing timer, because we need to be able to cancel it,
; and for self-destructing timer we could have race condition in cancelling/destructing.
;        DEBUGF 1,'K : pipe %x\n',ebx
.try_set_address:
        xor     edi, edi
        mov     edx, [ebx+usb_pipe.DeviceData]
        stdcall timer_hs, [edx+usb_device_data.DeviceDescriptor], 7FFFFFFFh, usb_abort_pipe, ebx
        test    eax, eax
        jz      .nothing
        mov     edx, [ebx+usb_pipe.DeviceData]
        mov     [edx+usb_device_data.Timer], eax
; 6b. If it succeeded, setup timer to configure wait timeout.
        lea     eax, [esi+usb_controller.SetAddressBuffer]
        stdcall usb_control_async, ebx, eax, edi, edi, usb_set_address_callback, edi, edi
; Use the return value from usb_control_async as our return value;
; if it is zero, then something has failed.
.nothing:
; 7. Return.
        pop     edi ebx         ; restore used registers to be stdcall
        ret
; Handlers of failures in steps 2b, 2d, 2f.
.freememory:
        call    free
        jmp     .freeaddr
.nomemory:
        dbgstr 'No memory for device data'
.freeaddr:
        mov     ecx, dword [esi+usb_controller.SetAddressBuffer+2]
        bts     [esi+usb_controller.ExistingAddresses], ecx
        xor     eax, eax
        jmp     .nothing
endp
 
; Helper procedure for usb_new_device.
; Allocates a new USB address and fills usb_controller.SetAddressBuffer
; with data for SET_ADDRESS(allocated_address) request.
; out: eax = 0 <=> failed
; Destroys edi.
proc usb_set_address_request
; There are 128 bits, one for each possible address.
; Note: only the USB thread works with usb_controller.ExistingAddresses,
; so there is no need for synchronization.
; We must find a bit set to 1 and clear it.
; 1. Find the first dword which has a nonzero bit = which is nonzero.
        mov     ecx, 128/32
        lea     edi, [esi+usb_controller.ExistingAddresses]
        xor     eax, eax
        repz scasd
; 2. If all dwords are zero, return an error.
        jz      .error
; 3. The dword at [edi-4] is nonzero. Find the lowest nonzero bit.
        bsf     eax, [edi-4]
; Now eax = bit number inside the dword at [edi-4].
; 4. Clear the bit.
        btr     [edi-4], eax
; 5. Generate the address by edi = memory address and eax = bit inside dword.
; Address = eax + 8 * (edi-4 - (esi+usb_controller.ExistingAddress)).
        sub     edi, esi
        lea     edi, [eax+(edi-4-usb_controller.ExistingAddresses)*8]
; 6. Store the allocated address in SetAddressBuffer and fill remaining fields.
; Note that usb_controller is zeroed at allocation, so only command byte needs
; to be filled.
        mov     byte [esi+usb_controller.SetAddressBuffer+1], USB_SET_ADDRESS
        mov     dword [esi+usb_controller.SetAddressBuffer+2], edi
; 7. Return non-zero value in eax.
        inc     eax
.nothing:
        ret
.error:
        dbgstr 'cannot allocate USB address'
        xor     eax, eax
        jmp     .nothing
endp
 
; This procedure is called by USB stack when SET_ADDRESS request initiated by
; usb_new_device is completed, either successfully or unsuccessfully.
; Note that USB stack uses esi = pointer to usb_controller.
proc usb_set_address_callback stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
        push    ebx     ; save ebx to be stdcall
 
        mov     ebx, [pipe]
; 1. In any case, cancel the timer.
        mov     eax, [ebx+usb_pipe.DeviceData]
        stdcall cancel_timer_hs, [eax+usb_device_data.Timer]
        mov     eax, [ebx+usb_pipe.DeviceData]
        mov     [eax+usb_device_data.Timer], 0
; Load data to registers for further references.
        mov     ecx, dword [esi+usb_controller.SetAddressBuffer+2]
        mov     eax, [esi+usb_controller.HardwareFunc]
; 2. Check whether the device has accepted new address. If so, proceed to 3.
; Otherwise, go to 4 if killed by usb_set_address_timeout or to 5 otherwise.
        cmp     [status], USB_STATUS_CANCELLED
        jz      .timeout
        cmp     [status], 0
        jnz     .error
; 3. Address accepted.
; 3a. The controller-specific structure for the control pipe still uses
; zero address. Call the controller-specific function to change it to
; the actual address.
; Note that the hardware could cache the controller-specific structure,
; so setting the address could take some time until the cache is evicted.
; Thus, the call is asynchronous; meet us in usb_after_set_address when it will
; be safe to continue.
;        dbgstr 'address set in device'
        call    [eax+usb_hardware_func.SetDeviceAddress]
; 3b. If the port is in non-root hub, clear 'reset in progress' flag.
; In any case, proceed to 6.
        mov     eax, [esi+usb_controller.ResettingHub]
        test    eax, eax
        jz      .return
        and     [eax+usb_hub.Actions], not HUB_RESET_IN_PROGRESS
.return:
; 6. Address configuration done, we can proceed with other ports.
; Call the worker function for that.
        call    usb_test_pending_port
.wakeup:
        push    esi edi
        call    usb_wakeup
        pop     edi esi
.nothing:
        pop     ebx     ; restore ebx to be stdcall
        ret
.timeout:
; 4. Device continues to NAK the request. Reset it and retry.
        mov     edx, [ebx+usb_pipe.DeviceData]
        mov     ecx, [edx+usb_device_data.DeviceDescriptor]
        add     ecx, ecx
        cmp     ecx, TIMEOUT_SET_ADDRESS_LAST
        ja      .error
        mov     [edx+usb_device_data.DeviceDescriptor], ecx
        dbgstr 'Timeout in USB device initialization, trying to reset...'
        cmp     [esi+usb_controller.ResettingHub], 0
        jz      .reset_roothub
        push    esi
        mov     esi, [esi+usb_controller.ResettingHub]
        call    usb_hub_initiate_reset
        pop     esi
        jmp     .nothing
.reset_roothub:
        movzx   ecx, [esi+usb_controller.ResettingPort]
        call    [eax+usb_hardware_func.InitiateReset]
        jmp     .wakeup
.error:
; 5. Device error: device not responding, disconnect etc.
        DEBUGF 1,'K : error %d in SET_ADDRESS, USB device disabled\n',[status]
; 5a. The address has not been accepted. Mark it as free.
        bts     dword [esi+usb_controller.ExistingAddresses], ecx
; 5b. Disable the port with bad device.
; For the root hub, call the controller-specific function and go to 6.
; For non-root hubs, let the hub code do its work and return (the request
; could take some time, the hub code is responsible for proceeding).
        cmp     [esi+usb_controller.ResettingHub], 0
        jz      .roothub
        mov     eax, [esi+usb_controller.ResettingHub]
        call    usb_hub_disable_resetting_port
        jmp     .nothing
.roothub:
        movzx   ecx, [esi+usb_controller.ResettingPort]
        call    [eax+usb_hardware_func.PortDisable]
        jmp     .return
endp
 
; This procedure is called from usb_subscription_done when the hardware cache
; is cleared after request from usb_set_address_callback.
; in: ebx -> usb_pipe
proc usb_after_set_address
;        dbgstr 'address set for controller'
; Issue control transfer GET_DESCRIPTOR(DEVICE_DESCR) for first 8 bytes.
; Remember, we still do not know the actual packet size;
; 8-bytes-request is safe.
; usb_new_device has allocated 8 extra bytes besides sizeof.usb_device_data;
; use them for both input and output.
        mov     eax, [ebx+usb_pipe.DeviceData]
        add     eax, usb_device_data.DeviceDescriptor
        mov     dword [eax], \
                80h + \         ; device-to-host, standard, device-wide
                (USB_GET_DESCRIPTOR shl 8) + \  ; request
                (0 shl 16) + \  ; descriptor index: there is only one
                (USB_DEVICE_DESCR shl 24)       ; descriptor type
        mov     dword [eax+4], 8 shl 16         ; data length
        stdcall usb_control_async, ebx, eax, eax, 8, usb_get_descr8_callback, eax, 0
        ret
endp
 
; This procedure is called by USB stack when GET_DESCRIPTOR(DEVICE_DESCR)
; request initiated by usb_after_set_address is completed, either successfully
; or unsuccessfully.
; Note that USB stack uses esi = pointer to usb_controller.
proc usb_get_descr8_callback stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
;       mov     eax, [buffer]
;       DEBUGF 1,'K : descr8: l=%x; %x %x %x %x %x %x %x %x\n',[length],\
;               [eax]:2,[eax+1]:2,[eax+2]:2,[eax+3]:2,[eax+4]:2,[eax+5]:2,[eax+6]:2,[eax+7]:2
        push    edi ebx         ; save used registers to be stdcall
        mov     ebx, [pipe]
; 1. Check whether the operation was successful.
; If not, say something to the debug board and stop the initialization.
        cmp     [status], 0
        jnz     .error
; 2. Length of descriptor must be at least sizeof.usb_device_descr bytes.
; If not, say something to the debug board and stop the initialization.
        mov     eax, [ebx+usb_pipe.DeviceData]
        cmp     [eax+usb_device_data.DeviceDescriptor+usb_device_descr.bLength], sizeof.usb_device_descr
        jb      .error
; 3. Now first 8 bytes of device descriptor are known;
; set DeviceDescrSize accordingly.
        mov     [eax+usb_device_data.DeviceDescrSize], 8
; 4. The controller-specific structure for the control pipe still uses
; the fake "maximum packet size". Call the controller-specific function to
; change it to the actual packet size from the device.
; Note that the hardware could cache the controller-specific structure,
; so changing it could take some time until the cache is evicted.
; Thus, the call is asynchronous; meet us in usb_after_set_endpoint_size
; when it will be safe to continue.
        movzx   ecx, [eax+usb_device_data.DeviceDescriptor+usb_device_descr.bMaxPacketSize0]
        mov     eax, [esi+usb_controller.HardwareFunc]
        call    [eax+usb_hardware_func.SetEndpointPacketSize]
.nothing:
; 5. Return.
        pop     ebx edi         ; restore used registers to be stdcall
        ret
.error:
        dbgstr 'error with USB device descriptor'
        jmp     .nothing
endp
 
; This procedure is called from usb_subscription_done when the hardware cache
; is cleared after request from usb_get_descr8_callback.
; in: ebx -> usb_pipe
proc usb_after_set_endpoint_size
; 1. Reallocate memory for device data:
; add memory for now-known size of device descriptor and extra 8 bytes
; for further actions.
; 1a. Allocate new memory.
        mov     eax, [ebx+usb_pipe.DeviceData]
        movzx   eax, [eax+usb_device_data.DeviceDescriptor+usb_device_descr.bLength]
; save length for step 2
        push    eax
        add     eax, sizeof.usb_device_data + 8
        call    malloc
; 1b. If failed, say something to the debug board and stop the initialization.
        test    eax, eax
        jz      .nomemory
; 1c. Copy data from old memory to new memory and switch the pointer in usb_pipe.
        push    eax
        push    esi edi
        mov     esi, [ebx+usb_pipe.DeviceData]
        mov     [ebx+usb_pipe.DeviceData], eax
        mov     edi, eax
        mov     eax, esi
        mov     ecx, sizeof.usb_device_data / 4
        rep movsd
        pop     edi esi
        call    usb_reinit_pipe_list
; 1d. Free the old memory.
        call    free
        pop     eax
; 2. Issue control transfer GET_DESCRIPTOR(DEVICE) for full descriptor.
; restore length saved in step 1a
        pop     edx
        add     eax, sizeof.usb_device_data
        mov     dword [eax], \
                80h + \         ; device-to-host, standard, device-wide
                (USB_GET_DESCRIPTOR shl 8) + \  ; request
                (0 shl 16) + \  ; descriptor index: there is only one
                (USB_DEVICE_DESCR shl 24)       ; descriptor type
        and     dword [eax+4], 0
        mov     [eax+6], dl     ; data length
        stdcall usb_control_async, ebx, eax, eax, edx, usb_get_descr_callback, eax, 0
; 3. Return.
        ret
.nomemory:
        dbgstr 'No memory for device data'
        ret
endp
 
; This procedure is called by USB stack when GET_DESCRIPTOR(DEVICE)
; request initiated by usb_after_set_endpoint_size is completed,
; either successfully or unsuccessfully.
proc usb_get_descr_callback stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
; Note: the prolog is the same as in usb_get_descr8_callback.
        push    edi ebx         ; save used registers to be stdcall
; 1. Check whether the operation was successful.
; If not, say something to the debug board and stop the initialization.
        cmp     [status], 0
        jnz     usb_get_descr8_callback.error
; The full descriptor is known, dump it if specified by compile-time option.
if USB_DUMP_DESCRIPTORS
        mov     eax, [buffer]
        mov     ecx, [length]
        sub     ecx, 8
        jbe     .skipdebug
        DEBUGF 1,'K : device descriptor:'
@@:
        DEBUGF 1,' %x',[eax]:2
        inc     eax
        dec     ecx
        jnz     @b
        DEBUGF 1,'\n'
.skipdebug:
end if
; 2. Check that bLength is the same as was in the previous request.
; If not, say something to the debug board and stop the initialization.
; It is important, because usb_after_set_endpoint_size has allocated memory
; according to the old bLength. Note that [length] for control transfers
; includes 8 bytes of setup packet, so data length = [length] - 8.
        mov     eax, [buffer]
        movzx   ecx, [eax+usb_device_descr.bLength]
        add     ecx, 8
        cmp     [length], ecx
        jnz     usb_get_descr8_callback.error
; Amuse the user if she is watching the debug board.
        mov     cl, [eax+usb_device_descr.bNumConfigurations]
        DEBUGF 1,'K : found USB device with ID %x:%x, %d configuration(s)\n',\
                [eax+usb_device_descr.idVendor]:4,\
                [eax+usb_device_descr.idProduct]:4,\
                cl
; 3. If there are no configurations, stop the initialization.
        cmp     [eax+usb_device_descr.bNumConfigurations], 0
        jz      .nothing
; 4. Copy length of device descriptor to device data structure.
        movzx   edx, [eax+usb_device_descr.bLength]
        mov     [eax+usb_device_data.DeviceDescrSize-usb_device_data.DeviceDescriptor], dl
; 5. Issue control transfer GET_DESCRIPTOR(CONFIGURATION). We do not know
; the full length of that descriptor, so start with first 8 bytes, they contain
; the full length.
; usb_after_set_endpoint_size has allocated 8 extra bytes after the
; device descriptor, use them for both input and output.
        add     eax, edx
        mov     dword [eax], \
                80h + \         ; device-to-host, standard, device-wide
                (USB_GET_DESCRIPTOR shl 8) + \  ; request
                (0 shl 16) + \  ; descriptor index: there is only one
                (USB_CONFIG_DESCR shl 24)       ; descriptor type
        mov     dword [eax+4], 8 shl 16         ; data length
        stdcall usb_control_async, [pipe], eax, eax, 8, usb_know_length_callback, eax, 0
.nothing:
; 6. Return.
        pop     ebx edi         ; restore used registers to be stdcall
        ret
endp
 
; This procedure is called by USB stack when GET_DESCRIPTOR(CONFIGURATION)
; request initiated by usb_get_descr_callback is completed,
; either successfully or unsuccessfully.
proc usb_know_length_callback stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
        push    ebx             ; save used registers to be stdcall
; 1. Check whether the operation was successful.
; If not, say something to the debug board and stop the initialization.
        cmp     [status], 0
        jnz     .error
; 2. Get the total length of data associated with config descriptor and store
; it in device data structure. The total length must be at least
; sizeof.usb_config_descr bytes; if not, say something to the debug board and
; stop the initialization.
        mov     eax, [buffer]
        mov     edx, [pipe]
        movzx   ecx, [eax+usb_config_descr.wTotalLength]
        mov     eax, [edx+usb_pipe.DeviceData]
        cmp     ecx, sizeof.usb_config_descr
        jb      .error
        mov     [eax+usb_device_data.ConfigDataSize], ecx
; 3. Reallocate memory for device data:
; include usb_device_data structure, device descriptor,
; config descriptor with all associated data, and extra bytes
; sufficient for 8 bytes control packet and for one usb_interface_data struc.
; Align extra bytes to dword boundary.
if sizeof.usb_interface_data > 8
.extra_size = sizeof.usb_interface_data
else
.extra_size = 8
end if
; 3a. Allocate new memory.
        movzx   edx, [eax+usb_device_data.DeviceDescrSize]
        lea     eax, [ecx+edx+sizeof.usb_device_data+.extra_size+3]
        and     eax, not 3
        push    eax
        call    malloc
        pop     edx
; 3b. If failed, say something to the debug board and stop the initialization.
        test    eax, eax
        jz      .nomemory
; 3c. Copy data from old memory to new memory and switch the pointer in usb_pipe.
        push    eax
        mov     ebx, [pipe]
        push    esi edi
        mov     esi, [ebx+usb_pipe.DeviceData]
        mov     edi, eax
        mov     [ebx+usb_pipe.DeviceData], eax
        mov     eax, esi
        movzx   ecx, [esi+usb_device_data.DeviceDescrSize]
        sub     edx, .extra_size
        mov     [esi+usb_device_data.Interfaces], edx
        add     ecx, sizeof.usb_device_data + 8
        mov     edx, ecx
        shr     ecx, 2
        and     edx, 3
        rep movsd
        mov     ecx, edx
        rep movsb
        pop     edi esi
        call    usb_reinit_pipe_list
; 3d. Free old memory.
        call    free
        pop     eax
; 4. Issue control transfer GET_DESCRIPTOR(CONFIGURATION) for full descriptor.
        movzx   ecx, [eax+usb_device_data.DeviceDescrSize]
        mov     edx, [eax+usb_device_data.ConfigDataSize]
        lea     eax, [eax+ecx+sizeof.usb_device_data]
        mov     dword [eax], \
                80h + \         ; device-to-host, standard, device-wide
                (USB_GET_DESCRIPTOR shl 8) + \  ; request
                (0 shl 16) + \  ; descriptor index: there is only one
                (USB_CONFIG_DESCR shl 24)       ; descriptor type
        and     dword [eax+4], 0
        mov     word [eax+6], dx        ; data length
        stdcall usb_control_async, [pipe], eax, eax, edx, usb_set_config_callback, eax, 0
.nothing:
; 5. Return.
        pop     ebx             ; restore used registers to be stdcall
        ret
.error:
        dbgstr 'error with USB configuration descriptor'
        jmp     .nothing
.nomemory:
        dbgstr 'No memory for device data'
        jmp     .nothing
endp
 
; This procedure is called by USB stack when GET_DESCRIPTOR(CONFIGURATION)
; request initiated by usb_know_length_callback is completed,
; either successfully or unsuccessfully.
proc usb_set_config_callback stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
; Note that the prolog is the same as in usb_know_length_callback.
        push    ebx             ; save used registers to be stdcall
; 1. Check whether the operation was successful.
; If not, say something to the debug board and stop the initialization.
        xor     ecx, ecx
        mov     ebx, [pipe]
        cmp     [status], ecx
        jnz     usb_know_length_callback.error
; The full descriptor is known, dump it if specified by compile-time option.
if USB_DUMP_DESCRIPTORS
        mov     eax, [buffer]
        mov     ecx, [length]
        sub     ecx, 8
        jbe     .skip_debug
        DEBUGF 1,'K : config descriptor:'
@@:
        DEBUGF 1,' %x',[eax]:2
        inc     eax
        dec     ecx
        jnz     @b
        DEBUGF 1,'\n'
.skip_debug:
        xor     ecx, ecx
end if
; 2. Issue control transfer SET_CONFIGURATION to activate this configuration.
; Usually this is the only configuration.
; Use extra bytes allocated by usb_know_length_callback;
; offset from device data start is stored in Interfaces.
        mov     eax, [ebx+usb_pipe.DeviceData]
        mov     edx, [buffer]
        add     eax, [eax+usb_device_data.Interfaces]
        mov     dl, [edx+usb_config_descr.bConfigurationValue]
        mov     dword [eax], USB_SET_CONFIGURATION shl 8
        mov     dword [eax+4], ecx
        mov     byte [eax+2], dl
        stdcall usb_control_async, [pipe], eax, ecx, ecx, usb_got_config_callback, [buffer], ecx
        pop     ebx             ; restore used registers to be stdcall
        ret
endp
 
; This procedure is called by USB stack when SET_CONFIGURATION
; request initiated by usb_set_config_callback is completed,
; either successfully or unsuccessfully.
; If successfully, the device is configured and ready to work,
; pass the device to the corresponding driver(s).
proc usb_got_config_callback stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
locals
InterfacesData  dd      ?
NumInterfaces   dd      ?
driver          dd      ?
endl
; 1. If there was an error, say something to the debug board and stop the
; initialization.
        cmp     [status], 0
        jz      @f
        dbgstr 'USB error in SET_CONFIGURATION'
        ret
@@:
        push    ebx edi         ; save used registers to be stdcall
; 2. Sanity checks: the total length must be the same as before (because we
; have allocated memory assuming the old value), length of config descriptor
; must be at least sizeof.usb_config_descr (we use fields from it),
; there must be at least one interface.
        mov     ebx, [pipe]
        mov     ebx, [ebx+usb_pipe.DeviceData]
        mov     eax, [calldata]
        mov     edx, [ebx+usb_device_data.ConfigDataSize]
        cmp     [eax+usb_config_descr.wTotalLength], dx
        jnz     .invalid
        cmp     [eax+usb_config_descr.bLength], 9
        jb      .invalid
        movzx   edx, [eax+usb_config_descr.bNumInterfaces]
        test    edx, edx
        jnz     @f
.invalid:
        dbgstr 'error: invalid configuration descriptor'
        jmp     .nothing
@@:
; 3. Store the number of interfaces in device data structure.
        mov     [ebx+usb_device_data.NumInterfaces], edx
; 4. If there is only one interface (which happens quite often),
; the memory allocated in usb_know_length_callback is sufficient.
; Otherwise (which also happens quite often), reallocate device data.
; 4a. Check whether there is only one interface. If so, skip this step.
        cmp     edx, 1
        jz      .has_memory
; 4b. Allocate new memory.
        mov     eax, [ebx+usb_device_data.Interfaces]
        lea     eax, [eax+edx*sizeof.usb_interface_data]
        call    malloc
; 4c. If failed, say something to the debug board and
; stop the initialization.
        test    eax, eax
        jnz     @f
        dbgstr 'No memory for device data'
        jmp     .nothing
@@:
; 4d. Copy data from old memory to new memory and switch the pointer in usb_pipe.
        push    eax
        push    esi
        mov     ebx, [pipe]
        mov     edi, eax
        mov     esi, [ebx+usb_pipe.DeviceData]
        mov     [ebx+usb_pipe.DeviceData], eax
        mov     eax, esi
        mov     ecx, [esi+usb_device_data.Interfaces]
        shr     ecx, 2
        rep movsd
        pop     esi
        call    usb_reinit_pipe_list
; 4e. Free old memory.
        call    free
        pop     ebx
.has_memory:
; 5. Initialize interfaces table: zero all contents.
        mov     edi, [ebx+usb_device_data.Interfaces]
        add     edi, ebx
        mov     [InterfacesData], edi
        mov     ecx, [ebx+usb_device_data.NumInterfaces]
if sizeof.usb_interface_data <> 8
You have changed sizeof.usb_interface_data? Modify this place too.
end if
        add     ecx, ecx
        xor     eax, eax
        rep stosd
; No interfaces are found yet.
        mov     [NumInterfaces], eax
; 6. Get the pointer to config descriptor data.
; Note: if there was reallocation, [buffer] is not valid anymore,
; so calculate value based on usb_device_data.
        movzx   eax, [ebx+usb_device_data.DeviceDescrSize]
        lea     eax, [eax+ebx+sizeof.usb_device_data]
        mov     [calldata], eax
        mov     ecx, [ebx+usb_device_data.ConfigDataSize]
; 7. Loop over all descriptors,
; scan for interface descriptors with bAlternateSetting = 0,
; load the corresponding driver, call its AddDevice function.
.descriptor_loop:
; While in loop: eax points to the current descriptor,
; ecx = number of bytes left, the iteration starts only if ecx is nonzero,
; edx = size of the current descriptor.
; 7a. The first byte is always accessible; it contains the length of
; the current descriptor. Validate that the length is at least 2 bytes,
; and the entire descriptor is readable (the length is at most number of
; bytes left).
        movzx   edx, [eax+usb_descr.bLength]
        cmp     edx, sizeof.usb_descr
        jb      .invalid
        cmp     ecx, edx
        jb      .invalid
; 7b. Check descriptor type. Ignore all non-INTERFACE descriptor.
        cmp     byte [eax+usb_descr.bDescriptorType], USB_INTERFACE_DESCR
        jz      .interface
.next_descriptor:
; 7c. Advance pointer, decrease length left, if there is still something left,
; continue the loop.
        add     eax, edx
        sub     ecx, edx
        jnz     .descriptor_loop
.done:
.nothing:
        pop     edi ebx         ; restore used registers to be stdcall
        ret
.interface:
; 7d. Validate the descriptor length.
        cmp     edx, sizeof.usb_interface_descr
        jb      .next_descriptor
; 7e. If bAlternateSetting is nonzero, this descriptor actually describes
; another mode of already known interface and belongs to the already loaded
; driver; amuse the user and continue to 7c.
        cmp     byte [eax+usb_interface_descr.bAlternateSetting], 0
        jz      @f
        DEBUGF 1,'K : note: alternate setting with %x/%x/%x\n',\
                [eax+usb_interface_descr.bInterfaceClass]:2,\
                [eax+usb_interface_descr.bInterfaceSubClass]:2,\
                [eax+usb_interface_descr.bInterfaceProtocol]:2
        jmp     .next_descriptor
@@:
; 7f. Check that the new interface does not overflow allocated table.
        mov     edx, [NumInterfaces]
        inc     edx
        cmp     edx, [ebx+usb_device_data.NumInterfaces]
        ja      .invalid
; 7g. We have found a new interface. Advance bookkeeping vars.
        mov     [NumInterfaces], edx
        add     [InterfacesData], sizeof.usb_interface_data
; 7h. Save length left and pointer to the current interface descriptor.
        push    ecx eax
; Amuse the user if she is watching the debug board.
        DEBUGF 1,'K : USB interface class/subclass/protocol = %x/%x/%x\n',\
                [eax+usb_interface_descr.bInterfaceClass]:2,\
                [eax+usb_interface_descr.bInterfaceSubClass]:2,\
                [eax+usb_interface_descr.bInterfaceProtocol]:2
; 7i. Select the correct driver based on interface class.
; For hubs, go to 7j. Otherwise, go to 7k.
; Note: this should be rewritten as table-based lookup when more drivers will
; be available.
        cmp     byte [eax+usb_interface_descr.bInterfaceClass], 9
        jz      .found_hub
        mov     edx, usb_hid_name
        cmp     byte [eax+usb_interface_descr.bInterfaceClass], 3
        jz      .load_driver
        mov     edx, usb_print_name
        cmp     byte [eax+usb_interface_descr.bInterfaceClass], 7
        jz      .load_driver
        mov     edx, usb_stor_name
        cmp     byte [eax+usb_interface_descr.bInterfaceClass], 8
        jz      .load_driver
        mov     edx, usb_other_name
        jmp     .load_driver
.found_hub:
; 7j. Hubs are a part of USB stack, thus, integrated into the kernel.
; Use the pointer to hub callbacks and go to 7m.
        mov     eax, usb_hub_pseudosrv - USBSRV.usb_func
        jmp     .driver_loaded
.load_driver:
; 7k. Load the corresponding driver.
        push    ebx esi edi
        stdcall get_service, edx
        pop     edi esi ebx
; 7l. If failed, say something to the debug board and go to 7p.
        test    eax, eax
        jnz     .driver_loaded
        dbgstr 'failed to load class driver'
        jmp     .next_descriptor2
.driver_loaded:
; 7m. Call AddDevice function of the driver.
; Note that top of stack contains a pointer to the current interface,
; saved by step 7h.
        mov     [driver], eax
        mov     eax, [eax+USBSRV.usb_func]
        pop     edx
        push    edx
; Note: usb_hub_init assumes that edx points to usb_interface_descr,
; ecx = length rest; if you change the code, modify usb_hub_init also.
        stdcall [eax+USBFUNC.add_device], [pipe], [calldata], edx
; 7n. If failed, say something to the debug board and go to 7p.
        test    eax, eax
        jnz     .store_data
        dbgstr 'USB device initialization failed'
        jmp     .next_descriptor2
.store_data:
; 7o. Store the returned value and the driver handle to InterfacesData.
; Note that step 7g has already advanced InterfacesData.
        mov     edx, [InterfacesData]
        mov     [edx+usb_interface_data.DriverData-sizeof.usb_interface_data], eax
        mov     eax, [driver]
        mov     [edx+usb_interface_data.DriverFunc-sizeof.usb_interface_data], eax
.next_descriptor2:
; 7p. Restore registers saved in step 7h, get the descriptor length and
; continue to 7c.
        pop     eax ecx
        movzx   edx, byte [eax+usb_descr.bLength]
        jmp     .next_descriptor
endp
 
; Driver names, see step 7i of usb_got_config_callback.
iglobal
usb_hid_name    db      'usbhid',0
usb_stor_name   db      'usbstor',0
usb_print_name  db      'usbprint',0
usb_other_name  db      'usbother',0
endg

Rev 4423	Rev 5201
-		1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		2	;; ;;
-		3	;; Copyright (C) KolibriOS team 2013-2014. All rights reserved. ;;
-		4	;; Distributed under terms of the GNU General Public License ;;
-		5	;; ;;
-		6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		7
-		8	$Revision: 5177 $
-		9
-		10
1	; Implementation of the USB protocol for device enumeration.	11	; Implementation of the USB protocol for device enumeration.
2	; Manage a USB device when it becomes ready for USB commands:	12	; Manage a USB device when it becomes ready for USB commands:
3	; configure, enumerate, load the corresponding driver(s),	13	; configure, enumerate, load the corresponding driver(s),
4	; pass device information to the driver.	14	; pass device information to the driver.
5		15
6	; =============================================================================	16	; =============================================================================
7	; ================================= Constants =================================	17	; ================================= Constants =================================
8	; =============================================================================	18	; =============================================================================
9	; USB standard request codes	19	; USB standard request codes
10	USB_GET_STATUS = 0	20	USB_GET_STATUS = 0
11	USB_CLEAR_FEATURE = 1	21	USB_CLEAR_FEATURE = 1
12	USB_SET_FEATURE = 3	22	USB_SET_FEATURE = 3
13	USB_SET_ADDRESS = 5	23	USB_SET_ADDRESS = 5
14	USB_GET_DESCRIPTOR = 6	24	USB_GET_DESCRIPTOR = 6
15	USB_SET_DESCRIPTOR = 7	25	USB_SET_DESCRIPTOR = 7
16	USB_GET_CONFIGURATION = 8	26	USB_GET_CONFIGURATION = 8
17	USB_SET_CONFIGURATION = 9	27	USB_SET_CONFIGURATION = 9
18	USB_GET_INTERFACE = 10	28	USB_GET_INTERFACE = 10
19	USB_SET_INTERFACE = 11	29	USB_SET_INTERFACE = 11
20	USB_SYNCH_FRAME = 12	30	USB_SYNCH_FRAME = 12
21		31
22	; USB standard descriptor types	32	; USB standard descriptor types
23	USB_DEVICE_DESCR = 1	33	USB_DEVICE_DESCR = 1
24	USB_CONFIG_DESCR = 2	34	USB_CONFIG_DESCR = 2
25	USB_STRING_DESCR = 3	35	USB_STRING_DESCR = 3
26	USB_INTERFACE_DESCR = 4	36	USB_INTERFACE_DESCR = 4
27	USB_ENDPOINT_DESCR = 5	37	USB_ENDPOINT_DESCR = 5
28	USB_DEVICE_QUALIFIER_DESCR = 6	38	USB_DEVICE_QUALIFIER_DESCR = 6
29	USB_OTHER_SPEED_CONFIG_DESCR = 7	39	USB_OTHER_SPEED_CONFIG_DESCR = 7
30	USB_INTERFACE_POWER_DESCR = 8	40	USB_INTERFACE_POWER_DESCR = 8
31		41
32	; Compile-time setting. If set, the code will dump all descriptors as they are	42	; Compile-time setting. If set, the code will dump all descriptors as they are
33	; read to the debug board.	43	; read to the debug board.
34	USB_DUMP_DESCRIPTORS = 1	44	USB_DUMP_DESCRIPTORS = 1
-		45
-		46	; According to the USB specification (9.2.6.3),
-		47	; any device must response to SET_ADDRESS in 50 ms, or 5 timer ticks.
-		48	; Of course, our world is far from ideal.
-		49	; I have seen devices that just NAK everything when being reset from working
-		50	; state, but start to work after second reset.
-		51	; Our strategy is as follows: give 2 seconds for the first attempt,
-		52	; this should be enough for normal devices and not too long to detect buggy ones.
-		53	; If the device continues NAKing, reset it and retry several times,
-		54	; doubling the interval: 2s -> 4s -> 8s -> 16s. Give up after that.
-		55	; Numbers are quite arbitrary.
-		56	TIMEOUT_SET_ADDRESS_INITIAL = 200
-		57	TIMEOUT_SET_ADDRESS_LAST = 1600
35		58
36	; =============================================================================	59	; =============================================================================
37	; ================================ Structures =================================	60	; ================================ Structures =================================
38	; =============================================================================	61	; =============================================================================
39	; USB descriptors. See USB specification for detailed explanations.	62	; USB descriptors. See USB specification for detailed explanations.
40	; First two bytes of every descriptor have the same meaning.	63	; First two bytes of every descriptor have the same meaning.
41	struct usb_descr	64	struct usb_descr
42	bLength db ?	65	bLength db ?
43	; Size of this descriptor in bytes	66	; Size of this descriptor in bytes
44	bDescriptorType db ?	67	bDescriptorType db ?
45	; One of USB_*_DESCR constants.	68	; One of USB_*_DESCR constants.
46	ends	69	ends
47		70
48	; USB device descriptor	71	; USB device descriptor
49	struct usb_device_descr usb_descr	72	struct usb_device_descr usb_descr
50	bcdUSB dw ?	73	bcdUSB dw ?
51	; USB Specification Release number in BCD, e.g. 110h = USB 1.1	74	; USB Specification Release number in BCD, e.g. 110h = USB 1.1
52	bDeviceClass db ?	75	bDeviceClass db ?
53	; USB Device Class Code	76	; USB Device Class Code
54	bDeviceSubClass db ?	77	bDeviceSubClass db ?
55	; USB Device Subclass Code	78	; USB Device Subclass Code
56	bDeviceProtocol db ?	79	bDeviceProtocol db ?
57	; USB Device Protocol Code	80	; USB Device Protocol Code
58	bMaxPacketSize0 db ?	81	bMaxPacketSize0 db ?
59	; Maximum packet size for zero endpoint	82	; Maximum packet size for zero endpoint
60	idVendor dw ?	83	idVendor dw ?
61	; Vendor ID	84	; Vendor ID
62	idProduct dw ?	85	idProduct dw ?
63	; Product ID	86	; Product ID
64	bcdDevice dw ?	87	bcdDevice dw ?
65	; Device release number in BCD	88	; Device release number in BCD
66	iManufacturer db ?	89	iManufacturer db ?
67	; Index of string descriptor describing manufacturer	90	; Index of string descriptor describing manufacturer
68	iProduct db ?	91	iProduct db ?
69	; Index of string descriptor describing product	92	; Index of string descriptor describing product
70	iSerialNumber db ?	93	iSerialNumber db ?
71	; Index of string descriptor describing serial number	94	; Index of string descriptor describing serial number
72	bNumConfigurations db ?	95	bNumConfigurations db ?
73	; Number of possible configurations	96	; Number of possible configurations
74	ends	97	ends
75		98
76	; USB configuration descriptor	99	; USB configuration descriptor
77	struct usb_config_descr usb_descr	100	struct usb_config_descr usb_descr
78	wTotalLength dw ?	101	wTotalLength dw ?
79	; Total length of data returned for this configuration	102	; Total length of data returned for this configuration
80	bNumInterfaces db ?	103	bNumInterfaces db ?
81	; Number of interfaces in this configuration	104	; Number of interfaces in this configuration
82	bConfigurationValue db ?	105	bConfigurationValue db ?
83	; Value for SET_CONFIGURATION control request	106	; Value for SET_CONFIGURATION control request
84	iConfiguration db ?	107	iConfiguration db ?
85	; Index of string descriptor describing this configuration	108	; Index of string descriptor describing this configuration
86	bmAttributes db ?	109	bmAttributes db ?
87	; Bit 6 is SelfPowered, bit 5 is RemoteWakeupSupported,	110	; Bit 6 is SelfPowered, bit 5 is RemoteWakeupSupported,
88	; bit 7 must be 1, other bits must be 0	111	; bit 7 must be 1, other bits must be 0
89	bMaxPower db ?	112	bMaxPower db ?
90	; Maximum power consumption from the bus in 2mA units	113	; Maximum power consumption from the bus in 2mA units
91	ends	114	ends
92		115
93	; USB interface descriptor	116	; USB interface descriptor
94	struct usb_interface_descr usb_descr	117	struct usb_interface_descr usb_descr
95	; The following two fields work in pair. Sometimes one interface can work	118	; The following two fields work in pair. Sometimes one interface can work
96	; in different modes; e.g. videostream from web-cameras requires different	119	; in different modes; e.g. videostream from web-cameras requires different
97	; bandwidth depending on resolution/quality/compression settings.	120	; bandwidth depending on resolution/quality/compression settings.
98	; Each mode of each interface has its own descriptor with its own endpoints	121	; Each mode of each interface has its own descriptor with its own endpoints
99	; following; all descriptors for one interface have the same bInterfaceNumber,	122	; following; all descriptors for one interface have the same bInterfaceNumber,
100	; and different bAlternateSetting.	123	; and different bAlternateSetting.
101	; By default, any interface operates in mode with bAlternateSetting = 0.	124	; By default, any interface operates in mode with bAlternateSetting = 0.
102	; Often this is the only mode. If there are another modes, the active mode	125	; Often this is the only mode. If there are another modes, the active mode
103	; is selected by SET_INTERFACE(bAlternateSetting) control request.	126	; is selected by SET_INTERFACE(bAlternateSetting) control request.
104	bInterfaceNumber db ?	127	bInterfaceNumber db ?
105	bAlternateSetting db ?	128	bAlternateSetting db ?
106	bNumEndpoints db ?	129	bNumEndpoints db ?
107	; Number of endpoints used by this interface, excluding zero endpoint	130	; Number of endpoints used by this interface, excluding zero endpoint
108	bInterfaceClass db ?	131	bInterfaceClass db ?
109	; USB Interface Class Code	132	; USB Interface Class Code
110	bInterfaceSubClass db ?	133	bInterfaceSubClass db ?
111	; USB Interface Subclass Code	134	; USB Interface Subclass Code
112	bInterfaceProtocol db ?	135	bInterfaceProtocol db ?
113	; USB Interface Protocol Code	136	; USB Interface Protocol Code
114	iInterface db ?	137	iInterface db ?
115	; Index of string descriptor describing this interface	138	; Index of string descriptor describing this interface
116	ends	139	ends
117		140
118	; USB endpoint descriptor	141	; USB endpoint descriptor
119	struct usb_endpoint_descr usb_descr	142	struct usb_endpoint_descr usb_descr
120	bEndpointAddress db ?	143	bEndpointAddress db ?
121	; Lower 4 bits form endpoint number,	144	; Lower 4 bits form endpoint number,
122	; upper bit is 0 for OUT endpoints and 1 for IN endpoints,	145	; upper bit is 0 for OUT endpoints and 1 for IN endpoints,
123	; other bits must be zero	146	; other bits must be zero
124	bmAttributes db ?	147	bmAttributes db ?
125	; Lower 2 bits form transfer type, one of *_PIPE,	148	; Lower 2 bits form transfer type, one of *_PIPE,
126	; other bits must be zero for non-isochronous endpoints;	149	; other bits must be zero for non-isochronous endpoints;
127	; refer to the USB specification for meaning in isochronous case	150	; refer to the USB specification for meaning in isochronous case
128	wMaxPacketSize dw ?	151	wMaxPacketSize dw ?
129	; Lower 11 bits form maximum packet size,	152	; Lower 11 bits form maximum packet size,
130	; next two bits specify the number of additional transactions per microframe	153	; next two bits specify the number of additional transactions per microframe
131	; for high-speed periodic endpoints, other bits must be zero.	154	; for high-speed periodic endpoints, other bits must be zero.
132	bInterval db ?	155	bInterval db ?
133	; Interval for polling endpoint for data transfers.	156	; Interval for polling endpoint for data transfers.
134	; Isochronous and high-speed interrupt endpoints: poll every 2^(bInterval-1)	157	; Isochronous and high-speed interrupt endpoints: poll every 2^(bInterval-1)
135	; (micro)frames	158	; (micro)frames
136	; Full/low-speed interrupt endpoints: poll every bInterval frames	159	; Full/low-speed interrupt endpoints: poll every bInterval frames
137	; High-speed bulk/control OUT endpoints: maximum NAK rate	160	; High-speed bulk/control OUT endpoints: maximum NAK rate
138	ends	161	ends
139		162
140	; =============================================================================	163	; =============================================================================
141	; =================================== Code ====================================	164	; =================================== Code ====================================
142	; =============================================================================	165	; =============================================================================
143		166
144	; When a new device is ready to be configured, a controller-specific code	167	; When a new device is ready to be configured, a controller-specific code
145	; calls usb_new_device.	168	; calls usb_new_device.
146	; The sequence of further actions:	169	; The sequence of further actions:
147	; * open pipe for the zero endpoint (usb_new_device);	170	; * open pipe for the zero endpoint (usb_new_device);
148	; maximum packet size is not known yet, but it must be at least 8 bytes,	171	; maximum packet size is not known yet, but it must be at least 8 bytes,
149	; so it is safe to send packets with <= 8 bytes	172	; so it is safe to send packets with <= 8 bytes
150	; * issue SET_ADDRESS control request (usb_new_device)	173	; * issue SET_ADDRESS control request (usb_new_device)
151	; * set the new device address in the pipe (usb_set_address_callback)	174	; * set the new device address in the pipe (usb_set_address_callback)
152	; * notify a controller-specific code that initialization of other ports	175	; * notify a controller-specific code that initialization of other ports
153	; can be started (usb_set_address_callback)	176	; can be started (usb_set_address_callback)
154	; * issue GET_DESCRIPTOR control request for first 8 bytes of device descriptor	177	; * issue GET_DESCRIPTOR control request for first 8 bytes of device descriptor
155	; (usb_after_set_address)	178	; (usb_after_set_address)
156	; * first 8 bytes of device descriptor contain the true packet size for zero	179	; * first 8 bytes of device descriptor contain the true packet size for zero
157	; endpoint, so set the true packet size (usb_get_descr8_callback)	180	; endpoint, so set the true packet size (usb_get_descr8_callback)
158	; * first 8 bytes of a descriptor contain the full size of this descriptor,	181	; * first 8 bytes of a descriptor contain the full size of this descriptor,
159	; issue GET_DESCRIPTOR control request for the full device descriptor	182	; issue GET_DESCRIPTOR control request for the full device descriptor
160	; (usb_after_set_endpoint_size)	183	; (usb_after_set_endpoint_size)
161	; * issue GET_DESCRIPTOR control request for first 8 bytes of configuration	184	; * issue GET_DESCRIPTOR control request for first 8 bytes of configuration
162	; descriptor (usb_get_descr_callback)	185	; descriptor (usb_get_descr_callback)
163	; * issue GET_DESCRIPTOR control request for full configuration descriptor	186	; * issue GET_DESCRIPTOR control request for full configuration descriptor
164	; (usb_know_length_callback)	187	; (usb_know_length_callback)
165	; * issue SET_CONFIGURATION control request (usb_set_config_callback)	188	; * issue SET_CONFIGURATION control request (usb_set_config_callback)
166	; * parse configuration descriptor, load the corresponding driver(s),	189	; * parse configuration descriptor, load the corresponding driver(s),
167	; pass the configuration descriptor to the driver and let the driver do	190	; pass the configuration descriptor to the driver and let the driver do
168	; the further work (usb_got_config_callback)	191	; the further work (usb_got_config_callback)
169		192
170	; This function is called from controller-specific part	193	; This function is called from controller-specific part
171	; when a new device is ready to be configured.	194	; when a new device is ready to be configured.
172	; in: ecx -> pseudo-pipe, part of usb_pipe	195	; in: ecx -> pseudo-pipe, part of usb_pipe
173	; in: esi -> usb_controller	196	; in: esi -> usb_controller
174	; in: [esi+usb_controller.ResettingHub] is the pointer to usb_hub for device,	197	; in: [esi+usb_controller.ResettingHub] is the pointer to usb_hub for device,
175	; NULL if the device is connected to the root hub	198	; NULL if the device is connected to the root hub
176	; in: [esi+usb_controller.ResettingPort] is the port for the device, zero-based	199	; in: [esi+usb_controller.ResettingPort] is the port for the device, zero-based
177	; in: [esi+usb_controller.ResettingSpeed] is the speed of the device, one of	200	; in: [esi+usb_controller.ResettingSpeed] is the speed of the device, one of
178	; USB_SPEED_xx.	201	; USB_SPEED_xx.
179	; out: eax = 0 <=> failed, the caller should disable the port.	202	; out: eax = 0 <=> failed, the caller should disable the port.
180	proc usb_new_device	203	proc usb_new_device
181	push ebx edi ; save used registers to be stdcall	204	push ebx edi ; save used registers to be stdcall
-		205	; 1. Check whether we're here because we were trying to reset
-		206	; already-registered device in hope to fix something serious.
-		207	; If so, skip allocation and go to 6.
-		208	movzx eax, [esi+usb_controller.ResettingPort]
-		209	mov edx, [esi+usb_controller.ResettingHub]
-		210	test edx, edx
-		211	jz .test_roothub
-		212	mov edx, [edx+usb_hub.ConnectedDevicesPtr]
-		213	mov ebx, [edx+eax*4]
-		214	jmp @f
-		215	.test_roothub:
-		216	mov ebx, [esi+usb_controller.DevicesByPort+eax*4]
-		217	@@:
-		218	test ebx, ebx
-		219	jnz .try_set_address
182	; 1. Allocate resources. Any device uses the following resources:	220	; 2. Allocate resources. Any device uses the following resources:
183	; - device address in the bus	221	; - device address in the bus
184	; - memory for device data	222	; - memory for device data
185	; - pipe for zero endpoint	223	; - pipe for zero endpoint
186	; If some allocation fails, we must undo our actions. Closing the pipe	224	; If some allocation fails, we must undo our actions. Closing the pipe
187	; is a hard task, so we avoid it and open the pipe as the last resource.	225	; is a hard task, so we avoid it and open the pipe as the last resource.
188	; The order for other two allocations is quite arbitrary.	226	; The order for other two allocations is quite arbitrary.
189	; 1a. Allocate a bus address.	227	; 2a. Allocate a bus address.
190	push ecx	228	push ecx
191	call usb_set_address_request	229	call usb_set_address_request
192	pop ecx	230	pop ecx
193	; 1b. If failed, just return zero.	231	; 2b. If failed, just return zero.
194	test eax, eax	232	test eax, eax
195	jz .nothing	233	jz .nothing
196	; 1c. Allocate memory for device data.	234	; 2c. Allocate memory for device data.
197	; For now, we need sizeof.usb_device_data and extra 8 bytes for GET_DESCRIPTOR	235	; For now, we need sizeof.usb_device_data and extra 8 bytes for GET_DESCRIPTOR
198	; input and output, see usb_after_set_address. Later we will reallocate it	236	; input and output, see usb_after_set_address. Later we will reallocate it
199	; to actual size needed for descriptors.	237	; to actual size needed for descriptors.
200	movi eax, sizeof.usb_device_data + 8	238	movi eax, sizeof.usb_device_data + 8
201	push ecx	239	push ecx
202	call malloc	240	call malloc
203	pop ecx	241	pop ecx
204	; 1d. If failed, free the bus address and return zero.	242	; 2d. If failed, free the bus address and return zero.
205	test eax, eax	243	test eax, eax
206	jz .nomemory	244	jz .nomemory
207	; 1e. Open pipe for endpoint zero.	245	; 2e. Open pipe for endpoint zero.
208	; For now, we do not know the actual maximum packet size;	246	; For now, we do not know the actual maximum packet size;
209	; for full-speed devices it can be any of 8, 16, 32, 64 bytes,	247	; for full-speed devices it can be any of 8, 16, 32, 64 bytes,
210	; low-speed devices must have 8 bytes, high-speed devices must have 64 bytes.	248	; low-speed devices must have 8 bytes, high-speed devices must have 64 bytes.
211	; Thus, we must use some fake "maximum packet size" until the actual size	249	; Thus, we must use some fake "maximum packet size" until the actual size
212	; will be known. However, the maximum packet size must be at least 8, and	250	; will be known. However, the maximum packet size must be at least 8, and
213	; initial stages of the configuration process involves only packets of <= 8	251	; initial stages of the configuration process involves only packets of <= 8
214	; bytes, they will be transferred correctly as long as	252	; bytes, they will be transferred correctly as long as
215	; the fake "maximum packet size" is also at least 8.	253	; the fake "maximum packet size" is also at least 8.
216	; Thus, any number >= 8 is suitable for actual hardware.	254	; Thus, any number >= 8 is suitable for actual hardware.
217	; However, software emulation of EHCI in VirtualBox assumes that high-speed	255	; However, software emulation of EHCI in VirtualBox assumes that high-speed
218	; control transfers are those originating from pipes with max packet size = 64,	256	; control transfers are those originating from pipes with max packet size = 64,
219	; even on early stages of the configuration process. This is incorrect,	257	; even on early stages of the configuration process. This is incorrect,
220	; but we have no specific preferences, so let VirtualBox be happy and use 64	258	; but we have no specific preferences, so let VirtualBox be happy and use 64
221	; as the fake "maximum packet size".	259	; as the fake "maximum packet size".
222	push eax	260	push eax
223	; We will need many zeroes.	261	; We will need many zeroes.
224	; "push edi" is one byte, "push 0" is two bytes; save space, use edi.	262	; "push edi" is one byte, "push 0" is two bytes; save space, use edi.
225	xor edi, edi	263	xor edi, edi
226	stdcall usb_open_pipe, ecx, edi, 64, edi, edi	264	stdcall usb_open_pipe, ecx, edi, 64, edi, edi
227	; Put pointer to pipe into ebx. "xchg eax,reg" is one byte, mov is two bytes.	265	; Put pointer to pipe into ebx. "xchg eax,reg" is one byte, mov is two bytes.
228	xchg eax, ebx	266	xchg eax, ebx
229	pop eax	267	pop eax
230	; 1f. If failed, free the memory, the bus address and return zero.	268	; 2f. If failed, free the memory, the bus address and return zero.
231	test ebx, ebx	269	test ebx, ebx
232	jz .freememory	270	jz .freememory
233	; 2. Store pointer to device data in the pipe structure.	271	; 3. Store pointer to device data in the pipe structure.
234	mov [ebx+usb_pipe.DeviceData], eax	272	mov [ebx+usb_pipe.DeviceData], eax
235	; 3. Init device data, using usb_controller.Resetting* variables.	273	; 4. Init device data, using usb_controller.Resetting* variables.
-		274	mov [eax+usb_device_data.Timer], edi
-		275	mov dword [eax+usb_device_data.DeviceDescriptor], TIMEOUT_SET_ADDRESS_INITIAL
236	mov [eax+usb_device_data.TTHub], edi	276	mov [eax+usb_device_data.TTHub], edi
237	mov [eax+usb_device_data.TTPort], 0	277	mov [eax+usb_device_data.TTPort], 0
238	mov [eax+usb_device_data.NumInterfaces], edi	278	mov [eax+usb_device_data.NumInterfaces], edi
239	mov [eax+usb_device_data.DeviceDescrSize], 0	279	mov [eax+usb_device_data.DeviceDescrSize], 0
240	mov dl, [esi+usb_controller.ResettingSpeed]	280	mov dl, [esi+usb_controller.ResettingSpeed]
241	mov [eax+usb_device_data.Speed], dl	281	mov [eax+usb_device_data.Speed], dl
242	mov [eax+usb_device_data.NumPipes], 1	282	mov [eax+usb_device_data.NumPipes], 1
243	push ebx	283	push ebx
244	cmp dl, USB_SPEED_HS	284	cmp dl, USB_SPEED_HS
245	jz .nott	285	jz .nott
246	mov ebx, [esi+usb_controller.ResettingHub]	286	mov ebx, [esi+usb_controller.ResettingHub]
247	test ebx, ebx	287	test ebx, ebx
248	jz .nott	288	jz .nott
249	mov cl, [esi+usb_controller.ResettingPort]	289	mov cl, [esi+usb_controller.ResettingPort]
250	mov edx, [ebx+usb_hub.ConfigPipe]	290	mov edx, [ebx+usb_hub.ConfigPipe]
251	mov edx, [edx+usb_pipe.DeviceData]	291	mov edx, [edx+usb_pipe.DeviceData]
252	cmp [edx+usb_device_data.TTHub], 0	292	cmp [edx+usb_device_data.TTHub], 0
253	jz @f	293	jz @f
254	mov cl, [edx+usb_device_data.TTPort]	294	mov cl, [edx+usb_device_data.TTPort]
255	mov ebx, [edx+usb_device_data.TTHub]	295	mov ebx, [edx+usb_device_data.TTHub]
256	jmp .has_tt	296	jmp .has_tt
257	@@:	297	@@:
258	cmp [edx+usb_device_data.Speed], USB_SPEED_HS	298	cmp [edx+usb_device_data.Speed], USB_SPEED_HS
259	jnz .nott	299	jnz .nott
260	.has_tt:	300	.has_tt:
261	mov [eax+usb_device_data.TTHub], ebx	301	mov [eax+usb_device_data.TTHub], ebx
262	mov [eax+usb_device_data.TTPort], cl	302	mov [eax+usb_device_data.TTPort], cl
263	.nott:	303	.nott:
264	pop ebx	304	pop ebx
265	mov [eax+usb_device_data.ConfigDataSize], edi	305	mov [eax+usb_device_data.ConfigDataSize], edi
266	mov [eax+usb_device_data.Interfaces], edi	306	mov [eax+usb_device_data.Interfaces], edi
267	movzx ecx, [esi+usb_controller.ResettingPort]	307	movzx ecx, [esi+usb_controller.ResettingPort]
268	mov [eax+usb_device_data.Port], cl	308	mov [eax+usb_device_data.Port], cl
269	mov edx, [esi+usb_controller.ResettingHub]	309	mov edx, [esi+usb_controller.ResettingHub]
270	mov [eax+usb_device_data.Hub], edx	310	mov [eax+usb_device_data.Hub], edx
271	; 4. Store pointer to the config pipe in the hub data.	311	; 5. Store pointer to the config pipe in the hub data.
272	; Config pipe serves as device identifier.	312	; Config pipe serves as device identifier.
273	; Root hubs use the array inside usb_controller structure,	313	; Root hubs use the array inside usb_controller structure,
274	; non-root hubs use the array immediately after usb_hub structure.	314	; non-root hubs use the array immediately after usb_hub structure.
275	test edx, edx	315	test edx, edx
276	jz .roothub	316	jz .roothub
277	mov edx, [edx+usb_hub.ConnectedDevicesPtr]	317	mov edx, [edx+usb_hub.ConnectedDevicesPtr]
278	mov [edx+ecx*4], ebx	318	mov [edx+ecx*4], ebx
279	jmp @f	319	jmp @f
280	.roothub:	320	.roothub:
281	mov [esi+usb_controller.DevicesByPort+ecx*4], ebx	321	mov [esi+usb_controller.DevicesByPort+ecx*4], ebx
282	@@:	322	@@:
283	call usb_reinit_pipe_list	323	call usb_reinit_pipe_list
284	; 5. Issue SET_ADDRESS control request, using buffer filled in step 1a.	324	; 6. Issue SET_ADDRESS control request, using buffer filled in step 2a.
285	; Use the return value from usb_control_async as our return value;	325	; 6a. Configure timer to force reset after timeout.
-		326	; Note: we can't use self-destructing timer, because we need to be able to cancel it,
-		327	; and for self-destructing timer we could have race condition in cancelling/destructing.
-		328	; DEBUGF 1,'K : pipe %x\n',ebx
-		329	.try_set_address:
-		330	xor edi, edi
-		331	mov edx, [ebx+usb_pipe.DeviceData]
-		332	stdcall timer_hs, [edx+usb_device_data.DeviceDescriptor], 7FFFFFFFh, usb_abort_pipe, ebx
-		333	test eax, eax
-		334	jz .nothing
-		335	mov edx, [ebx+usb_pipe.DeviceData]
-		336	mov [edx+usb_device_data.Timer], eax
286	; if it is zero, then something has failed.	337	; 6b. If it succeeded, setup timer to configure wait timeout.
287	lea eax, [esi+usb_controller.SetAddressBuffer]	338	lea eax, [esi+usb_controller.SetAddressBuffer]
288	stdcall usb_control_async, ebx, eax, edi, edi, usb_set_address_callback, edi, edi	339	stdcall usb_control_async, ebx, eax, edi, edi, usb_set_address_callback, edi, edi
-		340	; Use the return value from usb_control_async as our return value;
-		341	; if it is zero, then something has failed.
289	.nothing:	342	.nothing:
290	; 6. Return.	343	; 7. Return.
291	pop edi ebx ; restore used registers to be stdcall	344	pop edi ebx ; restore used registers to be stdcall
292	ret	345	ret
293	; Handlers of failures in steps 1b, 1d, 1f.	346	; Handlers of failures in steps 2b, 2d, 2f.
294	.freememory:	347	.freememory:
295	call free	348	call free
296	jmp .freeaddr	349	jmp .freeaddr
297	.nomemory:	350	.nomemory:
298	dbgstr 'No memory for device data'	351	dbgstr 'No memory for device data'
299	.freeaddr:	352	.freeaddr:
300	mov ecx, dword [esi+usb_controller.SetAddressBuffer+2]	353	mov ecx, dword [esi+usb_controller.SetAddressBuffer+2]
301	bts [esi+usb_controller.ExistingAddresses], ecx	354	bts [esi+usb_controller.ExistingAddresses], ecx
302	xor eax, eax	355	xor eax, eax
303	jmp .nothing	356	jmp .nothing
304	endp	357	endp
305		358
306	; Helper procedure for usb_new_device.	359	; Helper procedure for usb_new_device.
307	; Allocates a new USB address and fills usb_controller.SetAddressBuffer	360	; Allocates a new USB address and fills usb_controller.SetAddressBuffer
308	; with data for SET_ADDRESS(allocated_address) request.	361	; with data for SET_ADDRESS(allocated_address) request.
309	; out: eax = 0 <=> failed	362	; out: eax = 0 <=> failed
310	; Destroys edi.	363	; Destroys edi.
311	proc usb_set_address_request	364	proc usb_set_address_request
312	; There are 128 bits, one for each possible address.	365	; There are 128 bits, one for each possible address.
313	; Note: only the USB thread works with usb_controller.ExistingAddresses,	366	; Note: only the USB thread works with usb_controller.ExistingAddresses,
314	; so there is no need for synchronization.	367	; so there is no need for synchronization.
315	; We must find a bit set to 1 and clear it.	368	; We must find a bit set to 1 and clear it.
316	; 1. Find the first dword which has a nonzero bit = which is nonzero.	369	; 1. Find the first dword which has a nonzero bit = which is nonzero.
317	mov ecx, 128/32	370	mov ecx, 128/32
318	lea edi, [esi+usb_controller.ExistingAddresses]	371	lea edi, [esi+usb_controller.ExistingAddresses]
319	xor eax, eax	372	xor eax, eax
320	repz scasd	373	repz scasd
321	; 2. If all dwords are zero, return an error.	374	; 2. If all dwords are zero, return an error.
322	jz .error	375	jz .error
323	; 3. The dword at [edi-4] is nonzero. Find the lowest nonzero bit.	376	; 3. The dword at [edi-4] is nonzero. Find the lowest nonzero bit.
324	bsf eax, [edi-4]	377	bsf eax, [edi-4]
325	; Now eax = bit number inside the dword at [edi-4].	378	; Now eax = bit number inside the dword at [edi-4].
326	; 4. Clear the bit.	379	; 4. Clear the bit.
327	btr [edi-4], eax	380	btr [edi-4], eax
328	; 5. Generate the address by edi = memory address and eax = bit inside dword.	381	; 5. Generate the address by edi = memory address and eax = bit inside dword.
329	; Address = eax + 8 * (edi-4 - (esi+usb_controller.ExistingAddress)).	382	; Address = eax + 8 * (edi-4 - (esi+usb_controller.ExistingAddress)).
330	sub edi, esi	383	sub edi, esi
331	lea edi, [eax+(edi-4-usb_controller.ExistingAddresses)*8]	384	lea edi, [eax+(edi-4-usb_controller.ExistingAddresses)*8]
332	; 6. Store the allocated address in SetAddressBuffer and fill remaining fields.	385	; 6. Store the allocated address in SetAddressBuffer and fill remaining fields.
333	; Note that usb_controller is zeroed at allocation, so only command byte needs	386	; Note that usb_controller is zeroed at allocation, so only command byte needs
334	; to be filled.	387	; to be filled.
335	mov byte [esi+usb_controller.SetAddressBuffer+1], USB_SET_ADDRESS	388	mov byte [esi+usb_controller.SetAddressBuffer+1], USB_SET_ADDRESS
336	mov dword [esi+usb_controller.SetAddressBuffer+2], edi	389	mov dword [esi+usb_controller.SetAddressBuffer+2], edi
337	; 7. Return non-zero value in eax.	390	; 7. Return non-zero value in eax.
338	inc eax	391	inc eax
339	.nothing:	392	.nothing:
340	ret	393	ret
341	.error:	394	.error:
342	dbgstr 'cannot allocate USB address'	395	dbgstr 'cannot allocate USB address'
343	xor eax, eax	396	xor eax, eax
344	jmp .nothing	397	jmp .nothing
345	endp	398	endp
346		399
347	; This procedure is called by USB stack when SET_ADDRESS request initiated by	400	; This procedure is called by USB stack when SET_ADDRESS request initiated by
348	; usb_new_device is completed, either successfully or unsuccessfully.	401	; usb_new_device is completed, either successfully or unsuccessfully.
349	; Note that USB stack uses esi = pointer to usb_controller.	402	; Note that USB stack uses esi = pointer to usb_controller.
350	proc usb_set_address_callback stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword	403	proc usb_set_address_callback stdcall, pipe:dword, status:dword, buffer:dword, length:dword, calldata:dword
351	push ebx ; save ebx to be stdcall	404	push ebx ; save ebx to be stdcall
352	; Load data to registers for further references.	-
353	mov ebx, [pipe]	405	mov ebx, [pipe]
-		406	; 1. In any case, cancel the timer.
-		407	mov eax, [ebx+usb_pipe.DeviceData]
-		408	stdcall cancel_timer_hs, [eax+usb_device_data.Timer]
-		409	mov eax, [ebx+usb_pipe.DeviceData]
-		410	mov [eax+usb_device_data.Timer], 0
-		411	; Load data to registers for further references.
354	mov ecx, dword [esi+usb_controller.SetAddressBuffer+2]	412	mov ecx, dword [esi+usb_controller.SetAddressBuffer+2]
355	mov eax, [esi+usb_controller.HardwareFunc]	413	mov eax, [esi+usb_controller.HardwareFunc]
356	; 1. Check whether the device has accepted new address. If so, proceed to 2.	414	; 2. Check whether the device has accepted new address. If so, proceed to 3.
-		415	; Otherwise, go to 4 if killed by usb_set_address_timeout or to 5 otherwise.
-		416	cmp [status], USB_STATUS_CANCELLED
357	; Otherwise, go to 3.	417	jz .timeout
358	cmp [status], 0	418	cmp [status], 0
359	jnz .error	419	jnz .error
360	; 2. Address accepted.	420	; 3. Address accepted.
361	; 2a. The controller-specific structure for the control pipe still uses	421	; 3a. The controller-specific structure for the control pipe still uses
362	; zero address. Call the controller-specific function to change it to	422	; zero address. Call the controller-specific function to change it to
363	; the actual address.	423	; the actual address.
364	; Note that the hardware could cache the controller-specific structure,	424	; Note that the hardware could cache the controller-specific structure,
365	; so setting the address could take some time until the cache is evicted.	425	; so setting the address could take some time until the cache is evicted.
366	; Thus, the call is asynchronous; meet us in usb_after_set_address when it will	426	; Thus, the call is asynchronous; meet us in usb_after_set_address when it will
367	; be safe to continue.	427	; be safe to continue.
368	; dbgstr 'address set in device'	428	; dbgstr 'address set in device'
369	call [eax+usb_hardware_func.SetDeviceAddress]	429	call [eax+usb_hardware_func.SetDeviceAddress]
370	; 2b. If the port is in non-root hub, clear 'reset in progress' flag.	430	; 3b. If the port is in non-root hub, clear 'reset in progress' flag.
371	; In any case, proceed to 4.	431	; In any case, proceed to 6.
372	mov eax, [esi+usb_controller.ResettingHub]	432	mov eax, [esi+usb_controller.ResettingHub]
373	test eax, eax	433	test eax, eax
374	jz .return	434	jz .return
375	and [eax+usb_hub.Actions], not HUB_RESET_IN_PROGRESS	435	and [eax+usb_hub.Actions], not HUB_RESET_IN_PROGRESS
376	.return:	436	.return:
377	; 4. Address configuration done, we can proceed with other ports.	437	; 6. Address configuration done, we can proceed with other ports.
378	; Call the worker function for that.	438	; Call the worker function for that.
379	call usb_test_pending_port	439	call usb_test_pending_port
-		440	.wakeup:
-		441	push esi edi
-		442	call usb_wakeup
-		443	pop edi esi
380	.nothing:	444	.nothing:
381	pop ebx ; restore ebx to be stdcall	445	pop ebx ; restore ebx to be stdcall
382	ret	446	ret
-		447	.timeout:
-		448	; 4. Device continues to NAK the request. Reset it and retry.
-		449	mov edx, [ebx+usb_pipe.DeviceData]
-		450	mov ecx, [edx+usb_device_data.DeviceDescriptor]
-		451	add ecx, ecx
-		452	cmp ecx, TIMEOUT_SET_ADDRESS_LAST
-		453	ja .error
-		454	mov [edx+usb_device_data.DeviceDescriptor], ecx
-		455	dbgstr 'Timeout in USB device initialization, trying to reset...'
-		456	cmp [esi+usb_controller.ResettingHub], 0
-		457	jz .reset_roothub
-		458	push esi
-		459	mov esi, [esi+usb_controller.ResettingHub]
-		460	call usb_hub_initiate_reset
-		461	pop esi
-		462	jmp .nothing
-		463	.reset_roothub:
-		464	movzx ecx, [esi+usb_controller.ResettingPort]
-		465	call [eax+usb_hardware_func.InitiateReset]
-		466	jmp .wakeup
383	.error:	467	.error:
384	; 3. Device error: device not responding, disconnect etc.	468	; 5. Device error: device not responding, disconnect etc.
385	DEBUGF 1,'K : error %d in SET_ADDRESS, USB device disabled\n',[status]	469	DEBUGF 1,'K : error %d in SET_ADDRESS, USB device disabled\n',[status]
386	; 3a. The address has not been accepted. Mark it as free.	470	; 5a. The address has not been accepted. Mark it as free.
387	bts dword [esi+usb_controller.ExistingAddresses], ecx	471	bts dword [esi+usb_controller.ExistingAddresses], ecx
388	; 3b. Disable the port with bad device.	472	; 5b. Disable the port with bad device.
389	; For the root hub, call the controller-specific function and go to 6.	473	; For the root hub, call the controller-specific function and go to 6.
390	; For non-root hubs, let the hub code do its work and return (the request	474	; For non-root hubs, let the hub code do its work and return (the request
391	; could take some time, the hub code is responsible for proceeding).	475	; could take some time, the hub code is responsible for proceeding).
392	cmp [esi+usb_controller.ResettingHub], 0	476	cmp [esi+usb_controller.ResettingHub], 0
393	jz .roothub	477	jz .roothub
394	mov eax, [esi+usb_controller.ResettingHub]	478	mov eax, [esi+usb_controller.ResettingHub]
395	call usb_hub_disable_resetting_port	479	call usb_hub_disable_resetting_port
396	jmp .nothing	480	jmp .nothing
397	.roothub:	481	.roothub:
398	movzx ecx, [esi+usb_controller.ResettingPort]	482	movzx ecx, [esi+usb_controller.ResettingPort]
399	call [eax+usb_hardware_func.PortDisable]	483	call [eax+usb_hardware_func.PortDisable]
400	jmp .return	484	jmp .return
401	endp	485	endp
402		486
403	; This procedure is called from usb_subscription_done when the hardware cache	487	; This procedure is called from usb_subscription_done when the hardware cache
404	; is cleared after request from usb_set_address_callback.	488	; is cleared after request from usb_set_address_callback.
405	; in: ebx -> usb_pipe	489	; in: ebx -> usb_pipe
406	proc usb_after_set_address	490	proc usb_after_set_address
407	; dbgstr 'address set for controller'	491	; dbgstr 'address set for controller'
408	; Issue control transfer GET_DESCRIPTOR(DEVICE_DESCR) for first 8 bytes.	492	; Issue control transfer GET_DESCRIPTOR(DEVICE_DESCR) for first 8 bytes.
409	; Remember, we still do not know the actual packet size;	493	; Remember, we still do not know the actual packet size;
410	; 8-bytes-request is safe.	494	; 8-bytes-request is safe.
411	; usb_new_device has allocated 8 extra bytes besides sizeof.usb_device_data;	495	; usb_new_device has allocated 8 extra bytes besides sizeof.usb_device_data;
412	; use them for both input and output.	496	; use them for both input and output.
413	mov eax, [ebx+usb_pipe.DeviceData]	497	mov eax, [ebx+usb_pipe.DeviceData]
414	add eax, usb_device_data.DeviceDescriptor	498	add eax, usb_device_data.DeviceDescriptor
415	mov dword [eax], \	499	mov dword [eax], \

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/bus/usb/protocol.inc – Rev 4423 → 5201