WebSVN – Kolibri OS – Diff – /drivers/usb/ehci.asm

 ; Code for EHCI controllers.
+; Standard driver stuff
+format PE DLL native
+entry start
+__DEBUG__ equ 1
+__DEBUG_LEVEL__ equ 1
-; Note: it should be moved to an external driver,
+section '.reloc' data readable discardable fixups
-; it was convenient to have this code compiled into the kernel during initial
+section '.text' code readable executable
+include '../proc32.inc'
+include '../struct.inc'
+include '../macros.inc'
+include '../fdo.inc'
-; development, but there are no reasons to keep it here.
+include '../../kernel/trunk/bus/usb/common.inc'
 ; =============================================================================
 ; ================================= Constants =================================
 ; =============================================================================
 CapabilityParams        dd      ?
 ; Copy of EhciCapParamsReg value.
 DeferredActions         dd      ?
 ; Bitmask of events from EhciStatusReg which were observed by the IRQ handler
 ; and needs to be processed in the IRQ thread.
+PortRoutes              rb      16
+; Companion port route description.
+; Each byte describes routing of one port, value = PCI function.
+; This field must be the last one:
+; UHCI/OHCI code uses this field without knowing the entire structure.
 ends
 if ehci_controller.IntEDs mod 32
 .err Static endpoint descriptors must be 32-bytes aligned inside ehci_controller
 ; controller-independent code.
 ; Implements the structure usb_hardware_func from hccommon.inc for EHCI.
 iglobal
 align 4
 ehci_hardware_func:
+        dd      USBHC_VERSION
         dd      'EHCI'
         dd      sizeof.ehci_controller
+        dd      ehci_kickoff_bios
         dd      ehci_init
         dd      ehci_process_deferred
         dd      ehci_set_device_address
         dd      ehci_get_device_address
         dd      ehci_port_disable
         dd      ehci_alloc_td
         dd      ehci_free_td
         dd      ehci_alloc_transfer
         dd      ehci_insert_transfer
         dd      ehci_new_device
+ehci_name db    'EHCI',0
 endg
 ; =============================================================================
 ; =================================== Code ====================================
+; =============================================================================
+; Called once when driver is loading and once at shutdown.
+; When loading, must initialize itself, register itself in the system
+; and return eax = value obtained when registering.
+proc start
+virtual at esp
+                dd      ? ; return address
+.reason         dd      ? ; DRV_ENTRY or DRV_EXIT
+.cmdline        dd      ? ; normally NULL
+end virtual
+        cmp     [.reason], DRV_ENTRY
+        jnz     .nothing
+        mov     ecx, ehci_ep_mutex
+        invoke  MutexInit
+        mov     ecx, ehci_gtd_mutex
+        invoke  MutexInit
+        push    esi edi
+        mov     esi, [USBHCFunc]
+        mov     edi, usbhc_api
+        movi    ecx, sizeof.usbhc_func/4
+        rep movsd
+        pop     edi esi
+        invoke  RegUSBDriver, ehci_name, 0, ehci_hardware_func
+.nothing:
+        ret
-; =============================================================================
+endp
 ; Controller-specific initialization function.
 ; Called from usb_init_controller. Initializes the hardware and
 ; EHCI-specific parts of software structures.
 end if
 if (ehci_controller.IntEDs mod 0x1000) <> 0
 .err assertion failed
 end if
         add     eax, ehci_controller.IntEDs
-        call    get_phys_addr
+        call    [GetPhysAddr]
 ; 2b. Fill first 32 entries.
         inc     eax
         inc     eax     ; set Type to EHCI_TYPE_QH
         movi    ecx, 32
         mov     edx, ecx
 ; 3j. Initialize the head of Bulk list.
         sub     esi, sizeof.ehci_static_ep
         call    ehci_init_static_endpoint
 ; 4. Create a virtual memory area to talk with the controller.
 ; 4a. Enable memory & bus master access.
-        mov     ch, [.bus]
-        mov     cl, 1
-        mov     eax, ecx
-        mov     bh, [.devfn]
+        invoke  PciRead16, dword [.bus], dword [.devfn], 4
-        mov     bl, 4
-        call    pci_read_reg
         or      al, 6
-        xchg    eax, ecx
-        call    pci_write_reg
+        invoke  PciWrite16, dword [.bus], dword [.devfn], 4, eax
 ; 4b. Read memory base address.
-        mov     ah, [.bus]
+        invoke  PciRead32, dword [.bus], dword [.devfn], 10h
-        mov     al, 2
-        mov     bl, 10h
-        call    pci_read_reg
 ;       DEBUGF 1,'K : phys MMIO %x\n',eax
         and     al, not 0Fh
 ; 4c. Create mapping for physical memory. 200h bytes are always sufficient.
-        stdcall map_io_mem, eax, 200h, PG_SW+PG_NOCACHE
+        invoke  MapIoMem, eax, 200h, PG_SW+PG_NOCACHE
         test    eax, eax
         jz      .fail
 ;       DEBUGF 1,'K : MMIO %x\n',eax
 if ehci_controller.MMIOBase1 <> ehci_controller.BulkED + sizeof.ehci_static_ep
 .err assertion failed
 end if
         stosd   ; fill ehci_controller.MMIOBase1
