forked from KolibriOS/kolibrios
1020 lines
44 KiB
PHP
1020 lines
44 KiB
PHP
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ;;
|
|
;; Copyright (C) KolibriOS team 2013-2015. All rights reserved. ;;
|
|
;; Distributed under terms of the GNU General Public License ;;
|
|
;; ;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
$Revision: 5363 $
|
|
|
|
|
|
; 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
|