WebSVN – Kolibri OS – Diff – /drivers/ethernet/R6040.asm

 ;;          GNU GENERAL PUBLIC LICENSE                             ;;
 ;;             Version 2, June 1991                                ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+format PE DLL native
-format MS COFF
+entry START
+        CURRENT_API             = 0x0200
-        API_VERSION             = 0x01000100
+        COMPATIBLE_API          = 0x0100
-        DRIVER_VERSION          = 5
         API_VERSION             = (COMPATIBLE_API shl 16) + CURRENT_API
         MAX_DEVICES             = 16
         MAX_DEVICES             = 16
         RX_FIFO_THRESH          = 4             ; Rx buffer level before first PCI xfer.
         RX_DMA_BURST            = 4             ; Maximum PCI burst, '4' is 256 bytes
+        TX_DMA_BURST            = 4
-        TX_DMA_BURST            = 4
+section '.flat' readable writable executable
-include '../struct.inc'
-include '../macros.inc'
+include '../proc32.inc'
-include '../proc32.inc'
+include '../struct.inc'
-include '../imports.inc'
-include '../fdo.inc'
-include '../netdrv.inc'
-public START
+include '../macros.inc'
-public service_proc
+include '../fdo.inc'
-public version
+include '../netdrv_pe.inc'
 RX_BUF_LEN      equ (8192 << RX_BUF_LEN_IDX)    ; Size of the in-memory receive ring.
 IO_SIZE         = 256       ; RDC MAC I/O Size
+MAX_MAC         = 2         ; MAX RDC MAC
-MAX_MAC         = 2         ; MAX RDC MAC
-virtual at 0
+struct  x_head
-x_head:
-  .status         dw ?   ;0-1
+        status          dw ?   ;0-1
-  .len            dw ?   ;2-3
+        len             dw ?   ;2-3
-  .buf            dd ?   ;4-7
+        buf             dd ?   ;4-7
-  .ndesc          dd ?   ;8-B
+        ndesc           dd ?   ;8-B
-  .rev1           dd ?   ;C-F
+        rev1            dd ?   ;C-F
-  .vbufp          dd ?   ;10-13
+        vbufp           dd ?   ;10-13
-  .vndescp        dd ?   ;14-17
-  .skb_ptr        dd ?   ;18-1B
-  .rev2           dd ?   ;1C-1F
+        vndescp         dd ?   ;14-17
-  .sizeof:
+        skb_ptr         dd ?   ;18-1B
-end virtual
+        rev2            dd ?   ;1C-1F
-virtual at ebx
+ends
-        device:
-        ETH_DEVICE
+struct  device          ETH_DEVICE
-        .io_addr        dd ?
+        io_addr         dd ?
+        pci_bus         dd ?
+        pci_dev         dd ?
-        .cur_rx         dw ?
+        irq_line        db ?
-        .cur_tx         dw ?
+                        rb 3    ; align 4
-        .last_tx        dw ?
-        .phy_addr       dd ?
+        cur_rx          dw ?
-        .phy_mode       dw ?
+        cur_tx          dw ?
-        .mcr0           dw ?
-        .mcr1           dw ?
+        last_tx         dw ?
-        .switch_sig     dw ?
+        phy_addr        dd ?
+        phy_mode        dw ?
-        .pci_bus        dd ?
+        mcr0            dw ?
-        .pci_dev        dd ?
+        mcr1            dw ?
-        .irq_line       db ?
+        switch_sig      dw ?
-        rb 1            ; dword alignment
-        .tx_ring:       rb (((x_head.sizeof*TX_RING_SIZE)+32) and 0xfffffff0)
-        .rx_ring:       rb (((x_head.sizeof*RX_RING_SIZE)+32) and 0xfffffff0)
+        rb 0x100 - ($ and 0xff) ; align 256
-        .size = $ - device
         tx_ring         rb ((TX_RING_SIZE*sizeof.x_head+32) and 0xfffffff0)