+; 5. Read basic parameters of the controller.
+; 5a. Structural parameters.
+        mov     ebx, [eax+EhciStructParamsReg]
+; 5b. Port routing rules.
+; If bit 7 in HCSPARAMS is set, read and unpack EhciPortRouteReg.
+; Otherwise, bits 11:8 are N_PCC = number of ports per companion,
+; bits 15:12 are number of companions, maybe zero,
+; first N_PCC ports are routed to the first companion and so on.
+        xor     esi, esi
+        test    bl, bl
+        js      .read_routes
+        test    bh, 0x0F
+        jz      .no_companions
+        test    bh, 0xF0
+        jz      .no_companions
+        xor     edx, edx
+.fill_routes:
+        movzx   ecx, bh
+        and     ecx, 15
+@@:
+        mov     byte [edi+esi+ehci_controller.PortRoutes-(ehci_controller.MMIOBase1+4)], dl
+        inc     esi
+        cmp     esi, 16
+        jz      .routes_filled
+        dec     ecx
+        jnz     @b
+        movzx   ecx, bh
+        shr     ecx, 4
+        inc     edx
+        cmp     edx, ecx
+        jb      .fill_routes
+.no_companions:
+        mov     byte [edi+esi+ehci_controller.PortRoutes-(ehci_controller.MMIOBase1+4)], 0xFF
+        inc     esi
+        cmp     esi, 16
+        jnz     .no_companions
+        jmp     .routes_filled
+.read_routes:
+rept 2 counter
+{
+        mov     ecx, [eax+EhciPortRouteReg+(counter-1)*4]
+@@:
+        mov     edx, ecx
+        shr     ecx, 4
+        and     edx, 15
+        mov     byte [edi+esi+ehci_controller.PortRoutes-(ehci_controller.MMIOBase1+4)], dl
+        inc     esi
+        cmp     esi, 8*counter
+        jnz     @b
+}
+.routes_filled:
+;        DEBUGF 1,'K : EhciPortRouteReg: %x %x\n',[eax+EhciPortRouteReg],[eax+EhciPortRouteReg+4]
+;        DEBUGF 1,'K : routes:\nK : '
+;rept 8 counter
+;{
+;        DEBUGF 1,' %x',[edi+ehci_controller.PortRoutes-(ehci_controller.MMIOBase1+4)+counter-1]:2
+;}
+;        DEBUGF 1,'\nK : '
+;rept 8 counter
+;{
+;        DEBUGF 1,' %x',[edi+ehci_controller.PortRoutes+8-(ehci_controller.MMIOBase1+4)+counter-1]:2
+;}
+;        DEBUGF 1,'\n'
         movzx   ecx, byte [eax+EhciCapLengthReg]
         mov     edx, [eax+EhciCapParamsReg]
-        mov     ebx, [eax+EhciStructParamsReg]
         add     eax, ecx
 if ehci_controller.MMIOBase2 <> ehci_controller.MMIOBase1 + 4
 .err assertion failed
 end if
         stosd   ; fill ehci_controller.MMIOBase2
         test    dword [edi+EhciStatusReg], 1 shl 12
         jnz     .stopped
         and     dword [edi+EhciCommandReg], not 1
 @@:
         movi    esi, 1
-        call    delay_ms
+        invoke  Sleep
         test    dword [edi+EhciStatusReg], 1 shl 12
         jnz     .stopped
         loop    @b
         dbgstr 'Failed to stop EHCI controller'
         jmp     .fail_unmap
 ; 6c. Reset the controller. Wait up to 50 ms checking status every 1 ms.
         or      dword [edi+EhciCommandReg], 2
         movi    ecx, 50
 @@:
         movi    esi, 1
-        call    delay_ms
+        invoke  Sleep
         test    dword [edi+EhciCommandReg], 2
         jz      .reset_ok
         loop    @b
         dbgstr 'Failed to reset EHCI controller'
         jmp     .fail_unmap
         test    byte [esi+ehci_controller.CapabilityParams-sizeof.ehci_controller], 1
         jz      @f
         mov     dword [edi+EhciCtrlDataSegReg], 0
 @@:
 ; 7b. Hook interrupt and enable appropriate interrupt sources.
-        mov     ah, [.bus]
-        mov     al, 0
-        mov     bh, [.devfn]
+        invoke  PciRead8, dword [.bus], dword [.devfn], 3Ch
-        mov     bl, 3Ch
-        call    pci_read_reg
 ; al = IRQ
-        DEBUGF 1,'K : attaching to IRQ %x\n',al
+;        DEBUGF 1,'K : attaching to IRQ %x\n',al
         movzx   eax, al
-        stdcall attach_int_handler, eax, ehci_irq, esi
+        invoke  AttachIntHandler, eax, ehci_irq, esi
 ;       mov     dword [edi+EhciStatusReg], 111111b      ; clear status
 ; disable Frame List Rollover interrupt, enable all other sources
         mov     dword [edi+EhciInterruptReg], 110111b
 ; 7c. Inform the controller of the address of periodic lists head.
         lea     eax, [esi-sizeof.ehci_controller]
-        call    get_phys_addr
+        invoke  GetPhysAddr
         mov     dword [edi+EhciPeriodicListReg], eax
 ; 7d. Inform the controller of the address of asynchronous lists head.
         lea     eax, [esi+ehci_controller.ControlED-sizeof.ehci_controller]
-        call    get_phys_addr
+        invoke  GetPhysAddr
         mov     dword [edi+EhciAsyncListReg], eax
 ; 7e. Configure operational details and run the controller.
         mov     dword [edi+EhciCommandReg], \
                 (1 shl 16) + \ ; interrupt threshold = 1 microframe = 0.125ms
                 (0 shl 11) + \ ; disable Async Park Mode
         jb      @b
         test    byte [esi+ehci_controller.StructuralParams-sizeof.ehci_controller], 10h
         jz      @f
         push    esi
         movi    esi, 20
