WebSVN – Kolibri OS – Diff – /drivers/ethernet/RTL8139.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
-        TX_MXDMA                = 6 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=2048
+        TX_MXDMA                = 6     ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=2048
-        ERTXTH                  = 8 ; in unit of 32 bytes e.g:(8*32)=256
+        ERTXTH                  = 8     ; in unit of 32 bytes e.g:(8*32)=256
-        RX_MXDMA                = 7 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=unlimited
+        RX_MXDMA                = 7     ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=unlimited
-        RXFTH                   = 7 ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=no threshold
+        RXFTH                   = 7     ; 0=16 1=32 2=64 3=128 4=256 5=512 6=1024 7=no threshold
         DEBUG                   = 1
         __DEBUG__               = 1
+        __DEBUG_LEVEL__         = 2     ; 1 = verbose, 2 = errors only
+section '.flat' readable writable executable
         __DEBUG_LEVEL__         = 2             ; 1 = verbose, 2 = errors only
 include '../proc32.inc'
-include '../struct.inc'
-include '../macros.inc'
-include '../proc32.inc'
+include '../struct.inc'
-include '../imports.inc'
+include '../macros.inc'
-include '../fdo.inc'
-include '../netdrv.inc'
-public START
-public service_proc
+include '../fdo.inc'
-public version
+include '../netdrv_pe.inc'
         REG_IDR0                = 0x00
                                   (1 shl BIT_AER) or \                  ; Accept error packets
                                   (1 shl BIT_AR) or \                   ; Accept Runt packets (smaller then 64 bytes)
                                   (1 shl BIT_AM)                        ; Accept multicast packets
-        RX_BUFFER_SIZE          = (8192 shl RBLEN);+16+1500
-        MAX_ETH_FRAME_SIZE      = 1514
+        RX_BUFFER_SIZE          = (8192 shl RBLEN);+16+1500
         NUM_TX_DESC             = 4                                     ; not user selectable
         EE_93C46_REG_ETH_ID     = 7 ; MAC offset
                                   ISR_FIFOOVW or \
                                   ISR_LENCHG or \
                                   ISR_TIMEOUT or \
                                   ISR_SERR
         TSR_OWN                 = 1 shl 13
         TSR_TUN                 = 1 shl 14
         TSR_TOK                 = 1 shl 15
         TSR_CDH                 = 1 shl 28
         TSR_OWC                 = 1 shl 29
-        TSR_TABT                = 1 shl 30
-        TSR_CRS                 = 1 shl 31
-virtual at ebx
+        TSR_TABT                = 1 shl 30
+        TSR_CRS                 = 1 shl 31
+struct  device          ETH_DEVICE
+        io_addr         dd ?
+        pci_bus         dd ?
+        pci_dev         dd ?
+        irq_line        db ?
+                        rb 3    ; align 4
-        device:
+        rx_buffer       dd ?
-        ETH_DEVICE
-        .rx_buffer      dd ?
-        .rx_data_offset dd ?
+        rx_data_offset  dd ?
-        .io_addr        dd ?
-        .curr_tx_desc   db ?
-        .pci_bus        dd ?
-        .pci_dev        dd ?
-        .irq_line       db ?
-        .hw_ver_id      db ?
-                        db ?    ; align 4
-        .TX_DESC        rd NUM_TX_DESC
         curr_tx_desc    db ?
-        .size = $ - device
+        hw_ver_id       db ?
                         rb 2    ; align 4
 end virtual
         TX_DESC         rd NUM_TX_DESC
-section '.flat' code readable align 16
+ends
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;                        ;;
-;; proc START             ;;
-;;                        ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; (standard driver proc) ;;
+;;                        ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; proc START             ;;
 ;;                        ;;
-align 4
-proc START stdcall, state:dword
+;; (standard driver proc) ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
         cmp     [state], 1
 ;; proc SERVICE_PROC      ;;
 ;;                        ;;
 ;; (standard driver proc) ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 4
 proc service_proc stdcall, ioctl:dword
         jz      .firstdevice
         mov     ax, [eax+1]                             ; get the pci bus and device numbers
   .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]
