;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; ;; Copyright (C) KolibriOS team 2013-2014. All rights reserved. ;; ;; Distributed under terms of the GNU General Public License ;; ;; ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; $Revision: 4850 $ ; 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(DEVICE) 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