-        call    delay_ms
+        invoke  Sleep
         pop     esi
 @@:
 ; 9. Return pointer to usb_controller.
         xchg    eax, esi
         ret
 ; Note that the main code branch restores the stack at step 7 and never fails
 ; after step 7.
 .fail_unmap:
         pop     eax
         push    eax
-        stdcall free_kernel_space, [eax+ehci_controller.MMIOBase1]
+        invoke  FreeKernelSpace, [eax+ehci_controller.MMIOBase1]
 .fail:
         pop     ecx
         xor     eax, eax
         ret
 endp
         mov     [edi+ehci_static_ep.NextTD], eax
         mov     [edi+ehci_static_ep.AlternateNextTD], eax
         test    esi, esi
         jz      @f
         mov     eax, esi
-        call    get_phys_addr
+        invoke  GetPhysAddr
         inc     eax
         inc     eax     ; set Type to EHCI_TYPE_QH
 @@:
         mov     [edi+ehci_static_ep.NextQH], eax
         mov     [edi+ehci_static_ep.NextList], esi
         mov     byte [edi+ehci_static_ep.OverlayToken], 1 shl 6 ; halted
         add     edi, ehci_static_ep.SoftwarePart
+        mov     eax, [USBHCFunc]
-        call    usb_init_static_endpoint
+        call    [eax+usbhc_func.usb_init_static_endpoint]
         add     edi, sizeof.ehci_static_ep - ehci_static_ep.SoftwarePart
         ret
 endp
 ; to support USB flash drives. In this case,
 ; we must notify the BIOS that we don't need that emulation and know how to
 ; deal with USB devices.
 proc ehci_kickoff_bios
 ; 1. Get the physical address of MMIO registers.
-        mov     ah, [esi+PCIDEV.bus]
-        mov     bh, [esi+PCIDEV.devfn]
+        invoke  PciRead32, dword [esi+PCIDEV.bus], dword [esi+PCIDEV.devfn], 10h
-        mov     al, 2
-        mov     bl, 10h
-        call    pci_read_reg
         and     al, not 0Fh
 ; 2. Create mapping for physical memory. 200h bytes are always sufficient.
-        stdcall map_io_mem, eax, 200h, PG_SW+PG_NOCACHE
+        invoke  MapIoMem, eax, 200h, PG_SW+PG_NOCACHE
         test    eax, eax
         jz      .nothing
         push    eax     ; push argument for step 8
 ; 3. Some BIOSes enable controller interrupts as a result of giving
 ; controller away. At this point the system knows nothing about how to serve
         jb      .no_capability
 .look_bios_handoff:
         test    bl, 3
         jnz     .no_capability
 ; In each iteration, read the current dword,
-        mov     ah, [esi+PCIDEV.bus]
-        mov     al, 2
-        mov     bh, [esi+PCIDEV.devfn]
+        invoke  PciRead32, dword [esi+PCIDEV.bus], dword [esi+PCIDEV.devfn], ebx
-        call    pci_read_reg
 ; check, whether the capability ID is take-ownership ID = 1,
         cmp     al, 1
         jz      .found_bios_handoff
 ; if not, advance to next-capability link and continue loop.
         dec     byte [esp]
         inc     ebx
         test    eax, 0x10000
         jz      .has_ownership
 ; 4c. Request ownership.
         inc     ebx
-        mov     cl, 1
-        mov     ah, [esi+PCIDEV.bus]
+        invoke  PciWrite8, dword [esi+PCIDEV.bus], dword [esi+PCIDEV.devfn], ebx, 1
-        mov     al, 0
-        call    pci_write_reg
 ; 4d. Some BIOSes set ownership flag, but forget to watch for change-ownership
 ; requests; if so, there is no sense in waiting.
         inc     ebx
-        mov     ah, [esi+PCIDEV.bus]
+        invoke  PciRead32, dword [esi+PCIDEV.bus], dword [esi+PCIDEV.devfn], ebx
-        mov     al, 2
-        call    pci_read_reg
         dec     ebx
         dec     ebx
         test    ah, 20h
         jz      .force_ownership
 ; 4e. Wait for result no more than 1 s, checking for status every 1 ms.
 ; If successful, go to 5.
         mov     dword [esp], 1000
 @@:
-        mov     ah, [esi+PCIDEV.bus]
+        invoke  PciRead8, dword [esi+PCIDEV.bus], dword [esi+PCIDEV.devfn], ebx
-        mov     al, 0
-        call    pci_read_reg
         test    al, 1
         jz      .has_ownership
         push    esi
         movi    esi, 1
-        call    delay_ms
+        invoke  Sleep
         pop     esi
         dec     dword [esp]
         jnz     @b
         dbgstr  'warning: taking EHCI ownership from BIOS timeout'
 .force_ownership:
 ; 4f. BIOS has not responded within the timeout.
 ; Let's just clear BIOS ownership flag and hope that everything will be ok.
-        mov     ah, [esi+PCIDEV.bus]
+        invoke  PciWrite8, dword [esi+PCIDEV.bus], dword [esi+PCIDEV.devfn], ebx, 0
-        mov     al, 0
-        mov     cl, 0
-        call    pci_write_reg
 .has_ownership:
 ; 5. Just in case clear all SMI event sources except change-ownership.
         dbgstr 'has_ownership'
         inc     ebx
         inc     ebx