+        mov     [ebx + device.io_addr], eax
         PCI_find_io
 ; We've found the io address, find IRQ now
-; We've found the io address, find IRQ now
         invoke  PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.interrupt_line
-        PCI_find_irq
+        mov     [ebx + device.irq_line], al
         call    reset
         test    eax, eax
         jnz     .destroy
-        mov     [device.type], NET_TYPE_ETH
+        mov     [ebx + device.type], NET_TYPE_ETH
-        call    NetRegDev
+        invoke  NetRegDev
         cmp     eax, -1
         je      .destroy
         ret
 ; If the device was already loaded, find the device number and return it in eax
   .find_devicenum:
         ; todo: unregister device from device_list
         ; todo: reset device into virgin state
   .err:
         DEBUGF  2, "Error, removing all data !\n"
-        stdcall KernelFree, [device.rx_buffer]
+        invoke  KernelFree, [ebx + device.rx_buffer]
-        stdcall KernelFree, ebx
+        invoke  KernelFree, ebx
   .fail:
 align 4
 probe:
         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
 ; get chip version
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_TXCONFIG + 2
+        set_io  [ebx + device.io_addr], REG_TXCONFIG + 2
         in      ax, dx
         mov     ecx, 8
   .chip_ver_found:
         cmp     ecx, 8
         ja      .unknown
-        mov     [device.hw_ver_id], cl
+        mov     [ebx + device.hw_ver_id], cl
         mov     ecx, [crosslist+ecx*4]
-        mov     [device.name], ecx
+        mov     [ebx + device.name], ecx
         DEBUGF  1, "Chip version: %s\n", ecx
 ; wake up the chip
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_HLTCLK
+        set_io  [ebx + device.io_addr], REG_HLTCLK
         mov     al, 'R'         ; run the clock
         out     dx, al
 ; unlock config and BMCR registers
-        set_io  REG_9346CR
+        set_io  [ebx + device.io_addr], REG_9346CR
         mov     al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
         out     dx, al
 ; enable power management
-        set_io  REG_CONFIG1
+        set_io  [ebx + device.io_addr], REG_CONFIG1
         in      al, dx
   .new_chip:
         or      al, (1 shl BIT_PMEn)
         and     al, not (1 shl BIT_LWACT)
         out     dx, al
-        set_io  REG_CONFIG4
+        set_io  [ebx + device.io_addr], REG_CONFIG4
         in      al, dx
         and     al, not (1 shl BIT_LWPTN)
         out     dx, al
 ; lock config and BMCR registers
   .finish_wake_up:
         xor     al, al
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_9346CR
+        set_io  [ebx + device.io_addr], REG_9346CR
         out     dx, al
 reset:
         DEBUGF  1, "Reset\n"
 ; 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
+        invoke  AttachIntHandler, eax, int_handler, ebx
         test    eax, eax
         jnz     @f
         DEBUGF  2, "Could not attach int handler!\n"
-;        or      eax, -1
+        or      eax, -1
-;        ret
+        ret
        @@:
 ; reset chip
         DEBUGF  1, "Resetting chip\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     al, 1 shl BIT_RST
         out     dx, al
 ; Read MAC address
         call    read_mac
 ; unlock config and BMCR registers
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_9346CR
+        set_io  [ebx + device.io_addr], REG_9346CR
         mov     al, (1 shl BIT_93C46_EEM1) or (1 shl BIT_93C46_EEM0)
         out     dx, al
 ; initialize multicast registers (no filtering)
         mov     eax, 0xffffffff
-        set_io  REG_MAR0
+        set_io  [ebx + device.io_addr], REG_MAR0
         out     dx, eax