-end virtual
+        rx_ring         rb ((RX_RING_SIZE*sizeof.x_head+32) and 0xfffffff0)
 ends
 section '.flat' code readable align 16
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;                        ;;
-;; proc START             ;;
-;;                        ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; (standard driver proc) ;;
+;;                        ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; proc START             ;;
+;;                        ;;
-align 4
+;; (standard driver proc) ;;
-proc START stdcall, state:dword
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
         cmp [state], 1
-        jne .exit
+proc START c, reason:dword, cmdline:dword
 ;; proc SERVICE_PROC      ;;
 ;;                        ;;
 ;; (standard driver proc) ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 proc service_proc stdcall, ioctl:dword
-;        mov     eax, [edx + IOCTL.input]                      ; get the pci bus and device numbers
+;        mov     eax, [edx + IOCTL.input]               ; get the pci bus and device numbers
         mov     ax , [eax+1]                            ;
   .nextdevice:
         mov     ebx, [esi]
-        cmp     al, byte[device.pci_bus]
+        cmp     al, byte[ebx + device.pci_bus]
         jne     @f
-        cmp     ah, byte[device.pci_dev]
+        cmp     ah, byte[ebx + device.pci_dev]
         je      .find_devicenum                         ; Device is already loaded, let's find it's device number
        @@:
         add     esi, 4
 ; This device doesnt have its own eth_device structure yet, lets create one
   .firstdevice:
         cmp     [devices], MAX_DEVICES                  ; First check if the driver can handle one more card
         jae     .fail
-        allocate_and_clear ebx, device.size, .fail      ; Allocate the buffer for device structure
+        allocate_and_clear ebx, sizeof.device, .fail    ; Allocate the buffer for device structure
 ; Fill in the direct call addresses into the struct
-        mov     [device.reset], reset
+        mov     [ebx + device.reset], reset
-        mov     [device.transmit], transmit
+        mov     [ebx + device.transmit], transmit
-        mov     [device.unload], unload
+        mov     [ebx + device.unload], unload
-        mov     [device.name], my_service
+        mov     [ebx + device.name], my_service
 ; save the pci bus and device numbers
         mov     eax, [edx + IOCTL.input]