-        mov     ah, [esi+PCIDEV.bus]
+        invoke  PciRead16, dword [esi+PCIDEV.bus], dword [esi+PCIDEV.devfn], ebx
-        mov     al, 2
-        mov     ecx, eax
-        call    pci_read_reg
         and     ax, 2000h
-        xchg    eax, ecx
-        call    pci_write_reg
+        invoke  PciWrite16, dword [esi+PCIDEV.bus], dword [esi+PCIDEV.devfn], ebx, eax
 .has_ownership2:
         pop     ecx
 ; 6. Disable all controller interrupts until the system will be ready to
 ; process them.
         mov     dword [edi+EhciInterruptReg], 0
 ; 7. Now we can unblock interrupts in the processor.
         popf
 ; 8. Release memory mapping created in step 2 and return.
-        call    free_kernel_space
+        invoke  FreeKernelSpace
 .nothing:
         ret
 endp
 ; 2. Get the mask of events which should be processed.
         mov     esi, [.controller]
         mov     edi, [esi+ehci_controller.MMIOBase2-sizeof.ehci_controller]
         spin_lock_irqsave [esi+usb_controller.WaitSpinlock]
         mov     eax, [edi+EhciStatusReg]
-;       DEBUGF 1,'K : [%d] EHCI status %x\n',[timer_ticks],eax
 ; 3. Check whether that interrupt has been generated by our controller.
 ; (One IRQ can be shared by several devices.)
         and     eax, [edi+EhciInterruptReg]
         jz      .noint
 ; 4. Clear the events we know of.
 ; We can't do too much from an interrupt handler. Inform the processing thread
 ; that it should perform appropriate actions.
         or      [esi+ehci_controller.DeferredActions-sizeof.ehci_controller], eax
         spin_unlock_irqrestore [esi+usb_controller.WaitSpinlock]
         inc     ebx
-        call    usb_wakeup_if_needed
+        invoke  usbhc_api.usb_wakeup_if_needed
 ; 6. Interrupt processed; return non-zero.
         mov     al, 1
         pop     edi esi ebx     ; restore used registers to be cdecl
         ret
 endp
 ; This procedure is called from usb_set_address_callback
 ; and stores USB device address in the ehci_pipe structure.
 ; in: esi -> usb_controller, ebx -> usb_pipe, cl = address
 proc ehci_set_device_address
         mov     byte [ebx+ehci_pipe.Token-sizeof.ehci_pipe], cl
-        call    usb_subscribe_control
+        jmp     [usbhc_api.usb_subscribe_control]
-        ret
 endp
 ; This procedure returns USB device address from the ehci_pipe structure.
 ; in: esi -> usb_controller, ebx -> usb_pipe
         and     eax, not (0x7FF shl 16)
         shl     ecx, 16
         or      eax, ecx
         mov     [ebx+ehci_pipe.Token-sizeof.ehci_pipe], eax
 ; Wait until hardware cache is evicted.
-        call    usb_subscribe_control
+        jmp     [usbhc_api.usb_subscribe_control]
-        ret
 endp
 uglobal
 align 4
 ; Both hardware+software parts must be allocated, returns pointer to usb_pipe
 ; (software part).
 proc ehci_alloc_pipe
         push    ebx
         mov     ebx, ehci_ep_mutex
-        stdcall usb_allocate_common, (sizeof.ehci_pipe + sizeof.usb_pipe + 1Fh) and not 1Fh
+        invoke  usbhc_api.usb_allocate_common, (sizeof.ehci_pipe + sizeof.usb_pipe + 1Fh) and not 1Fh
         test    eax, eax
         jz      @f
         add     eax, sizeof.ehci_pipe
 @@:
         pop     ebx
 virtual at esp
         dd      ?       ; return address
 .ptr    dd      ?
 end virtual
         sub     [.ptr], sizeof.ehci_pipe
-        jmp     usb_free_common
+        jmp     [usbhc_api.usb_free_common]
 endp
 ; This procedure is called from API usb_open_pipe and processes
 ; the controller-specific part of this API. See docs.
         mov     [eax+ehci_gtd.Token-sizeof.ehci_gtd], edx
         mov     [eax+ehci_gtd.NextTD-sizeof.ehci_gtd], 1
         mov     [eax+ehci_gtd.AlternateNextTD-sizeof.ehci_gtd], 1
 ; 3. Store physical address of the first TD.
         sub     eax, sizeof.ehci_gtd
-        call    get_phys_addr
+        call    [GetPhysAddr]
         mov     [edi+ehci_pipe.Overlay.NextTD-sizeof.ehci_pipe], eax
 ; 4. Fill ehci_pipe.Flags except for S- and C-masks.
 ; Copy location from the config pipe.
         mov     eax, [ecx+ehci_pipe.Flags-sizeof.ehci_pipe]
         and     eax, 3FFF0000h
 ; 5d. Insert in the hardware list: copy previous NextQH to the new pipe,
 ; store the physical address of the new pipe to previous NextQH.
         mov     ecx, [edx+ehci_static_ep.NextQH-ehci_static_ep.SoftwarePart]
         mov     [edi+ehci_pipe.NextQH-sizeof.ehci_pipe], ecx
         lea     eax, [edi-sizeof.ehci_pipe]