-        set_io  REG_MAR4
+        set_io  [ebx + device.io_addr], REG_MAR4
         out     dx, eax
 ; enable Rx/Tx
         mov     al, (1 shl BIT_RE) or (1 shl BIT_TE)
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         out     dx, al
 ; Rxbuffer size, unlimited dma burst, no wrapping, no rx threshold
 ; accept broadcast packets, accept physical match packets
         mov     eax, RX_CONFIG
-        set_io  REG_RXCONFIG
+        set_io  [ebx + device.io_addr], REG_RXCONFIG
         out     dx, eax
 ; 1024 bytes DMA burst, total retries = 16 + 8 * 16 = 144
         mov     eax, (TX_MXDMA shl BIT_TX_MXDMA) or (TXRR shl BIT_TXRR) or BIT_IFG1 or BIT_IFG0
-        set_io  REG_TXCONFIG
+        set_io  [ebx + device.io_addr], REG_TXCONFIG
         out     dx, eax
 ; enable auto negotiation
-        set_io  REG_BMCR
+        set_io  [ebx + device.io_addr], REG_BMCR
         in      ax, dx
         or      ax, (1 shl BIT_ANE)
         out     dx, ax
 ; set auto negotiation advertisement
-        set_io  REG_ANAR
+        set_io  [ebx + device.io_addr], REG_ANAR
         in      ax, dx
         or      ax, (1 shl BIT_SELECTOR) or (1 shl BIT_10) or (1 shl BIT_10FD) or (1 shl BIT_TX) or (1 shl BIT_TXFD)
         out     dx, ax
 ; lock config and BMCR registers
         xor     eax, eax
-        set_io  REG_9346CR
+        set_io  [ebx + device.io_addr], REG_9346CR
         out     dx, al
 ; init RX/TX pointers
-        mov     [device.rx_data_offset], eax
+        mov     [ebx + device.rx_data_offset], eax
-        mov     [device.curr_tx_desc], al
+        mov     [ebx + device.curr_tx_desc], al
-;        set_io  REG_CAPR
+;        set_io  [ebx + device.io_addr], REG_CAPR
 ;        out     dx, ax
 ; clear packet/byte counters
-        lea     edi, [device.bytes_tx]
+        lea     edi, [ebx + device.bytes_tx]
         mov     ecx, 6
         rep     stosd
 ; clear missing packet counter
-        set_io  REG_MPC
+        set_io  [ebx + device.io_addr], REG_MPC
         out     dx, eax
 ; set RxBuffer address, init RX buffer offset
-        mov     eax, [device.rx_buffer]
+        mov     eax, [ebx + device.rx_buffer]
         mov     dword[eax], 0                   ; clear receive flags for first packet (really needed??)
         DEBUGF  1, "RX buffer virtual addr=0x%x\n", eax
-        GetRealAddr
+        invoke  GetPhysAddr
 ;; In: buffer pointer in [esp+4]           ;;
 ;;     size of buffer in [esp+8]           ;;
 ;;     pointer to device structure in ebx  ;;
 ;;                                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+proc transmit stdcall bufferptr, buffersize
-align 4
+        pushf
-transmit:
+        cli
-        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",\
+        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], MAX_ETH_FRAME_SIZE
+        cmp     [buffersize], 1514
         ja      .fail
-        cmp     dword [esp+8], 60
+        cmp     [buffersize], 60
         jb      .fail
 ; check if we own the current discriptor
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_TSD0
+        set_io  [ebx + device.io_addr], REG_TSD0
-        movzx   ecx, [device.curr_tx_desc]
+        movzx   ecx, [ebx + device.curr_tx_desc]
         shl     ecx, 2
         add     edx, ecx
         in      eax, dx
         test    eax, (1 shl BIT_OWN)
         jz      .wait_to_send
   .send_packet:
 ; get next descriptor
-        inc     [device.curr_tx_desc]
+        inc     [ebx + device.curr_tx_desc]
-        and     [device.curr_tx_desc], NUM_TX_DESC-1
+        and     [ebx + device.curr_tx_desc], NUM_TX_DESC-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
 ; Set the buffer address