+        movzx   ecx, byte[eax+1]
-        movzx   ecx, byte[eax+1]
+        mov     [ebx + device.pci_bus], ecx
-        mov     [device.pci_bus], ecx
+        movzx   ecx, byte[eax+2]
+        mov     [ebx + device.pci_dev], ecx
-        movzx   ecx, byte[eax+2]
-        mov     [device.pci_dev], ecx
+; Now, it's time to find the base io addres of the PCI device
-; Now, it's time to find the base io addres of the PCI device
+        stdcall PCI_find_io, [ebx + device.pci_bus], [ebx + device.pci_dev]
-        PCI_find_io
-; We've found the io address, find IRQ now
-        PCI_find_irq
+        mov     [ebx + device.io_addr], eax
-        DEBUGF  1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
+; We've found the io address, find IRQ now
+        invoke  PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line
+        mov     [ebx + device.irq_line], al
-        [device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4
+        DEBUGF  1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
+        [ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.io_addr]:8
-; Ok, the eth_device structure is ready, let's probe the device
         cli
 ; Ok, the eth_device structure is ready, let's probe the device
         call    probe                                                   ; this function will output in eax
-        test    eax, eax
+        mov     eax, [devices]                                          ; Add the device structure to our device list
-        jnz     .err_sti                                                ; If an error occured, exit
+        mov     [device_list+4*eax], ebx                                ; (IRQ handler uses this list to find device)
+        inc     [devices]                                               ;
-        mov     eax, [devices]                                          ; Add the device structure to our device list
-        mov     [device_list+4*eax], ebx                                ; (IRQ handler uses this list to find device)
+        call    probe                                                   ; this function will output in eax
-        inc     [devices]                                               ;
+        test    eax, eax
+        jnz     .err2
         mov     [device.type], NET_TYPE_ETH
-        call    NetRegDev
+        mov     [ebx + device.type], NET_TYPE_ETH
-        sti
+        invoke  NetRegDev
         cmp     eax, -1
         je      .destroy
         ret
+        ret
-; If the device was already loaded, find the device number and return it in eax
+; If the device was already loaded, find the device number and return it in eax
   .find_devicenum:
-        DEBUGF  1,"Trying to find device number of already registered device\n"
+  .find_devicenum:
-        call    NetPtrToNum                                             ; This kernel procedure converts a pointer to device struct in ebx
+        DEBUGF  2,"Trying to find device number of already registered device\n"
-                                                                        ; into a device number in edi
+        invoke  NetPtrToNum                                             ; This kernel procedure converts a pointer to device struct in ebx
 ;;                                                                        ;;
 ;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
 ;mdio_read:
-;        stdcall phy_read, [device.io_addr], [device.phy_addr], ecx
+;        stdcall phy_read, [ebx + device.io_addr], [ebx + device.phy_addr], ecx
 ;        ret
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 probe:
-        DEBUGF  1,"Probing R6040 device\n"
+        DEBUGF  1,"Probing\n"
+; Make the device a bus master
+        invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command
         or      al, PCI_CMD_MASTER
-        PCI_make_bus_master
+        invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
         ; If PHY status change register is still set to zero
         ; it means the bootloader didn't initialize it
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  PHY_CC
+        set_io  [ebx + device.io_addr], PHY_CC
         in      ax, dx
         call    read_mac
         ; Some bootloaders/BIOSes do not initialize MAC address, warn about that
         and     eax, 0xFF
-        or      eax, dword [device.mac]
+        or      eax, dword [ebx + device.mac]
         test    eax, eax
         jnz     @f
         DEBUGF  2, "MAC address not initialized!\n"
      @@:
         ; Init RDC private data
-        mov     [device.mcr0], MCR0_XMTEN or MCR0_RCVEN
+        mov     [ebx + device.mcr0], MCR0_XMTEN or MCR0_RCVEN
-        mov     [device.phy_addr], PHY1_ADDR
+        mov     [ebx + device.phy_addr], PHY1_ADDR
-        mov     [device.switch_sig], 0
+        mov     [ebx + device.switch_sig], 0
         ; Check the vendor ID on the PHY, if 0xFFFF assume none attached
-        stdcall phy_read, [device.phy_addr], 2
+        stdcall phy_read, [ebx + device.phy_addr], 2
         cmp     ax, 0xFFFF
         ; Initialize and alloc RX/TX buffers
         call    init_txbufs
         call    init_rxbufs
         ; Read the PHY ID
-        mov     [device.phy_mode], MCR0_FD
+        mov     [ebx + device.phy_mode], MCR0_FD
         stdcall phy_read, 0, 2
-        mov     [device.switch_sig], ax
+        mov     [ebx + device.switch_sig], ax
         cmp     ax, ICPLUS_PHY_ID
         jne     @f
         stdcall phy_write, 29, 31, 0x175C ; Enable registers
         jmp     .phy_readen
       @@:
         ; PHY Mode Check
-        stdcall phy_write, [device.phy_addr], 4, PHY_CAP
+        stdcall phy_write, [ebx + device.phy_addr], 4, PHY_CAP
-        stdcall phy_write, [device.phy_addr], 0, PHY_MODE
+        stdcall phy_write, [ebx + device.phy_addr], 0, PHY_MODE
       if PHY_MODE = 0x3100
         call    phy_mode_chk
-        mov     [device.phy_mode], ax
+        mov     [ebx + device.phy_mode], ax
         jmp     .phy_readen
       end if
       if not (PHY_MODE and 0x0100)
-        mov     [device.phy_mode], 0
+        mov     [ebx + device.phy_mode], 0
       end if
       .phy_readen:
         ; Set duplex mode
         ; Initialize all Mac registers
-        call    init_mac_regs
         call    init_mac_regs
 align 4
 reset:
-        DEBUGF  1,"Resetting R6040\n"
+        DEBUGF  1,"Resetting\n"
-        ; Mask off Interrupt
-        xor     ax, ax
+        ; Mask off Interrupt
-        set_io  0
+        xor     ax, ax
-        set_io  MIER
+        set_io  [ebx + device.io_addr], 0
-        out     dx, ax
+        set_io  [ebx + device.io_addr], MIER
         out     dx, ax
 ; attach int handler
-        movzx   eax, [device.irq_line]
+        movzx   eax, [ebx + device.irq_line]
         DEBUGF  1,"Attaching int handler to irq %x\n", eax:1
-        stdcall AttachIntHandler, eax, int_handler, dword 0
-        test    eax, eax
+        invoke  AttachIntHandler, eax, int_handler, ebx
-        jnz     @f
+        test    eax, eax
-        DEBUGF  2,"Could not attach int handler!\n"
+        jnz     @f
-;        or      eax, -1
+        DEBUGF  2,"Could not attach int handler!\n"
-;        ret
+        or      eax, -1
-       @@:
+        ret
        @@:
         test    ecx, ecx
         jnz     .read
   @@:
         ;Reset internal state machine
         mov     ax,  2
-        set_io  MAC_SM
+        set_io  [ebx + device.io_addr], MAC_SM
         out     dx, ax
         xor     ax, ax
         out     dx, ax
         mov     esi, 5
-        stdcall Sleep
+        invoke  Sleep
         ;MAC Bus Control Register
         mov     ax, MBCR_DEFAULT
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  MBCR
+        set_io  [ebx + device.io_addr], MBCR
         out     dx, ax
         ;Buffer Size Register
         mov     ax, MAX_BUF_SIZE
-        set_io  MR_BSR
+        set_io  [ebx + device.io_addr], MR_BSR
         out     dx, ax
         ;Write TX ring start address
-        lea     eax, [device.tx_ring]
+        lea     eax, [ebx + device.tx_ring]
-        GetRealAddr
+        invoke  GetPhysAddr
-        set_io  MTD_SA0
+        set_io  [ebx + device.io_addr], MTD_SA0
         out     dx, ax
         shr     eax, 16
-        set_io  MTD_SA1
+        set_io  [ebx + device.io_addr], MTD_SA1
         out     dx, ax
         ;Write RX ring start address
-        lea     eax, [device.rx_ring]
+        lea     eax, [ebx + device.rx_ring]
-        GetRealAddr
+        invoke  GetPhysAddr
-        set_io  MRD_SA0
+        set_io  [ebx + device.io_addr], MRD_SA0
         out     dx, ax
         shr     eax, 16
-        set_io  MRD_SA1
+        set_io  [ebx + device.io_addr], MRD_SA1
         out     dx, ax
         ;Set interrupt waiting time and packet numbers
         xor     ax, ax
-        set_io  MT_ICR
+        set_io  [ebx + device.io_addr], MT_ICR
         out     dx, ax
         ;Enable interrupts
         mov     ax, INT_MASK
-        set_io  MIER
+        set_io  [ebx + device.io_addr], MIER
-        out     dx, ax
         out     dx, ax
         ;Enable RX
-        mov     ax, [device.mcr0]
-        or      ax, MCR0_RCVEN
+        ;Enable RX
-        set_io  0
+        mov     ax, [ebx + device.mcr0]
-        out     dx, ax
+        or      ax, MCR0_RCVEN
+        set_io  [ebx + device.io_addr], 0
-        ;Let TX poll the descriptors
+        out     dx, ax
-        ;we may got called by tx_timeout which has left
-        ;some unset tx buffers
+        ;Let TX poll the descriptors
-        xor     ax, ax
+        ;we may got called by tx_timeout which has left some unset tx buffers
-        inc     ax
+        xor     ax, ax
 align 4
 init_txbufs:
         DEBUGF  1,"Init TxBufs\n"
-        lea     esi, [device.tx_ring]
+        lea     esi, [ebx + device.tx_ring]
-        lea     eax, [device.tx_ring + x_head.sizeof]
+        lea     eax, [ebx + device.tx_ring + sizeof.x_head]
-        GetRealAddr
+        invoke  GetPhysAddr
         mov     ecx, TX_RING_SIZE
     .next_desc:
-        mov     [esi + x_head.ndesc], eax
-        mov     [esi + x_head.skb_ptr], 0
+        mov     [esi + x_head.ndesc], eax
-        mov     [esi + x_head.status], DSC_OWNER_MAC
+        mov     [esi + x_head.skb_ptr], 0
-        add     eax, x_head.sizeof
+        mov     [esi + x_head.status], DSC_OWNER_MAC
-        add     esi, x_head.sizeof
+        add     eax, sizeof.x_head
+        add     esi, sizeof.x_head
         dec     ecx
         jnz     .next_desc
-        lea     eax, [device.tx_ring]
+        lea     eax, [ebx + device.tx_ring]
-        GetRealAddr
+        invoke  GetPhysAddr
-        mov     [device.tx_ring + x_head.sizeof*(TX_RING_SIZE - 1) + x_head.ndesc], eax
+        mov     dword[ebx + device.tx_ring + sizeof.x_head*(TX_RING_SIZE-1) + x_head.ndesc], eax
         ret
 align 4
 init_rxbufs:
         DEBUGF  1,"Init RxBufs\n"
-        lea     esi, [device.rx_ring]
+        lea     esi, [ebx + device.rx_ring]
-        lea     eax, [device.rx_ring + x_head.sizeof]
+        lea     eax, [ebx + device.rx_ring + sizeof.x_head]
-        GetRealAddr
+        invoke  GetPhysAddr
         mov     edx, eax
         mov     ecx, RX_RING_SIZE
     .next_desc:
         mov     [esi + x_head.ndesc], edx
         push    esi ecx edx
-        stdcall KernelAlloc, MAX_BUF_SIZE
+        invoke  KernelAlloc, MAX_BUF_SIZE
         pop     edx ecx esi
 phy_mode_chk:
         DEBUGF  1,"Checking PHY mode\n"
         ; PHY Link Status Check
-        stdcall phy_read, [device.phy_addr], MII_BMSR
+        stdcall phy_read, [ebx + device.phy_addr], MII_BMSR
         test    ax, BMSR_LSTATUS
         jz      .ret_0x8000
         ; PHY Chip Auto-Negotiation Status
         test    ax, BMSR_ANEGCOMPLETE
         jnz     .auto_nego
         ; Force Mode
-        stdcall phy_read, [device.phy_addr], MII_BMCR
+        stdcall phy_read, [ebx + device.phy_addr], MII_BMCR
         test    ax, BMCR_FULLDPLX
         jnz     .ret_0x8000
   .auto_nego:
         ; Auto Negotiation Mode
-        stdcall phy_read, [device.phy_addr], MII_LPA
+        stdcall phy_read, [ebx + device.phy_addr], MII_LPA
         mov     cx, ax
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                         ;;
 ;; Transmit                                ;;
-;;                                         ;;
-;; In: buffer pointer in [esp+4]           ;;
-;;     size of buffer in [esp+8]           ;;
+;;                                         ;;
-;;     pointer to device structure in ebx  ;;
+;; In: pointer to device structure in ebx  ;;
 ;;                                         ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+proc transmit stdcall bufferptr, buffersize
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-align 4
+        pushf
+        cli
-transmit:
-        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [esp+4], [esp+8]
+        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [buffersize]
-        mov     eax, [esp+4]
+        mov     eax, [bufferptr]
         DEBUGF  1,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
         [eax+00]:2,[eax+01]:2,[eax+02]:2,[eax+03]:2,[eax+04]:2,[eax+05]:2,\
         [eax+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\
         [eax+13]:2,[eax+12]:2
-        cmp     dword [esp+8], 1514
+        cmp     [buffersize], 1514
         ja      .fail
-        cmp     dword [esp+8], 60
+        cmp     [buffersize], 60
         jb      .fail
-        movzx   edi, [device.cur_tx]
+        movzx   edi, [ebx + device.cur_tx]
         shl     edi, 5
         add     edi, ebx
-        add     edi, device.tx_ring - ebx
+        add     edi, device.tx_ring
         DEBUGF  1,"TX buffer status: 0x%x\n", [edi + x_head.status]:4
         test    [edi + x_head.status], DSC_OWNER_MAC    ; check if buffer is available
         jnz     .wait_to_send
   .do_send:
         DEBUGF  1,"Sending now\n"
-        mov     eax, [esp+4]
+        mov     eax, [bufferptr]
         mov     [edi + x_head.skb_ptr], eax
-        GetRealAddr
+        invoke  GetPhysAddr
         mov     [edi + x_head.buf], eax
-        mov     ecx, [esp+8]
+        mov     ecx, [buffersize]
         mov     [edi + x_head.len], cx
         mov     [edi + x_head.status], DSC_OWNER_MAC
         ; Trigger the MAC to check the TX descriptor
         mov     ax, 0x01
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  MTPR
+        set_io  [ebx + device.io_addr], MTPR
         out     dx, ax
+        inc     [ebx + device.cur_tx]
-        inc     [device.cur_tx]
+        and     [ebx + device.cur_tx], TX_RING_SIZE - 1
-        and     [device.cur_tx], TX_RING_SIZE - 1
 ; Update stats
-        inc     [device.packets_tx]
+        inc     [ebx + device.packets_tx]
-        mov     eax, [esp+8]
+        mov     eax, [buffersize]
-        add     dword [device.bytes_tx], eax
+        add     dword[ebx + device.bytes_tx], eax
-        adc     dword [device.bytes_tx + 4], 0
+        adc     dword[ebx + device.bytes_tx + 4], 0
         xor     eax, eax
-        ret     8
+        popf
         ret
   .wait_to_send:
   .wait_to_send:
-        DEBUGF  1,"Waiting for TX buffer\n"
-        call    GetTimerTicks           ; returns in eax
+        DEBUGF  1,"Waiting for TX buffer\n"
         lea     edx, [eax + 100]
-     .l2:
+        invoke  GetTimerTicks           ; returns in eax
+        lea     edx, [eax + 100]
-        test    [edi + x_head.status], DSC_OWNER_MAC
+     .l2:
-        jz      .do_send
+        test    [edi + x_head.status], DSC_OWNER_MAC
-        mov     esi, 10
+        jz      .do_send
-        call    Sleep
+        mov     esi, 10
-        call    GetTimerTicks
+        invoke  Sleep
         jz      .nothing
         mov     esi, device_list
   .nextdevice:
         mov     ebx, [esi]
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  MISR
+        set_io  [ebx + device.io_addr], MISR
         in      ax, dx
         out     dx, ax                  ; send it back to ACK
         test    ax, ax
         jnz     .got_it
         jnz     .nextdevice
   .nothing:
         pop     edi esi ebx
         xor     eax, eax
-        ret                             ; If no device was found, abort (The irq was probably for a device, not registered to this driver)
         ret                             ; If no device was found, abort
         push    ebx
   .more_RX:
         pop     ebx
         ; Find the current RX descriptor
-        movzx   edx, [device.cur_rx]
+        movzx   edx, [ebx + device.cur_rx]
         shl     edx, 5
-        lea     edx, [device.rx_ring + edx]
+        lea     edx, [ebx + device.rx_ring + edx]
         ; Check the descriptor status
         mov     cx, [edx + x_head.status]
         movzx   ecx, [edx + x_head.len]
         and     ecx, 0xFFF
         sub     ecx, 4                  ; Do not count the CRC
         ; Update stats
-        add     dword[device.bytes_rx], ecx
+        add     dword[ebx + device.bytes_rx], ecx
-        adc     dword[device.bytes_rx + 4], 0
+        adc     dword[ebx + device.bytes_rx + 4], 0
-        inc     dword[device.packets_rx]
+        inc     dword[ebx + device.packets_rx]
         ; Push packet size and pointer, kernel will need it..
         DEBUGF  1,"packet ptr=0x%x\n", [edx + x_head.skb_ptr]
         ; reset the RX descriptor
         push    edx
-        stdcall KernelAlloc, MAX_BUF_SIZE
+        invoke  KernelAlloc, MAX_BUF_SIZE
         pop     edx
         mov     [edx + x_head.skb_ptr], eax
-        GetRealAddr
+        invoke  GetPhysAddr
         mov     [edx + x_head.buf], eax
         mov     [edx + x_head.status], DSC_OWNER_MAC
         ; Use next descriptor next time
-        inc     [device.cur_rx]
+        inc     [ebx + device.cur_rx]
-        and     [device.cur_rx], RX_RING_SIZE - 1
+        and     [ebx + device.cur_rx], RX_RING_SIZE - 1
         ; At last, send packet to kernel
-        jmp     Eth_input
+        jmp     [Eth_input]
   .no_RX:
         test    word[esp], TX_FINISH
         jz      .no_TX
         DEBUGF  1,"Freeing buffer 0x%x\n", [edi + x_head.skb_ptr]
         push    [edi + x_head.skb_ptr]
         mov     [edi + x_head.skb_ptr], 0
-        call    KernelFree
+        invoke  KernelFree
-        inc     [device.last_tx]
+        inc     [ebx + device.last_tx]
-        and     [device.last_tx], TX_RING_SIZE - 1
+        and     [ebx + device.last_tx], TX_RING_SIZE - 1
         DEBUGF  1,"initializing MAC regs\n"
         ; MAC operation register
         mov     ax, 1
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  MCR1
+        set_io  [ebx + device.io_addr], MCR1
         out     dx, ax
         ; Reset MAC
         mov     ax, 2
-        set_io  MAC_SM
+        set_io  [ebx + device.io_addr], MAC_SM
         out     dx, ax
         ; Reset internal state machine
         xor     ax, ax
         out     dx, ax
         mov     esi, 5
-        stdcall Sleep
+        invoke  Sleep
         mov     eax, [phy_addr]
         shl     eax, 8
         add     eax, [reg]
         add     eax, MDIO_READ
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  MMDIO
+        set_io  [ebx + device.io_addr], MMDIO
         out     dx, ax
         ;Wait for the read bit to be cleared.
         jz      @f
         dec     ecx
         jnz     .read
   @@:
-        set_io  MMRD
+        set_io  [ebx + device.io_addr],   MMRD
         in      ax, dx
         and     eax, 0xFFFF
 ; Write a word data to PHY Chip
 align 4
 proc  phy_write stdcall, phy_addr:dword, reg:dword, val:dword
         DEBUGF  1,"PHY write, addr=0x%x reg=0x%x val=0x%x\n", \
-        DEBUGF  1,"PHY write, addr=0x%x reg=0x%x val=0x%x\n", [phy_addr]:8, [reg]:8, [val]:8
+        [phy_addr]:8, [reg]:8, [val]:8
         mov     eax, [val]
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  MMWD
+        set_io  [ebx + device.io_addr], MMWD
         out     dx, ax
         ;Write the command to the MDIO bus
         mov     eax, [phy_addr]
         shl     eax, 8
         add     eax, [reg]
         add     eax, MDIO_WRITE
-        set_io  MMDIO
+        set_io  [ebx + device.io_addr], MMDIO
 read_mac:
         DEBUGF  1,"Reading MAC:\n"
         mov     cx, 3
-        lea     edi, [device.mac]
+        lea     edi, [ebx + device.mac]
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  MID_0L
+        set_io  [ebx + device.io_addr], MID_0L
      .mac:
         in      ax, dx
         stosw
         inc     dx
         inc     dx
+        dec     cx
-        dec     cx
+        jnz     .mac
         jnz     .mac
         DEBUGF  1,"%x-%x-%x-%x-%x-%x\n",\
-        DEBUGF  1,"%x-%x-%x-%x-%x-%x\n",[edi-6]:2, [edi-5]:2, [edi-4]:2, [edi-3]:2, [edi-2]:2, [edi-1]:2
+        [edi-6]:2, [edi-5]:2, [edi-4]:2, [edi-3]:2, [edi-2]:2, [edi-1]:2
+        ret
-        ret
+; End of code

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/R6040.asm – Rev 4470 → 4597