-        call    get_phys_addr
+        call    [GetPhysAddr]
         inc     eax
         inc     eax
         mov     [edx+ehci_static_ep.NextQH-ehci_static_ep.SoftwarePart], eax
 ; 6. Return with nonzero eax.
         ret
 ; and therefore is ready to be configured.
 ; ecx = port, esi -> ehci_controller, edi -> EHCI MMIO
 proc ehci_new_port
 ; 1. If the device operates at low-speed, just release it to a companion.
         mov     eax, [edi+EhciPortsReg+ecx*4]
-        DEBUGF 1,'K : [%d] EHCI %x port %d state is %x\n',[timer_ticks],esi,ecx,eax
+        DEBUGF 1,'K : EHCI %x port %d state is %x\n',esi,ecx,eax
         mov     edx, eax
         and     ah, 0Ch
         cmp     ah, 4
         jz      .low_speed
 ; 2. Devices operating at full-speed and high-speed must now have ah == 8.
 ; 2. Initiate reset signalling.
         or      ah, 1
         and     al, not (4 or 2Ah)
         mov     [edi+EhciPortsReg+ecx*4], eax
 ; 3. Store the current time and set status to 1 = reset signalling active.
-        mov     eax, [timer_ticks]
+        invoke  GetTimerTicks
         mov     [esi+usb_controller.ResetTime], eax
         mov     [esi+usb_controller.ResettingStatus], 1
 ;       dbgstr 'high-speed or full-speed device, resetting'
-        DEBUGF 1,'K : [%d] EHCI %x: port %d has HS or FS device, resetting\n',[timer_ticks],esi,ecx
+        DEBUGF 1,'K : EHCI %x: port %d has HS or FS device, resetting\n',esi,ecx
         pop     edi
 .nothing:
         ret
 .low_speed:
 ;       dbgstr 'low-speed device, releasing'
-        DEBUGF 1,'K : [%d] EHCI %x: port %d has LS device, releasing\n',[timer_ticks],esi,ecx
+        DEBUGF 1,'K : EHCI %x: port %d has LS device, releasing\n',esi,ecx
         or      dh, 20h
         and     dl, not 2Ah
         mov     [edi+EhciPortsReg+ecx*4], edx
         ret
 .se1:
         jbe     .lastpacket
 ; 2. While the remaining data cannot fit in one descriptor,
 ; allocate full descriptors (of maximal possible size).
 ; 2a. Calculate size of one descriptor: must be a multiple of transfer size
 ; and must be not greater than 4001h.
-        movzx   ecx, word [ebx+ohci_pipe.Flags+2-sizeof.ohci_pipe]
+        movzx   ecx, word [ebx+ehci_pipe.Token+2-sizeof.ehci_pipe]
+        and     ecx, (1 shl 11) - 1
         mov     eax, 4001h
         xor     edx, edx
         mov     edi, eax
         div     ecx
         sub     edi, edx
         jmp     @f
 .disable_short:
         mov     eax, [ebx+usb_pipe.Controller]
         add     eax, ehci_controller.StopQueueTD - sizeof.ehci_controller
 @@:
-        call    get_phys_addr
+        call    [GetPhysAddr]
         mov     edx, [origTD]
 @@:
         cmp     edx, [esp]
         jz      @f
         mov     [edx+ehci_gtd.AlternateNextTD-sizeof.ehci_gtd], eax
         pop     eax
         ret
 .fail:
         mov     edi, ehci_hardware_func
         mov     eax, [td]
-        stdcall usb_undo_tds, [origTD]
+        invoke  usbhc_api.usb_undo_tds, [origTD]
         xor     eax, eax
         ret
 endp
         call    ehci_alloc_td
         test    eax, eax
         jz      .nothing
 ; 2. Initialize controller-independent parts of both TDs.
         push    eax
-        call    usb_init_transfer
+        invoke  usbhc_api.usb_init_transfer
         pop     eax
 ; 3. Copy PID to the new descriptor.
         mov     edx, [ecx+ehci_gtd.Token-sizeof.ehci_gtd]
         mov     [eax+ehci_gtd.Token-sizeof.ehci_gtd], edx
         mov     [eax+ehci_gtd.NextTD-sizeof.ehci_gtd], 1
         mov     [eax+ehci_gtd.AlternateNextTD-sizeof.ehci_gtd], 1
 ; 4. Save the returned value (next descriptor).
         push    eax
 ; 5. Store the physical address of the next descriptor.
         sub     eax, sizeof.ehci_gtd
-        call    get_phys_addr
+        call    [GetPhysAddr]
         mov     [ecx+ehci_gtd.NextTD-sizeof.ehci_gtd], eax
 ; 6. For zero-length transfers, store zero in all fields for buffer addresses.
 ; Otherwise, fill them with real values.
         xor     eax, eax
         mov     [ecx+ehci_gtd.Flags-sizeof.ehci_gtd], eax
         mov     [ecx+ehci_gtd.BufferPointers-sizeof.ehci_gtd+(%-1)*4], eax
 end repeat
         cmp     [.packetSize], eax
         jz      @f
         mov     eax, [.buffer]
-        call    get_phys_addr
+        call    [GetPhysAddr]
         mov     [ecx+ehci_gtd.BufferPointers-sizeof.ehci_gtd], eax
         and     eax, 0xFFF
         mov     edx, [.packetSize]
         add     edx, eax
         sub     edx, 0x1000
         jbe     @f
         mov     eax, [.buffer]
         add     eax, 0x1000