-        set_io  REG_TSAD0
+        set_io  [ebx + device.io_addr], REG_TSAD0
-        mov     eax, [esp+4]
+        mov     eax, [bufferptr]
-        mov     [device.TX_DESC+ecx], eax
+        mov     [ebx + device.TX_DESC+ecx], eax
-        GetRealAddr
+        invoke  GetPhysAddr
         out     dx, eax
 ; And the size of the buffer
+        set_io  [ebx + device.io_addr], REG_TSD0
-        set_io  REG_TSD0
+        mov     eax, [buffersize]
-        mov     eax, [esp+8]
+        or      eax, (ERTXTH shl BIT_ERTXTH)    ; Early threshold
-        or      eax, (ERTXTH shl BIT_ERTXTH)    ; Early threshold
+        out     dx, eax
         out     dx, eax
         DEBUGF  1, "Packet Sent!\n"
-        DEBUGF  1, "Packet Sent!\n"
+        xor     eax, eax
-        xor     eax, eax
+        popf
-        ret     8
+        ret
   .wait_to_send:
         jmp     .send_packet
   .fail:
+        DEBUGF  2, "transmit failed!\n"
-        DEBUGF  2, "transmit failed!\n"
+        invoke  KernelFree, [bufferptr]
-        stdcall KernelFree, [esp+4]
+        popf
+        or      eax, -1
+        ret
         jz      .nothing
         mov     esi, device_list
   .nextdevice:
         mov     ebx, [esi]
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_ISR
+        set_io  [ebx + device.io_addr], REG_ISR
         in      ax, dx                          ; Get interrupt status
         out     dx, ax                          ; send it back to ACK
         test    ax, ax
         jnz     .got_it
         test    ax, ISR_ROK
         jz      @f
         push    ax
   .receive:
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         in      al, dx
         test    al, BUFE                        ; test if RX buffer is empty
         jnz     .finish
         DEBUGF  1, "RX:\n"
-        mov     eax, [device.rx_buffer]
+        mov     eax, [ebx + device.rx_buffer]
-        add     eax, [device.rx_data_offset]
+        add     eax, [ebx + device.rx_data_offset]
         test    byte [eax], (1 shl BIT_ROK)     ; check if packet is ok
         jz      .reset_rx
 ; packet is ok, copy it
         movzx   ecx, word [eax+2]               ; packet length
         sub     cx, 4                           ; don't copy 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     [device.packets_rx]
+        inc     [ebx + device.packets_rx]
         DEBUGF  1, "Received %u bytes\n", ecx
   .nw:
         jz      .nd
         rep     movsd
   .nd:
-        jmp     Eth_input                       ; Send it to kernel
+        jmp     [Eth_input]                     ; Send it to kernel
   .abort:
         pop     eax ebx
                                                 ; update eth_data_start_offset
         movzx   eax, word [eax+2]               ; packet length
-        add     eax, [device.rx_data_offset]
+        add     eax, [ebx + device.rx_data_offset]
         add     eax, 4+3                        ; packet header is 4 bytes long + dword alignment
         and     eax, not 3                      ; dword alignment
         cmp     eax, RX_BUFFER_SIZE
         jb      .no_wrap
         DEBUGF  1, "Wrapping\n"
         sub     eax, RX_BUFFER_SIZE
   .no_wrap:
-        mov     [device.rx_data_offset], eax
+        mov     [ebx + device.rx_data_offset], eax
         DEBUGF  1, "New RX ptr: %d\n", eax
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
         DEBUGF  1, "Transmit done!\n"
         push    ax
         mov     ecx, (NUM_TX_DESC-1)*4
   .txdescloop:
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_TSD0
+        set_io  [ebx + device.io_addr], REG_TSD0
         add     edx, ecx
         in      eax, dx
         test    eax, TSR_OWN                    ; DMA operation completed
         jz      .notthisone