-        call    get_pg_addr
+        call    [GetPgAddr]
         mov     [ecx+ehci_gtd.BufferPointers+4-sizeof.ehci_gtd], eax
         sub     edx, 0x1000
         jbe     @f
         mov     eax, [.buffer]
         add     eax, 0x2000
-        call    get_pg_addr
+        call    [GetPgAddr]
         mov     [ecx+ehci_gtd.BufferPointers+8-sizeof.ehci_gtd], eax
         sub     edx, 0x1000
         jbe     @f
         mov     eax, [.buffer]
         add     eax, 0x3000
-        call    get_pg_addr
+        call    [GetPgAddr]
         mov     [ecx+ehci_gtd.BufferPointers+12-sizeof.ehci_gtd], eax
         sub     edx, 0x1000
         jbe     @f
         mov     eax, [.buffer]
         add     eax, 0x4000
-        call    get_pg_addr
+        call    [GetPgAddr]
         mov     [ecx+ehci_gtd.BufferPointers+16-sizeof.ehci_gtd], eax
 @@:
 ; 7. Fill Token field:
 ; set Status = 0 (inactive, ehci_insert_transfer would mark everything active);
 ; keep current PID if [.direction] is zero, use two lower bits of [.direction]
 ; This function is called from ehci_process_deferred when
 ; reset signalling for a new device needs to be finished.
 proc ehci_port_reset_done
         movzx   ecx, [esi+usb_controller.ResettingPort]
         and     dword [edi+EhciPortsReg+ecx*4], not 12Ah
-        mov     eax, [timer_ticks]
+        invoke  GetTimerTicks
         mov     [esi+usb_controller.ResetTime], eax
         mov     [esi+usb_controller.ResettingStatus], 2
-        DEBUGF 1,'K : [%d] EHCI %x: reset port %d done\n',[timer_ticks],esi,ecx
+;        DEBUGF 1,'K : EHCI %x: reset port %d done\n',esi,ecx
         ret
 endp
 ; This function is called from ehci_process_deferred when
 ; If reset has been failed (device disconnected during reset),
 ; continue to next device (if there is one).
         xor     eax, eax
         xchg    al, [esi+usb_controller.ResettingStatus]
         test    al, al
+        jns     @f
-        js      usb_test_pending_port
+        jmp     [usbhc_api.usb_test_pending_port]
+@@:
 ; 2. Get the port status. High-speed devices should be now enabled,
 ; full-speed devices are left disabled;
 ; if the port is disabled, release it to a companion and continue to
 ; next device (if there is one).
         movzx   ecx, [esi+usb_controller.ResettingPort]
         mov     eax, [edi+EhciPortsReg+ecx*4]
-        DEBUGF 1,'K : [%d] EHCI %x status of port %d is %x\n',[timer_ticks],esi,ecx,eax
+        DEBUGF 1,'K : EHCI %x status of port %d is %x\n',esi,ecx,eax
         test    al, 4
         jnz     @f
 ;       DEBUGF 1,'K : USB port disabled after reset, status = %x\n',eax
         dbgstr 'releasing to companion'
         or      ah, 20h
         mov     [edi+EhciPortsReg+ecx*4], eax
-        jmp     usb_test_pending_port
+        jmp     [usbhc_api.usb_test_pending_port]
 @@:
 ; 3. Call the worker procedure to notify the protocol layer
 ; about new EHCI device. It is high-speed.
         movi    eax, USB_SPEED_HS
         call    ehci_new_device
         jnz     .nothing
 ; 4. If something at the protocol layer has failed
 ; (no memory, no bus address), disable the port and stop the initialization.
 .disable_exit:
         and     dword [edi+EhciPortsReg+ecx*4], not (4 or 2Ah)
-        jmp     usb_test_pending_port
+        jmp     [usbhc_api.usb_test_pending_port]
 .nothing:
         ret
 endp
         jz      .common
 ; 4. For low-speed and full-speed devices, fill address:port
 ; of the last high-speed hub (the closest to the device hub)
 ; for split transactions, and set ControlEndpoint bit in eax;
 ; ehci_init_pipe assumes that the parent pipe is a control pipe.
+        push    eax
         movzx   ecx, [esi+usb_controller.ResettingPort]
         mov     edx, [esi+usb_controller.ResettingHub]
-; If the parent hub is high-speed, it is TT for the device.
-; Otherwise, the parent hub itself is behind TT, and the device
-; has the same TT hub+port as the parent hub.
-        push    eax
-        mov     eax, [edx+usb_hub.ConfigPipe]
-        mov     eax, [eax+usb_pipe.DeviceData]
-        cmp     [eax+usb_device_data.Speed], USB_SPEED_HS
-        jz      @f
-        movzx   ecx, [eax+usb_device_data.TTPort]
+        invoke  usbhc_api.usb_get_tt
-        mov     edx, [eax+usb_device_data.TTHub]
-@@:
-        mov     edx, [edx+usb_hub.ConfigPipe]
         inc     ecx
         mov     edx, [edx+ehci_pipe.Token-sizeof.ehci_pipe]
         shl     ecx, 23
         and     edx, 7Fh
         shl     edx, 16
         mov     ecx, esp
         sub     esp, sizeof.ehci_pipe - ehci_pipe.Flags - 4
         push    edx     ; ehci_pipe.Flags
         push    eax     ; ehci_pipe.Token
 ; 6. Notify the protocol layer.
-        call    usb_new_device
+        invoke  usbhc_api.usb_new_device
 ; 7. Cleanup the stack after step 5 and return.
         add     esp, sizeof.ehci_pipe - ehci_pipe.Flags + 8
         pop     ecx ebx ; restore used registers
         ret
 endp
 ; the first read and the clearing, invalidating the old status. If an event
 ; occurs after the clearing, we will not miss it, looking in the next scan.
         mov     [edi+EhciPortsReg+ecx*4], eax
         mov     ebx, eax
         mov     eax, [edi+EhciPortsReg+ecx*4]
-        DEBUGF 1,'K : [%d] EHCI %x: status of port %d changed to %x\n',[timer_ticks],esi,ecx,ebx
+        DEBUGF 1,'K : EHCI %x: status of port %d changed to %x\n',esi,ecx,ebx
 ; 3e. Handle overcurrent.
 ; Note: that needs work.
         test    bl, 20h ; overcurrent change
         jz      .noovercurrent
         test    al, 10h ; overcurrent active
 ; 3h. Change connected status. For the connection event, also store
 ; the connection time; any further processing is permitted only after
 ; USB_CONNECT_DELAY ticks.
         test    al, 1
         jz      .disconnect
-        mov     eax, [timer_ticks]
+        invoke  GetTimerTicks
         mov     [esi+usb_controller.ConnectedTime+ecx*4], eax
         bts     [esi+usb_controller.NewConnected], ecx
         jmp     .nextport
 .disconnect:
         btr     [esi+usb_controller.NewConnected], ecx
         cmp     ecx, [esi+usb_controller.NumPorts]
         jb      .portloop
 .skip_roothub:
 ; 4. Process disconnect events. This should be done after step 3
 ; (which includes the first stage of disconnect processing).
-        call    usb_disconnect_stage2
+        invoke  usbhc_api.usb_disconnect_stage2
 ; 5. Check for previously connected devices.
 ; If there is a connected device which was connected less than
 ; USB_CONNECT_DELAY ticks ago, plan to wake up when the delay will be over.
 ; Otherwise, call ehci_new_port.
 ; This should be done after step 3.
         cmp     [esi+usb_controller.NewConnected], ecx
         jz      .skip_newconnected
 .portloop2:
         bt      [esi+usb_controller.NewConnected], ecx
         jnc     .noconnect
-        mov     eax, [timer_ticks]
+        invoke  GetTimerTicks
         sub     eax, [esi+usb_controller.ConnectedTime+ecx*4]
         sub     eax, USB_CONNECT_DELAY
         jge     .connected
         neg     eax
         cmp     [esp], eax
 .noperiodic:
 ; 6b. Asynchronous endpoints.
 ; Satisfy a request when InterruptOnAsyncAdvance fired.
         test    byte [esp+4], 20h
         jz      @f
-        dbgstr 'async advance int'
+;        dbgstr 'async advance int'
         mov     eax, [esi+usb_controller.WaitPipeRequestAsync]
         mov     [esi+usb_controller.ReadyPipeHeadAsync], eax
 @@:
 ; Some hardware in some (rarely) conditions set the status bit,
 ; but just does not generate the corresponding interrupt.
 .test_reset:
 ; 8a. Test whether reset signalling is active.
         cmp     [esi+usb_controller.ResettingStatus], 1
         jnz     .no_reset_in_progress
 ; 8b. Yep. Test whether it should be stopped.
-        mov     eax, [timer_ticks]
+        invoke  GetTimerTicks
         sub     eax, [esi+usb_controller.ResetTime]
         sub     eax, USB_RESET_TIME
         jge     .reset_done
 ; 8c. Not yet, but initiate wakeup in -eax ticks and exit this step.
         neg     eax
 .no_reset_in_progress:
 ; 8e. Test whether reset process is done, either successful or failed.
         cmp     [esi+usb_controller.ResettingStatus], 0
         jz      .skip_reset
 ; 8f. Yep. Test whether it should be stopped.
-        mov     eax, [timer_ticks]
+        invoke  GetTimerTicks
         sub     eax, [esi+usb_controller.ResetTime]
         sub     eax, USB_RESET_RECOVERY_TIME
         jge     .reset_recovery_done
 ; 8g. Not yet, but initiate wakeup in -eax ticks and exit this step.
         neg     eax
         jmp     .test_reset
 .skip_reset:
 ; 9. Process wait-done notifications, test for new wait requests.
 ; Note: that must be done after steps 4 and 7 which could create new requests.
 ; 9a. Call the worker function.
-        call    usb_process_wait_lists
+        invoke  usbhc_api.usb_process_wait_lists
 ; 9b. If it reports that an asynchronous endpoint should be removed,
 ; doorbell InterruptOnAsyncAdvance and schedule wakeup in 1s
 ; (sometimes it just does not fire).
         test    al, 1 shl CONTROL_PIPE
         jz      @f
         mov     edx, [esi+usb_controller.WaitPipeListAsync]
         mov     [esi+usb_controller.WaitPipeRequestAsync], edx
         or      dword [edi+EhciCommandReg], 1 shl 6
-        dbgstr 'async advance doorbell'
+;        dbgstr 'async advance doorbell'
         cmp     dword [esp], 100
         jb      @f
         mov     dword [esp], 100
 @@:
 ; 9c. If it reports that a periodic endpoint should be removed,
 ; 2. For every pipe, perform the internal loop over all descriptors.
 ; All descriptors are organized in the queue; we process items from the start
 ; of the queue until a) the last descriptor (not the part of the queue itself)
 ; or b) an active (not yet processed by the hardware) descriptor is reached.
         lea     ecx, [ebx+usb_pipe.Lock]