-        cmp     [device.TX_DESC+ecx], 0
+        cmp     [ebx + device.TX_DESC+ecx], 0
         test    eax, TSR_TOK
         jz      .no_tok
         DEBUGF  1, "TX: Transmit OK!\n"
   .no_tok:
-        DEBUGF  1, "free transmit buffer 0x%x\n", [device.TX_DESC+ecx]:8
+        DEBUGF  1, "free transmit buffer 0x%x\n", [ebx + device.TX_DESC+ecx]:8
         push    ecx ebx
-        stdcall KernelFree, [device.TX_DESC+ecx]
+        invoke  KernelFree, [ebx + device.TX_DESC+ecx]
         pop     ebx ecx
-        mov     [device.TX_DESC+ecx], 0
+        mov     [ebx + device.TX_DESC+ecx], 0
   .notthisone:
         sub     ecx, 4
         jz      @f
         push    ax
         DEBUGF  2, "RX:buffer overflow!\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_ISR
+        set_io  [ebx + device.io_addr], REG_ISR
         mov     ax, ISR_FIFOOVW or ISR_RXOVW
         out     dx, ax
         jz      @f
         push    ax
         DEBUGF  2, "RX fifo overflow!\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_ISR
+        set_io  [ebx + device.io_addr], REG_ISR
         mov     ax, ISR_FIFOOVW or ISR_RXOVW
         out     dx, ax
 align 4
 cable:
         DEBUGF  1, "Checking link status:\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_MSR
+        set_io  [ebx + device.io_addr], REG_MSR
         in      al, dx
         test    al, 1 shl 2             ; 0 = link ok 1 = link fail
         jnz     .notconnected
         test    al, 1 shl 3             ; 0 = 100 Mbps 1 = 10 Mbps
         jnz     .10mbps
   .100mbps:
-        mov     [device.state], ETH_LINK_100M
+        mov     [ebx + device.state], ETH_LINK_100M
-        call    NetLinkChanged
+        invoke  NetLinkChanged
         DEBUGF  2, "link changed to 100 mbit\n"
         ret
   .10mbps:
-        mov     [device.state], ETH_LINK_10M
+        mov     [ebx + device.state], ETH_LINK_10M
-        call    NetLinkChanged
+        invoke  NetLinkChanged
 write_mac:      ; in: mac pushed onto stack (as 3 words)
         DEBUGF  1, "Writing MAC\n"
 ; disable all in command registers
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_9346CR
+        set_io  [ebx + device.io_addr], REG_9346CR
         xor     eax, eax
         out     dx, al
-        set_io  REG_IMR
+        set_io  [ebx + device.io_addr], REG_IMR
         xor     eax, eax
         out     dx, ax
-        set_io  REG_ISR
+        set_io  [ebx + device.io_addr], REG_ISR
         mov     eax, -1
         out     dx, ax
 ; enable writing
-        set_io  REG_9346CR
+        set_io  [ebx + device.io_addr], REG_9346CR
         mov     eax, REG_9346CR_WE
         out     dx, al
  ; write the mac ...
-        set_io  REG_IDR0
+        set_io  [ebx + device.io_addr], REG_IDR0
         pop     eax
         out     dx, eax
-        set_io  REG_IDR0+4
+        set_io  [ebx + device.io_addr], REG_IDR0+4
         xor     eax, eax
 ;;;;;;;;;;;;;;;;;;;;;;
 read_mac:
         DEBUGF  1, "Reading MAC:\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        lea     edi, [device.mac]
+        lea     edi, [ebx + device.mac]
         in      eax, dx
         stosd
         add     edx, 4
         ret
+; End of code
-; End of code
+data fixups
-section '.data' data readable writable align 16 ; place all uninitialized data place here
-align 4                                         ; Place all initialised data here
+end data
-devices         dd 0
+include '../peimport.inc'
 version         dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
 HW_VER_ARRAY_SIZE = $-hw_ver_array
+include_debug_strings                           ; All data wich FDO uses will be included here

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/RTL8139.asm – Rev 4470 → 5045