-        call    mutex_lock
+        invoke  MutexLock
         mov     ebx, [ebx+usb_pipe.LastTD]
         push    ebx
         mov     ebx, [ebx+usb_gtd.NextVirt]
 .tdloop:
 ; 3. For every descriptor, test active flag and check for end-of-queue;
         cmp     byte [ebx+ehci_gtd.Token-sizeof.ehci_gtd], 0
         js      .tddone
 ; Release the queue lock while processing one descriptor:
 ; callback function could (and often would) schedule another transfer.
         push    ecx
-        call    mutex_unlock
+        invoke  MutexUnlock
         call    ehci_process_updated_td
         pop     ecx
-        call    mutex_lock
+        invoke  MutexLock
         jmp     .tdloop
 .tddone:
-        call    mutex_unlock
+        invoke  MutexUnlock
         pop     ebx
 ; End of internal loop, restore pointer to the next pipe
 ; and continue the external loop.
         pop     ebx
         jmp     .loop
 ;       lea     eax, [ebx-sizeof.ehci_gtd]
 ;       DEBUGF 1,'K : %x %x %x %x\n',[eax],[eax+4],[eax+8],[eax+12]
 ;       DEBUGF 1,'K : %x %x %x %x\n',[eax+16],[eax+20],[eax+24],[eax+28]
 ;@@:
 ; 1. Remove this descriptor from the list of descriptors for this pipe.
-        call    usb_unlink_td
+        invoke  usbhc_api.usb_unlink_td
 ; 2. Calculate actual number of bytes transferred.
         mov     eax, [ebx+ehci_gtd.Token-sizeof.ehci_gtd]
         lea     edx, [eax+eax]
         shr     edx, 17
         sub     edx, [ebx+usb_gtd.Length]
         jnz     .special
 .notify:
 ; 4. Either the descriptor in ebx was processed without errors,
 ; or all necessary error actions were taken and ebx points to the last
 ; related descriptor.
-; 4a. Test whether it is the last descriptor in the transfer
-; <=> it has an associated callback.
-        mov     eax, [ebx+usb_gtd.Callback]
-        test    eax, eax
-        jz      .nocallback
-; 4b. It has an associated callback; call it with corresponding parameters.
-        stdcall_verify eax, [ebx+usb_gtd.Pipe], ecx, \
-                [ebx+usb_gtd.Buffer], edx, [ebx+usb_gtd.UserData]
-        jmp     .callback
-.nocallback:
-; 4c. It is an intermediate descriptor. Add its length to the length
-; in the following descriptor.
-        mov     eax, [ebx+usb_gtd.NextVirt]
+        invoke  usbhc_api.usb_process_gtd
-        add     [eax+usb_gtd.Length], edx
-.callback:
 ; 5. Free the current descriptor and return the next one.
         push    [ebx+usb_gtd.NextVirt]
         stdcall ehci_free_td, ebx
         pop     ebx
         ret
         push    eax
 ; 6b. Traverse the list of descriptors looking for the final descriptor
 ; for this transfer. Free and unlink non-final descriptors.
 ; Final descriptor will be freed in step 5.
 .look_final:
-        call    usb_is_final_packet
+        invoke  usbhc_api.usb_is_final_packet
         jnc     .found_final
         push    [ebx+usb_gtd.NextVirt]
         stdcall ehci_free_td, ebx
         pop     ebx
-        call    usb_unlink_td
+        invoke  usbhc_api.usb_unlink_td
         jmp     .look_final
 .found_final:
 ; 6c. Restore the status saved in 6a and transform it to the error code.
 ; Notes:
 ; * any USB transaction error results in Halted bit; if it is not set,
         jnz     .normal
         push    ecx
         push    [ebx+usb_gtd.NextVirt]
         stdcall ehci_free_td, ebx
         pop     ebx
-        call    usb_unlink_td
+        invoke  usbhc_api.usb_unlink_td
         pop     ecx
 .normal:
 ; 6f. For bulk/interrupt transfers we have no choice but halt the queue,
 ; the driver should intercede (through some API which is not written yet).
 ; Control pipes normally recover at the next SETUP transaction (first stage
 endp
 proc ehci_alloc_td
         push    ebx
         mov     ebx, ehci_gtd_mutex
-        stdcall usb_allocate_common, (sizeof.ehci_gtd + sizeof.usb_gtd + 1Fh) and not 1Fh
+        invoke  usbhc_api.usb_allocate_common, (sizeof.ehci_gtd + sizeof.usb_gtd + 1Fh) and not 1Fh
         test    eax, eax
         jz      @f
         add     eax, sizeof.ehci_gtd
 @@:
 ; This procedure is called from several places from main USB code and
 ; frees all additional data associated with the transfer descriptor.
 ; EHCI has no additional data, so just free ehci_gtd structure.
 proc ehci_free_td
         sub     dword [esp+4], sizeof.ehci_gtd
-        jmp     usb_free_common
+        jmp     [usbhc_api.usb_free_common]
 endp
+include 'ehci_scheduler.inc'
+section '.data' readable writable
+include '../peimport.inc'
+include_debug_strings
+IncludeIGlobals
+IncludeUGlobals
+align 4
+usbhc_api usbhc_func

Subversion Repositories Kolibri OS

(root)/drivers/usb/ehci.asm – Rev 4300 → 4418