WebSVN – Kolibri OS – Diff – /drivers/ethernet/3c59x.asm

 ;; Copyright (C) KolibriOS team 2004-2014. All rights reserved. ;;
 ;; Distributed under terms of the GNU General Public License    ;;
 ;;                                                              ;;
 ;;  3Com network driver for KolibriOS                           ;;
 ;;                                                              ;;
-;;  Ported to KolibriOS net-branch by hidnplayr (28/05/10)      ;;
+;;  Ported to KolibriOS net-branch by hidnplayr                 ;;
 ;;                                                              ;;
 ;;  Thanks to: scrap metal recyclers, whom provide me with      ;;
 ;;                         loads of hardware                    ;;
 ;;             diamond: who makes me understand KolibriOS       ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Original copyright from menuetos driver:
+;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                                                         ;;
 ;;  3C59X.INC                                                              ;;
 ;;                                                                         ;;
 ;;  Ethernet driver for Menuet OS                                          ;;
 ;;  Revision 1.1  2004/06/12 18:27:15  kozma
 ;;  Initial revision
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+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
+        FORCE_FD                = 0     ; forcing full duplex mode makes sense at some cards and link types
         FORCE_FD                = 0     ; forcing full duplex mode makes sense at some cards and link types
-        PROMISCIOUS             = 0     ; enables promiscous mode
+        NUM_RX_DESC             = 4     ; a power of 2 number
+        NUM_TX_DESC             = 4     ; a power of 2 number
+        __DEBUG__               = 1
         __DEBUG_LEVEL__         = 2     ; 1 = verbose, 2 = errors only
         DEBUG                   = 1
-        __DEBUG__               = 1
-        __DEBUG_LEVEL__         = 2
 section '.flat' readable writable executable
-include '../struct.inc'
-include '../macros.inc'
-include '../proc32.inc'
-include '../imports.inc'
-include '../fdo.inc'
-include '../netdrv.inc'
-public START
-public service_proc
-public version
-struc DPD {     ; Download Packet Descriptor
-        .next_ptr               dd ?
-        .frame_start_hdr        dd ?
-        .frag_addr              dd ?    ; for packet data
-        .frag_len               dd ?    ; for packet data
-        .realaddr               dd ?
-        .size                   = 32
-}
-virtual at 0
-  dpd DPD
-end virtual
-struc UPD {     ; Upload Packet Descriptor
-        .next_ptr               dd ?
-        .pkt_status             dd ?
-        .frag_addr              dd ?
-        .frag_len               dd ?    ; for packet data
-        .realaddr               dd ?
-        .size           = 32
 include '../proc32.inc'
 include '../struct.inc'
-virtual at 0
+include '../macros.inc'
-  upd UPD
+include '../fdo.inc'
 ; MII commands
         MII_CMD_MASK            = (1111b shl 10)
         MII_CMD_READ            = (0110b shl 10)
         MII_CMD_WRITE           = (0101b shl 10)
-; MII registers
-        REG_MII_BMCR            = 0     ; basic mode control register
-        REG_MII_BMSR            = 1     ; basic mode status register
-        REG_MII_ANAR            = 4     ; auto negotiation advertisement register
-        REG_MII_ANLPAR          = 5     ; auto negotiation link partner ability register
-        REG_MII_ANER            = 6     ; auto negotiation expansion register
-; MII bits
-        BIT_MII_AUTONEG_COMPLETE        = 5     ; auto-negotiation complete
-        BIT_MII_PREAMBLE_SUPPRESSION    = 6
 ; eeprom bits and commands
         EEPROM_CMD_READ         = 0x80
         EEPROM_BIT_BUSY         = 15
         EEPROM_REG_CAPABILITIES = 0x10
 ; Commands for command register
+        SELECT_REGISTER_WINDOW  = (1 shl 11)
-        SELECT_REGISTER_WINDOW  = (1 shl 11)
+; Hw capabilities bitflags
-        IS_VORTEX               = 0x1
+        IS_VORTEX               = 0x0001
-        IS_BOOMERANG            = 0x2
+        IS_BOOMERANG            = 0x0002
-        IS_CYCLONE              = 0x4
+        IS_CYCLONE              = 0x0004
-        IS_TORNADO              = 0x8
+        IS_TORNADO              = 0x0008
-        EEPROM_8BIT             = 0x10
+        EEPROM_8BIT             = 0x0010
-        HAS_PWR_CTRL            = 0x20
+        HAS_PWR_CTRL            = 0x0020
-        HAS_MII                 = 0x40
+        HAS_MII                 = 0x0040
-        HAS_NWAY                = 0x80
+        HAS_NWAY                = 0x0080
-        HAS_CB_FNS              = 0x100
+        HAS_CB_FNS              = 0x0100
-        INVERT_MII_PWR          = 0x200
+        INVERT_MII_PWR          = 0x0200
-        INVERT_LED_PWR          = 0x400
+        INVERT_LED_PWR          = 0x0400
-        MAX_COLLISION_RESET     = 0x800
+        MAX_COLLISION_RESET     = 0x0800
         EEPROM_OFFSET           = 0x1000
         HAS_HWCKSM              = 0x2000
         DownComplete            = 0x0200
         UpComplete              = 0x0400
         DMAInProgress           = 0x0800        ; 1 shl 11  (DMA controller is still busy)
         CmdInProgress           = 0x1000        ; 1 shl 12  (EL3_CMD is still busy)
-        S_5_INTS                = HostError + RxEarly + UpComplete + DownComplete ;+ TxComplete + RxComplete  + TxAvailable
+        S_5_INTS                = HostError + RxEarly + UpComplete + DownComplete + StatsFull ;+ TxComplete + RxComplete  + TxAvailable
 ; Commands
         TotalReset              = 0 shl 11
         RxBroadcast             = 4
         RxProm                  = 8
 ; RX/TX buffers sizes
-        MAX_ETH_PKT_SIZE        = 1536          ; max packet size
-        NUM_RX_DESC             = 4             ; a power of 2 number
-        NUM_TX_DESC             = 4             ; a power of 2 number
+        MAX_ETH_PKT_SIZE        = 1536          ; max packet size
-        MAX_ETH_FRAME_SIZE      = 1520          ; size of ethernet frame + bytes alignment
-virtual at ebx
+        MAX_ETH_FRAME_SIZE      = 1520          ; size of ethernet frame + bytes alignment
-        device:
+struct  tx_desc
+        next_ptr                dd ?
+        frame_start_hdr         dd ?
+        frag_addr               dd ?    ; for packet data
+        frag_len                dd ?    ; for packet data
+        realaddr                dd ?
+                                rd 3    ; align 32
+ends
-        ETH_DEVICE
+struct  rx_desc
+        next_ptr                dd ?
+        pkt_status              dd ?
+        frag_addr               dd ?
+        frag_len                dd ?    ; for packet data
+        realaddr                dd ?
+                                rd 3    ; align 32
-        .dpd_buffer       rd (dpd.size*NUM_TX_DESC)/4
+ends
-        .upd_buffer       rd (upd.size*NUM_RX_DESC)/4
-        .curr_upd         dd ?
-        .prev_dpd         dd ?
+struct  device                  ETH_DEVICE
-        .io_addr          dd ?
+        io_addr                 dd ?
+        pci_bus                 dd ?
+        pci_dev                 dd ?
-        .pci_bus          dd ?
+        irq_line                db ?
-        .pci_dev          dd ?
+                                rb 3    ; alignment
-        .irq_line         db ?
-                rb 3    ; alignment
+        curr_tx                 dd ?
+        curr_rx                 dd ?
-        .prev_tx_frame            dd ?
+        prev_tx_frame           dd ?
+        ver_id                  db ?
-        .ver_id                   db ?
+        full_bus_master         db ?
-        .full_bus_master          db ?
+        has_hwcksm              db ?
+        preamble                db ?
+        dn_list_ptr_cleared     db ?
-        .has_hwcksm               db ?
+        internal_link           dd ?    ; link state (to be used only internally by driver)
-        .preamble                 db ?
         .dn_list_ptr_cleared      db ?
         rb 0x100 - ($ and 0xff) ; align 256
-        .size = $ - device
+        tx_desc_buffer          rd (sizeof.tx_desc*NUM_TX_DESC)/4
         rx_desc_buffer          rd (sizeof.rx_desc*NUM_RX_DESC)/4
 end virtual
 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
-  .entry:
         DEBUGF 1,"Loading driver\n"
-        stdcall RegService, my_service, service_proc
+        cmp     [reason], DRV_ENTRY
-        ret
+        jne     .fail
-  .fail:
+        DEBUGF  2,"Loading driver\n"
         cmp     byte [eax], 1                           ; 1 means device number and bus number (pci) are given
         jne     .fail                                   ; other types of this hardware dont exist
 ; check if the device is already listed
-        mov     ecx, [VORTEX_DEVICES]
+        mov     ecx, [vortex_devices]
         test    ecx, ecx
         jz      .maybeboomerang
-        mov     esi, VORTEX_LIST
+        mov     esi, vortex_list
         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
         loop    .nextdevice
   .maybeboomerang:
-        mov     ecx, [BOOMERANG_DEVICES]
+        mov     ecx, [boomerang_devices]
         test    ecx, ecx
         jz      .firstdevice
-        mov     esi, BOOMERANG_LIST
+        mov     esi, boomerang_list
         mov     eax, [edx + IOCTL.input]                ; get the pci bus and device numbers
         mov     ax, [eax+1]                             ;
   .nextdevice2:
         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
         loop    .nextdevice2
 ; This device doesnt have its own eth_device structure yet, lets create one
   .firstdevice:
-        mov     ecx, [BOOMERANG_DEVICES]
+        mov     ecx, [boomerang_devices]
-        add     ecx, [VORTEX_DEVICES]
+        add     ecx, [vortex_devices]
         cmp     ecx, 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     [ebx + device.reset], reset
+        mov     [ebx + device.transmit], null_op
-        mov     [device.reset], reset
+        mov     [ebx + device.unload], null_op
-        mov     [device.transmit], null_op
+        mov     [ebx + device.name], my_service
+; save the pci bus and device numbers
-        mov     [device.unload], null_op
-        mov     [device.name], my_service
+        mov     eax, [edx + IOCTL.input]
+        movzx   ecx, byte[eax+1]
-; save the pci bus and device numbers
+        mov     [ebx + device.pci_bus], ecx
         movzx   ecx, byte[eax+2]
-        mov     eax, [edx + IOCTL.input]
+        mov     [ebx + device.pci_dev], ecx
         movzx   ecx, byte[eax+1]
-        mov     [device.pci_bus], ecx
+; Now, it's time to find the base io addres of the PCI device
         movzx   ecx, byte[eax+2]
-        mov     [device.pci_dev], ecx
+        stdcall PCI_find_io, [ebx + device.pci_bus], [ebx + device.pci_dev]
+        mov     [ebx + device.io_addr], eax
-; Now, it's time to find the base io addres of the PCI device
-        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
         DEBUGF  1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
-        [device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4
+        [ebx + device.pci_dev]:1,[ebx + device.pci_bus]:1,[ebx + device.irq_line]:1,[ebx + device.io_addr]:4
 ; Ok, the eth_device structure is ready, let's probe the device
         call    probe                                                   ; this function will output in eax
         test    eax, eax
         jnz     .err                                                    ; If an error occured, exit
-        movzx   ecx, [device.ver_id]
+        movzx   ecx, [ebx + device.ver_id]
         test    word [hw_versions+2+ecx*4], IS_VORTEX
         jz      .not_vortex
-        mov     eax, [VORTEX_DEVICES]                                   ; Add the device structure to our device list
+        mov     eax, [vortex_devices]                                   ; Add the device structure to our device list
-        mov     [VORTEX_LIST+4*eax], ebx                                ; (IRQ handler uses this list to find device)
+        mov     [vortex_list+4*eax], ebx                                ; (IRQ handler uses this list to find device)
-        inc     [VORTEX_DEVICES]                                        ;
+        inc     [vortex_devices]                                        ;
   .register:
-        mov     [device.type], NET_TYPE_ETH
+        mov     [ebx + device.type], NET_TYPE_ETH
-        call    NetRegDev
+        invoke  NetRegDev
-        cmp     eax, -1
-        je      .destroy
         cmp     eax, -1
+        je      .destroy
         call    start_device
-        ret
+        call    start_device
         ret
   .not_vortex:
 ;;        Actual Hardware dependent code starts here                      ;;
 ;;                                                                        ;;
 ;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
+align 4
+null_op:
         ret
 align 4
 probe:
         DEBUGF  1,"Probing 3com card\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
+        invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.command, eax
+; wake up the card
+        DEBUGF 1,"Checking if the device is awake\n"
+; wake up - we directly do it by programming PCI
+; check if the device is power management capable
+        invoke  PciRead16, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.status
+        test    al, PCI_STATUS_CAPA     ; is there "new capabilities" linked list?
+        jz      .device_awake
+; search for power management register
+        invoke  PciRead8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.cap_ptr
+        and     al, not 3
+        cmp     al, 0x3f
+        jbe     .device_awake           ; invalid pointer if less then PCI header size
+; traverse the list
-        PCI_make_bus_master
+        movzx   esi, al
+  .pm_loop:
+        invoke  PciRead16, [ebx + device.pci_bus], [ebx + device.pci_dev], esi
+        cmp     al, 1
+        je      .set_pm_state
+        movzx   esi, ah                 ; load address of next capability
+        test    ah, ah                  ; 0 if none left
+        jnz     .pm_loop
+        jmp     .device_awake
+; wake up the device if necessary
+  .set_pm_state:
+        DEBUGF 1,"Waking up the device\n"
+        add     esi, 4                  ; offset for power management
+        invoke  PciRead32, [ebx + device.pci_bus], [ebx + device.pci_dev], esi
+        test    al, 11b
+        jz      .device_awake
+        and     al, not 11b             ; set state to D0
+        invoke  PciWrite32, [ebx + device.pci_bus], [ebx + device.pci_dev], esi, eax
+  .device_awake:
-; wake up the card
+        DEBUGF 1,"Device is awake\n"
         call    wake_up
 ; Check device/vendor ID
         or      eax, -1
         ret
   .found:
         mov     esi, [hw_str+ecx*4]
         DEBUGF  1,"Hardware type: %s\n", esi
-        mov     [device.name], esi
+        mov     [ebx + device.name], esi
-        mov     [device.ver_id], cl
+        mov     [ebx + device.ver_id], cl
         test    word [hw_versions+2+ecx*4], HAS_HWCKSM
-        setnz   [device.has_hwcksm]
+        setnz   [ebx + device.has_hwcksm]
 ; set pci latency for vortex cards
         test    word [hw_versions+2+ecx*4], IS_VORTEX
         jz      .not_vortex
-        mov     eax, 11111000b ; 248 = max latency
+        mov     al, 11111000b ; 248 = max latency
-        stdcall PciWrite32, [device.pci_bus], [device.pci_dev], PCI_REG_LATENCY, eax
+        invoke  PciWrite8, [ebx + device.pci_bus], [ebx + device.pci_dev], PCI_header00.max_latency, eax
   .not_vortex:
 ; set RX/TX functions
         mov     ax, EEPROM_REG_CAPABILITIES
         call    read_eeprom
         test    al, 100000b ; full bus master?
-        setnz   [device.full_bus_master]
+        setnz   [ebx + device.full_bus_master]
         jnz     .boomerang_func
-        mov     [device.transmit], vortex_transmit
+        mov     [ebx + device.transmit], vortex_transmit
         DEBUGF  2,"Device is a vortex type\n"
         DEBUGF  2,"I'm sorry but vortex code hasnt been tested yet\n"
         DEBUGF  2,"Please contact me on hidnplayr@kolibrios.org\n"
         DEBUGF  2,"If you can help me finish it!\n"
         or      eax, -1
         ret
         jmp     @f
   .boomerang_func: ; full bus master, so use boomerang functions
-        mov     [device.transmit], boomerang_transmit
+        mov     [ebx + device.transmit], boomerang_transmit
         DEBUGF  1,"Device is a boomerang type\n"
        @@:
         call    read_mac_eeprom
-        test    byte [device.full_bus_master], 0xff
+        test    byte [ebx + device.full_bus_master], 0xff
         jz      .set_preamble
 ; switch to register window 2
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+2
         out     dx, ax
 ; activate xcvr by setting some magic bits
-        set_io  REG_RESET_OPTIONS
+        set_io  [ebx + device.io_addr], REG_RESET_OPTIONS
         in      ax, dx
         and     ax, not 0x4010
-        movzx   ecx, [device.ver_id]
+        movzx   ecx, [ebx + device.ver_id]
         test    word [ecx*4+hw_versions+2], INVERT_LED_PWR
         or      ah, 0x40
        @@:
         out     dx, ax
   .set_preamble:
 ; use preamble as default
-        mov     byte [device.preamble], 1 ; enable preamble
+        mov     byte [ebx + device.preamble], 1 ; enable preamble
+        DEBUGF 1,"Global reset..\n"
+; GlobalReset
+        set_io  [ebx + device.io_addr], 0
+        set_io  [ebx + device.io_addr], REG_COMMAND
+        xor     eax, eax
+;       or      al, 0x14
+        out     dx, ax
+; wait for GlobalReset to complete
+        mov     ecx, 64000
+  .rsloop:
+        in      ax , dx
+        test    ah , 10000b             ; CmdInProgress
+        loopz   .rsloop
+        DEBUGF 1,"Waiting for nic to boot..\n"
+; wait for 2 seconds for NIC to boot
+        mov     esi, 2000               ; WTF? FIXME
+        invoke  Sleep ; 2 seconds
+        DEBUGF 1,"Ok!\n"
         call    global_reset
 ;--------------------------
+;
+; RESET
-;--------------------------
 ; RESET
+;--------------------------
 align 4
 reset:
-        movzx   eax, [device.irq_line]
+        movzx   eax, [ebx + device.irq_line]
-        DEBUGF  1,"Attaching int handler to irq %x\n",eax:1
         DEBUGF  1,"Attaching int handler to irq %x\n", eax:1
         movzx   ecx, [device.ver_id]
-        test    word [hw_versions+2+ecx*4], IS_VORTEX
-        jz      .not_vortex
+        movzx   ecx, [ebx + device.ver_id]
         test    word [hw_versions+2+ecx*4], IS_VORTEX
-        mov     esi, int_vortex
-        jmp     .reg_int
+        jz      .not_vortex
+        mov     esi, int_vortex
-.not_vortex:
+        jmp     .reg_int
-        mov     esi, int_boomerang
+  .not_vortex:
         mov     esi, int_boomerang
-.reg_int:
+  .reg_int:
-        stdcall AttachIntHandler, eax, esi, dword 0
+        invoke  AttachIntHandler, eax, esi, ebx
         test    eax, eax
         jnz     @f
         DEBUGF  2,"Could not attach int handler!\n"
-;        or      eax, -1
+        or      eax, -1
-;        ret
+        ret
   @@:
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW + 0
         out     dx, ax
         mov     ax, StopCoax
         out     dx, ax                        ; stop transceiver
         mov     ax, SELECT_REGISTER_WINDOW + 4
         out     dx, ax                        ; disable UTP
-        set_io  REG_MEDIA_STATUS
+        set_io  [ebx + device.io_addr], REG_MEDIA_STATUS
         mov     ax, 0x0
-        set_io  REG_COMMAND
-        mov     ax, SELECT_REGISTER_WINDOW + 0
-        out     dx, ax
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW + 0
-        set_io  REG_FIFO_DIAGNOSTIC
+        out     dx, ax
         mov     ax, 0
-        out     dx, ax                        ; disable card
+        set_io  [ebx + device.io_addr], REG_FIFO_DIAGNOSTIC
         mov     ax, 0
-        mov     ax, 1
+        out     dx, ax                        ; disable card
         out     dx, ax                        ; enable card
         mov     ax, 1
-        call    write_mac
+        out     dx, ax                        ; enable card
         call    write_mac
 ;<<<<<<<<<<<<<<
         set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW + 1
         out     dx, ax
+        mov     ecx, 32
+        set_io  [ebx + device.io_addr], 0x0b
+  .loop:
+        in      al, dx
+        loop    .loop
+; Get rid of stray ints
+        set_io  [ebx + device.io_addr], REG_COMMAND
+        mov     ax, AckIntr + 0xff
+        out     dx, ax
-        mov     ecx, 32
+        mov     ax, SetStatusEnb + S_5_INTS
-        set_io  0x0b
+        out     dx, ax
   .loop:
-        in      al, dx
+        mov     ax, SetIntrEnb + S_5_INTS
-        loop    .loop
-; Get rid of stray ints
+        out     dx, ax
         set_io  REG_COMMAND
-        mov     ax, AckIntr + 0xff
+        DEBUGF  1,"Setting RX mode\n"
         out     dx, ax
         set_io  [ebx + device.io_addr], 0
-        mov     ax, SetStatusEnb + S_5_INTS
-        out     dx, ax
         set_io  [ebx + device.io_addr], REG_COMMAND
 align 4
 start_device:
         DEBUGF  1,"Starting the device\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SetTxThreshold + 60 ;2047 ; recommended by the manual :)
         out     dx, ax
         call    check_tx_status
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
 ; switch to register window 4
         mov     ax, SELECT_REGISTER_WINDOW+4
         out     dx, ax
 ; wait for linkDetect
-        set_io  REG_MEDIA_STATUS
+        set_io  [ebx + device.io_addr], REG_MEDIA_STATUS
-        mov     ecx, 20 ; wait for max 2s
+        mov     ecx, 20         ; wait for max 2s
   .link_detect_loop:
         mov     esi, 100
-        call    Sleep ; 100 ms
+        invoke  Sleep           ; 100 ms
         in      ax, dx
-        test    ah, 1000b ; linkDetect
+        test    ah, 1000b       ; linkDetect
         jnz     @f
         loop    .link_detect_loop
         DEBUGF  2,"Link detect timed-out!\n"
        @@:
 ; print link type
         xor     eax, eax
-        bsr     ax, word [device.state]
+        bsr     ax, word[ebx + device.internal_link]
-        jz      @f
-        sub     ax, 4
+        jz      @f
-       @@:
+        sub     ax, 5
        @@:
         mov     esi, [link_str+eax*4]
-        DEBUGF  1,"Established Link type: %s\n", esi
+        mov     esi, [link_str+eax*4]
         mov     ax, SetIntrEnb + S_5_INTS
         out     dx, ax
 ; Start RX/TX
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, RxEnable
         out     dx, ax
         mov     ax, TxEnable
         out     dx, ax
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SetRxThreshold + 208
         out     dx, ax
-        mov     ax, SetTxThreshold + 60 ;16 ; recommended by the manual :)
-        out     dx, ax
-        mov     ax, SELECT_REGISTER_WINDOW + 1
-        out     dx, ax
-        ret
-align 4
-set_rx_mode:
-        DEBUGF  1,"Setting RX mode\n"
-        set_io  0
-        set_io  REG_COMMAND
-if      defined PROMISCIOUS
-        mov     ax, SetRxFilter + RxStation + RxMulticast + RxBroadcast + RxProm
-else if  defined ALLMULTI
-        mov     ax, SetRxFilter + RxStation + RxMulticast + RxBroadcast
-else
-        mov     ax, SetRxFilter + RxStation + RxBroadcast
-end if
-        out     dx, ax
-        ret
-;***************************************************************************
-;   Function
-;      global_reset
-;   Description
-;      resets the device
-;   Parameters:
-;
-;   Return value:
-;   Destroyed registers
-;      ax, ecx, edx, esi
-;
-;***************************************************************************1
-align 4
-global_reset:
-        DEBUGF 1,"Global reset..\n"
-; GlobalReset
-        set_io  0
-        set_io  REG_COMMAND
-        xor     eax, eax
-;       or      al, 0x14
-        out     dx, ax
-; wait for GlobalReset to complete
-        mov     ecx, 64000
-  .loop:
+        mov     ax, SetTxThreshold + 60 ;16 ; recommended by the manual :)
-        in      ax , dx
-        test    ah , 10000b ; check CmdInProgress
+        out     dx, ax
-        loopz   .loop
+        mov     ax, SELECT_REGISTER_WINDOW + 1
 align 4
 tx_reset:
         DEBUGF 1,"tx reset\n"
 ; TxReset
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, TxReset
         out     dx, ax
 ; Wait for TxReset to complete
         mov     ecx, 200000
         test    ah, 10000b ; check CmdInProgress
         jz      .tx_set_prev
         dec     ecx
         jnz     .tx_reset_loop
-.tx_set_prev:
+  .tx_set_prev:
-; init last_dpd
+; init last TX descriptor
-        lea     eax, [device.dpd_buffer + (NUM_TX_DESC-1)*dpd.size]
+        lea     eax, [ebx + device.tx_desc_buffer + (NUM_TX_DESC-1)*sizeof.tx_desc]
-        mov     [device.prev_dpd], eax
+        mov     [ebx + device.curr_tx], eax
-.tx_enable:
+  .tx_enable:
 align 4
 rx_reset:
         DEBUGF 1,"rx reset\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, RxReset or 0x4
         out     dx, ax
         jz      .done
         dec     ecx
         jnz     .loop
   .done:
-        lea     eax, [device.upd_buffer]
+        lea     eax, [ebx + device.rx_desc_buffer]
-        mov     [device.curr_upd], eax
+        mov     [ebx + device.curr_rx], eax
-        GetRealAddr
+        invoke  GetPhysAddr
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_UP_LIST_PTR
+        set_io  [ebx + device.io_addr], REG_UP_LIST_PTR
         out     dx, eax
+  .rx_enable:
-  .rx_enable:
+        ret
         ret
 align 4
 create_rx_ring:
-; create upd ring
+; create rx descriptor ring
-        lea     eax, [device.upd_buffer]
+        lea     eax, [ebx + device.rx_desc_buffer]
-        GetRealAddr
+        invoke  GetPhysAddr
-        mov     edi, eax                                                ; real addr of first descr
+        mov     edi, eax                                                ; real addr of first descr
-        lea     esi, [device.upd_buffer]                                ; ptr to first descr
-        lea     edx, [device.upd_buffer + (NUM_RX_DESC-1)*upd.size]     ; ptr to last descr
+        lea     esi, [ebx + device.rx_desc_buffer]                          ; ptr to first descr
+        lea     edx, [ebx + device.rx_desc_buffer + (NUM_RX_DESC-1)*sizeof.rx_desc]     ; ptr to last descr
         mov     ecx, NUM_RX_DESC
+        mov     ecx, NUM_RX_DESC
-  .upd_loop:
+  .loop:
-        mov     [edx + upd.next_ptr], edi
+        mov     [edx + rx_desc.next_ptr], edi
         push    ecx edx
-        stdcall KernelAlloc, MAX_ETH_FRAME_SIZE
+        invoke  KernelAlloc, MAX_ETH_FRAME_SIZE
         pop     edx ecx
-        mov     [esi + upd.realaddr], eax
+        mov     [esi + rx_desc.realaddr], eax
-        call    GetPgAddr
+        invoke  GetPgAddr
-        mov     [esi + upd.frag_addr], eax
+        mov     [esi + rx_desc.frag_addr], eax
-        and     [esi + upd.pkt_status], 0
+        and     [esi + rx_desc.pkt_status], 0
-        mov     [esi + upd.frag_len], MAX_ETH_FRAME_SIZE or (1 shl 31)
+        mov     [esi + rx_desc.frag_len], MAX_ETH_FRAME_SIZE or (1 shl 31)
 ;---------------------------------------------------------------------------
 align 4
 try_link_detect:
-        DEBUGF  1,"trying to detect link\n"
+        DEBUGF  1,"Trying to detect link\n"
 ; create self-directed packet
-        stdcall KernelAlloc, 20 ; create a buffer for the self-directed packet
+        invoke  KernelAlloc, 20 ; create a buffer for the self-directed packet
         test    eax, eax
         jz      .fail
         pushd   20              ; Packet parameters for device.transmit
         push    eax             ;
         mov     edi, eax
-        lea     esi, [device.mac]
+        lea     esi, [ebx + device.mac]
         movsw
         movsd
         sub     esi, 6
         movsw
         movsd
         mov     ax , 0x0608
         stosw
 ; download self-directed packet
-        call    [device.transmit]
+        call    [ebx + device.transmit]
 ; switch to register window 4
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+4
         out     dx, ax
 ; See if we have received the packet by now..
-        cmp     [device.packets_rx], 0
+        cmp     [ebx + device.packets_rx], 0
         jnz     .link_detected
 ; switch to register window 4
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+4
         out     dx, ax
 ; read linkbeatdetect
-        set_io  REG_MEDIA_STATUS
+        set_io  [ebx + device.io_addr], REG_MEDIA_STATUS
         in      ax, dx
         test    ah, 1000b ; test linkBeatDetect
         jnz     .link_detected
         xor     al, al
+        jmp     .finish
         jmp     .finish
   .link_detected:
 try_phy:
         DEBUGF 1,"PHY=%u\n", ah
         DEBUGF 1,"Detecting if device is auto-negotiation capable\n"
-        mov     al, REG_MII_BMCR
+        mov     al, MII_BMCR
         push    eax
         call    mdio_read       ; returns with window #4
-        or      ah , 0x80       ; software reset
+        or      ah, 0x80        ; software reset
         mov     esi, eax
-        mov     eax, dword [esp]
+        mov     eax, [esp]
         call    mdio_write      ; returns with window #4
 ; wait for reset to complete
         mov     esi, 2000
-        stdcall Sleep      ; 2s
+        invoke  Sleep      ; 2s
         mov     eax, [esp]
         call    mdio_read       ; returns with window #4
-        test    ah , 0x80
+        test    ah, 0x80
         jnz     .fail1
         mov     eax, [esp]
 ; wait for a while after reset
         mov     esi, 20
-        stdcall Sleep      ; 20ms
+        invoke  Sleep      ; 20ms
         mov     eax, [esp]
+        mov     al , MII_BMSR
-        mov     al , REG_MII_BMSR
+        call    mdio_read        ; returns with window #4
-        call    mdio_read        ; returns with window #4
+        test    al, 1            ; extended capability supported?
-        test    al , 1           ; extended capability supported?
+        jz      .fail2
-        jz      .fail2
+        DEBUGF  1,"Extended capability supported\n"
 ; auto-neg capable?
-        test    al , 1000b
+; auto-neg capable?
-        jz      .fail2           ; not auto-negotiation capable
+        test    al , 1000b
-        DEBUGF  1,"Device is auto-negotiation capable\n"
+        jz      .fail2           ; not auto-negotiation capable
         DEBUGF  1,"Auto-negotiation capable\n"
 ; auto-neg complete?
-        test    al , 100000b
+; auto-neg complete?
-        jnz     .auto_neg_ok
+        test    al , 100000b
         jnz     .auto_neg_ok
         DEBUGF  1,"Restarting auto-negotiation\n"
 ; restart auto-negotiation
         mov     esi, eax
         or      bh , 10010b     ; restart auto-negotiation
         mov     eax, [esp]
         call    mdio_write      ; returns with window #4
         mov     esi, 4000
-        stdcall Sleep  ; 4 seconds
+        invoke  Sleep  ; 4 seconds
         mov     eax, [esp]
-        mov     al , REG_MII_BMSR
+        mov     al , MII_BMSR
         call    mdio_read ; returns with window #4
         test    al , 100000b ; auto-neg complete?
         jnz     .auto_neg_ok
         jmp     .fail3
   .auto_neg_ok:
         DEBUGF  1,"Auto-negotiation complete\n"
 ; compare advertisement and link partner ability registers
         mov     eax, [esp]
-        mov     al , REG_MII_ANAR
+        mov     al, MII_ADVERTISE
-        call    mdio_read       ; returns with window #4
+        call    mdio_read               ; returns with window #4
         xchg    eax, [esp]
-        mov     al , REG_MII_ANLPAR
+        mov     al, MII_LPA
-        call    mdio_read       ; returns with window #4
+        call    mdio_read               ; returns with window #4
         pop     esi
         and     eax, esi
-        and     eax, 1111100000b
+        and     eax, 11111100000b       ; Mask off
-        push    eax
+        push    eax
-        mov     word[device.state+2], ax
+        mov     word[ebx + device.internal_link+2], ax
 ; switch to register window 3
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
-        mov     ax , SELECT_REGISTER_WINDOW+3
+        mov     ax, SELECT_REGISTER_WINDOW+3
-        out     dx , ax
+        out     dx, ax
 ; set full-duplex mode
-        set_io  REG_MAC_CONTROL
+        set_io  [ebx + device.io_addr], REG_MAC_CONTROL
-        in      ax , dx
+        in      ax, dx
-        and     ax , not 0x120  ; clear full duplex and flow control
+        and     ax, not 0x120           ; clear full duplex and flow control
         DEBUGF 1,"Using half-duplex\n"
-        out     dx , ax
+        out     dx, ax
-        mov     al , 1
+        mov     al, 1
         ret
   .fail1:
         DEBUGF  2,"reset failed!\n"
         pop     eax
         xor     al, al
         pop     eax
         xor     al, al
         ret
   .fail3:
-        DEBUGF  2,"auto-negotiation reset failed!\n"
+        DEBUGF  2,"Auto-negotiation reset failed!\n"
         pop     eax
         xor     al, al
 ;***************************************************************************
 align 4
 try_mii:
-        DEBUGF  1,"trying to find MII PHY\n"
+        DEBUGF  1,"Trying to find MII PHY\n"
 ; switch to register window 3
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+3
         out     dx, ax
-        set_io  REG_INTERNAL_CONFIG
+        set_io  [ebx + device.io_addr], REG_INTERNAL_CONFIG
         in      eax, dx
         and     eax, (1111b shl 20)
         cmp     eax, (1000b shl 20) ; is auto-negotiation set?
         jne     .mii_device
-        DEBUGF  1,"auto-negotiation is set\n"
+        DEBUGF  1,"Auto-negotiation is set\n"
 ; switch to register window 4
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
-        mov     ax , SELECT_REGISTER_WINDOW+4
+        mov     ax, SELECT_REGISTER_WINDOW+4
-        out     dx , ax
+        out     dx, ax
 ; PHY==24 is the on-chip auto-negotiation logic
 ; it supports only 10base-T and 100base-TX
-        mov     ah , 24
+        mov     ah, 24
         call    try_phy
-        test    al , al
+        test    al, al
-        jz      .fail_finish
+        jz      .fail
-        mov     cl , 24
+        mov     cl, 24
         jmp     .check_preamble
   .mii_device:
         cmp     eax, (0110b shl 20)
-        jne     .fail_finish
+        jne     .fail
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
   .search_for_phy:
 ; search for PHY
-        mov     cx , 31
+        mov     cx, 31
   .search_phy_loop:
-        DEBUGF  1,"Searching the PHY\n"
+        DEBUGF  1,"Searching for the PHY\n"
-        cmp     cx , 24
+        cmp     cx, 24
         je      .next_phy
-        mov     ah , cl ; ah = phy
+        mov     ah, cl                  ; ah = phy
-        mov     al , REG_MII_BMCR ; al = Basic Mode Status Register
+        mov     al, MII_BMSR            ; al = Basic Mode Status Register       ; BUGFIX HERE! :):)
         push    cx
         call    mdio_read
         pop     cx
-        test    ax , ax
+        test    ax, ax
-        test    al , al
+        test    al, al
         jnz     .check_preamble
   .next_phy:
         loopw   .search_phy_loop
+  .fail:
-  .fail_finish:
+        DEBUGF  1,"PHY not found\n"
         xor     al, al
         ret
 ; epilog
   .check_preamble:
         DEBUGF  1,"Using PHY: %u\nChecking PreAmble\n", cl
         push    eax ; eax contains the return value of try_phy
 ; check hard coded preamble forcing
-        movzx   eax, [device.ver_id]
+        movzx   eax, [ebx + device.ver_id]
         test    word [eax*4+hw_versions+2], EXTRA_PREAMBLE
-        setnz   [device.preamble] ; force preamble
+        setnz   [ebx + device.preamble] ; force preamble
         jnz     .finish
 ; check mii for preamble suppression
         mov     ah, cl
-        mov     al, REG_MII_BMSR
+        mov     al, MII_BMSR
         call    mdio_read
         test    al, 1000000b ; preamble suppression?
-        setz    [device.preamble] ; no
+        setz    [ebx + device.preamble] ; no
 ;***************************************************************************
 align 4
 test_packet:
-        DEBUGF 1,"sending test packet\n"
+        DEBUGF 1,"Sending test packet\n"
 ; switch to register window 3
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+3
         out     dx, ax
 ; set fullDuplexEnable in MacControl register
-        set_io  REG_MAC_CONTROL
+        set_io  [ebx + device.io_addr], REG_MAC_CONTROL
         in      ax, dx
         or      ax, 0x120
         out     dx, ax
 ; switch to register window 5
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+5
         out     dx, ax
 ; set RxFilter to enable individual address matches
         mov     ax, (10000b shl 11)
-        set_io  REG_RX_FILTER
+        set_io  [ebx + device.io_addr], REG_RX_FILTER
         in      al, dx
         or      al, 1
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         out     dx, ax
 ; issue RxEnable and TxEnable
         call    rx_reset
         call    tx_reset
 ; create self-directed packet
-        stdcall KernelAlloc, 20 ; create a buffer for the self-directed packet
+        invoke  KernelAlloc, 20 ; create a buffer for the self-directed packet
         test    eax, eax
         jz      .fail
         pushd   20              ; Packet parameters for device.transmit
         push    eax             ;
         mov     edi, eax
-        lea     esi, [device.mac]
+        lea     esi, [ebx + device.mac]
         movsw
         movsd
         sub     esi, 6
         movsw
         movsd
-        mov     ax , 0x0608
+        mov     ax, 0x0608
         stosw
 ; download self-directed packet
-        call    [device.transmit]
+        call    [ebx + device.transmit]
 ; wait for 2s
         mov     esi, 2000
-        call    Sleep
+        invoke  Sleep
 ; check if self-directed packet is received
-        mov     eax, [device.packets_rx]
+        mov     eax, [ebx + device.packets_rx]
         test    eax, eax
         DEBUGF 1,"trying loopback\n"
         push    eax
 ; switch to register window 3
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+3
         out     dx, ax
         mov     eax, [esp]
         mov     cl, al
         inc     cl
         shl     cl, 3
-        or      byte [device.state+1], cl
+        or      byte [ebx + device.internal_link+1], cl
         xchg    eax, [esp]
         test    al, al
         jz      .aui_finish
 ; issue DisableDcConverter command
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, (10111b shl 11)
         out     dx, ax
   .aui_finish:
         pop     eax ; al contains the result of operation
         test    al, al
         jnz     @f
-        and     byte [device.state+1], not 11000b
+        and     byte [ebx + device.internal_link+1], not 11000b
 set_active_port:
         DEBUGF 1,"Trying to find the active port\n"
 ; switch to register window 3
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW + 3
         out     dx, ax
-        set_io  REG_INTERNAL_CONFIG
+        set_io  [ebx + device.io_addr], REG_INTERNAL_CONFIG
         in      eax, dx
         test    eax, (1 shl 24) ; check if autoselect enable
         jz      .set_first_available_media
 ; check 100BASE-TX and 10BASE-T
-        set_io  REG_MEDIA_OPTIONS
+        set_io  [ebx + device.io_addr], REG_MEDIA_OPTIONS
         in      ax, dx
         test    al, 1010b       ; check whether 100BASE-TX or 10BASE-T available
         jz      .mii_device     ; they are not available
 ; set auto-negotiation
-        set_io  REG_INTERNAL_CONFIG
+        set_io  [ebx + device.io_addr], REG_INTERNAL_CONFIG
         DEBUGF 1,"Using auto negotiation\n"
         ret
   .mii_device:
 ; switch to register window 3
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
 ; check for off-chip mii device
-        set_io  REG_MEDIA_OPTIONS
+        set_io  [ebx + device.io_addr], REG_MEDIA_OPTIONS
         in      ax, dx
         test    al, 1000000b ; check miiDevice
         jz      .base_fx
-        set_io  REG_INTERNAL_CONFIG
+        set_io  [ebx + device.io_addr], REG_INTERNAL_CONFIG
         in      eax, dx
         and     eax, not (1111b shl 20)
         or      eax, (0110b shl 20) ; set MIIDevice
         out     dx, eax
         DEBUGF 1,"Using off-chip mii device\n"
         ret
   .base_fx:
 ; switch to register window 3
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
 ; check for 100BASE-FX
-        set_io  REG_MEDIA_OPTIONS
+        set_io  [ebx + device.io_addr], REG_MEDIA_OPTIONS
         in      ax, dx ; read media option register
         test    al, 100b ; check 100BASE-FX
         jz      .aui_enable
-        set_io  REG_INTERNAL_CONFIG
+        set_io  [ebx + device.io_addr], REG_INTERNAL_CONFIG
         in      eax, dx
         and     eax, not (1111b shl 20)
         or      eax, (0101b shl 20) ; set 100base-FX
         out     dx, eax
         DEBUGF 1,"Using 100Base-FX\n"
         ret
   .aui_enable:
 ; switch to register window 3
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
 ; check for 10Mbps AUI connector
-        set_io  REG_MEDIA_OPTIONS
+        set_io  [ebx + device.io_addr], REG_MEDIA_OPTIONS
         in      ax, dx ; read media option register
         test    al, 100000b ; check 10Mbps AUI connector
         jz      .coax_available
-        set_io  REG_INTERNAL_CONFIG
+        set_io  [ebx + device.io_addr], REG_INTERNAL_CONFIG
         in      eax, dx
         and     eax, not (1111b shl 20)
         or      eax, (0001b shl 20) ; set 10Mbps AUI connector
         out     dx, eax
         DEBUGF 1,"Using 10Mbps aui\n"
         ret
   .coax_available:
 ; switch to register window 3
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
 ; check for coaxial 10BASE-2 port
-        set_io  REG_MEDIA_OPTIONS
+        set_io  [ebx + device.io_addr], REG_MEDIA_OPTIONS
         in      ax, dx ; read media option register
         test    al, 10000b ; check 10BASE-2
         jz      .set_first_available_media
-        set_io  REG_INTERNAL_CONFIG
+        set_io  [ebx + device.io_addr], REG_INTERNAL_CONFIG
         in      eax, dx
         and     eax, not (1111b shl 20)
         or      eax, (0011b shl 20) ; set 10BASE-2
 align 4
 set_available_media:
         DEBUGF  1,"Setting the available media\n"
 ; switch to register window 3
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+3
         out     dx, ax
-        set_io  REG_MEDIA_OPTIONS
+        set_io  [ebx + device.io_addr], REG_MEDIA_OPTIONS
         in      ax, dx
         DEBUGF  1,"available media:%x\n", al
         mov     cl, al
-        set_io  REG_INTERNAL_CONFIG
+        set_io  [ebx + device.io_addr], REG_INTERNAL_CONFIG
         in      eax, dx
         and     eax, not (1111b shl 20) ; these bits hold the 'transceiver select' value
         test    cl, 10b         ; baseTXAvailable
         jz      @f
         DEBUGF  1,"base TX is available\n"
         or      eax, (100b shl 20)
-if defined FORCE_FD
+if FORCE_FD
-        mov     word [device.state], (1 shl 8)
+        mov     word [ebx + device.internal_link], (1 shl 8)
 else
-        mov     word [device.mode], (1 shl 7)
+        mov     word [ebx + device.internal_link], (1 shl 7)
 end if
         jmp     .set_media
        @@:
         test    cl, 100b        ; baseFXAvailable
         jz      @f
         DEBUGF  1,"base FX is available\n"
         or      eax, (101b shl 20)
-        mov     word [device.state], (1 shl 10)
+        mov     word [ebx + device.internal_link], (1 shl 10)
         jmp     .set_media
        @@:
         test    cl, 1000000b    ; miiDevice
         jz      @f
         DEBUGF  1,"mii-device is available\n"
         or      eax, (0110b shl 20)
-        mov     word [device.state], (1 shl 13)
+        mov     word [ebx + device.internal_link], (1 shl 13)
         jmp     .set_media
        @@:
         test    cl, 1000b       ; 10bTAvailable
         jz      @f
         DEBUGF  1,"10base-T is available\n"
   .set_default:
 if FORCE_FD
-        mov     word [device.state], (1 shl 6)
+        mov     word [ebx + device.internal_link], (1 shl 6)
 else
-        mov     word [device.state], (1 shl 5)
+        mov     word [ebx + device.internal_link], (1 shl 5)
 end if
         jmp     .set_media
        @@:
         test    cl, 10000b      ; coaxAvailable
         jz      @f
         DEBUGF  1,"coax is available\n"
         push    eax
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, (10b shl 11) ; EnableDcConverter
         out     dx, ax
         pop     eax
         or      eax, (11b shl 20)
-        mov     word [device.state], (1 shl 12)
+        mov     word [ebx + device.internal_link], (1 shl 12)
         jmp     .set_media
        @@:
         test    cl, 10000b      ; auiAvailable
         jz      .set_default
-        DEBUGF  1,"AUI is available\n"
-        or      eax, (1 shl 20)
-        mov     word [device.state], (1 shl 11)
-  .set_media:
-        set_io  0
-        set_io  REG_INTERNAL_CONFIG
-        out     dx, eax
-if FORCE_FD
-        DEBUGF  1,"Forcing full duplex\n"
-        set_io  REG_MAC_CONTROL
-        in      ax, dx
-        or      ax, 0x120
-        out     dx, ax
-end if
-        mov     al, 1
-        ret
-;***************************************************************************
-;   Function
-;      wake_up
-;   Description
-;      set the power state to D0
-;
-;***************************************************************************
-align 4
-wake_up:
-        DEBUGF 1,"Waking up NIC: "
-; wake up - we directly do it by programming PCI
-; check if the device is power management capable
-        stdcall PciRead32, [device.pci_bus], [device.pci_dev], PCI_REG_STATUS
-        test    al, 10000b      ; is there "new capabilities" linked list?
-        jz      .device_awake
-; search for power management register
-        stdcall PciRead16, [device.pci_bus], [device.pci_dev], PCI_REG_CAP_PTR
-        cmp     al, 0x3f
-        jbe     .device_awake
-; traverse the list
-        movzx   esi, al
-  .pm_loop:
-        stdcall PciRead32, [device.pci_bus], [device.pci_dev], esi
-        cmp     al , 1
-        je      .set_pm_state
-        movzx   esi, ah
-        test    ah , ah
-        jnz     .pm_loop
-        jmp     .device_awake
+        DEBUGF  1,"AUI is available\n"
         or      eax, (1 shl 20)
-; waku up the device if necessary
+        mov     word [ebx + device.internal_link], (1 shl 11)
   .set_pm_state:
   .set_media:
         DEBUGF 1,"Reading from eeprom.. "
         push    eax
 ; switch to register window 0
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+0
         out     dx, ax
         pop     eax
         and     ax, 111111b ; take only the first 6 bits into account
-        movzx   esi, [device.ver_id]
+        movzx   esi, [ebx + device.ver_id]
         test    word [esi*4+hw_versions+2], EEPROM_8BIT
         test    word [esi*4+hw_versions+2], EEPROM_OFFSET
         jz      .read
         add     ax, 0x30
 .read:
-        set_io  REG_EEPROM_COMMAND
+        set_io  [ebx + device.io_addr], REG_EEPROM_COMMAND
         out     dx, ax
         mov     ecx, 0xffff ; duration of about 162 us ;-)
 .wait_for_reading:
         in      ax, dx
         test    ah, 0x80 ; check bit eepromBusy
         jz      .read_data
         loop    .wait_for_reading
 .read_data:
-        set_io  REG_EEPROM_DATA
+        set_io  [ebx + device.io_addr], REG_EEPROM_DATA
         in      ax, dx
 mdio_sync:
         DEBUGF 1,"syncing mdio\n"
 ; switch to register window 4
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+4
         out     dx, ax
-        cmp     [device.preamble], 0
+        cmp     [ebx + device.preamble], 0
         je      .no_preamble
 ; send 32 logic ones
-        set_io  REG_PHYSICAL_MGMT
+        set_io  [ebx + device.io_addr], REG_PHYSICAL_MGMT
         mov     ecx, 31
   .loop:
         mov     ax, (1 shl BIT_MGMT_DATA) or (1 shl BIT_MGMT_DIR)
         DEBUGF 1,"Reading MII registers\n"
         push    eax
         call    mdio_sync ; returns with window #4
         pop     eax
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_PHYSICAL_MGMT
+        set_io  [ebx + device.io_addr], REG_PHYSICAL_MGMT
         shl     al, 3
         shr     ax, 3
         and     ax, not MII_CMD_MASK
         DEBUGF 1,"Writing MII registers\n"
         push    eax
         call    mdio_sync
         pop     eax
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_PHYSICAL_MGMT
+        set_io  [ebx + device.io_addr], REG_PHYSICAL_MGMT
         shl     al, 3
         shr     ax, 3
         and     ax, not MII_CMD_MASK
         or      ax, MII_CMD_WRITE
 check_tx_status:
         DEBUGF 1,"Checking TX status\n"
 ; clear TxStatus queue
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_TX_STATUS
+        set_io  [ebx + device.io_addr], REG_TX_STATUS
         mov     ecx, 31 ; max number of queue entries
         xor     al, al
         out     dx, al
         loop    .tx_status_loop
-  .finish:
   .finish:
         ret
   .error:
 ;;     size of buffer in [esp+8]           ;;
 ;;     pointer to device structure in ebx  ;;
 ;;                                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+proc vortex_transmit stdcall bufferptr, buffersize
-align 4
+        pushf
+        cli
-vortex_transmit:
+        DEBUGF  1,"Transmitting packet, buffer:%x, size:%u\n", [bufferptr], [buffersize]
+        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,\
-        DEBUGF 1,"Sending packet (vortex)\n"
+        [eax+13]:2,[eax+12]:2
+        cmp     [buffersize], 1514
         ja      .fail
-        cmp     dword [esp+8], MAX_ETH_FRAME_SIZE
+        cmp     [buffersize], 60
-        ja      .finish ; packet is too long
+        jb      .fail
         call    check_tx_status
 ; switch to register window 7
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+7
         out     dx, ax
 ; check for master operation in progress
-        set_io  REG_MASTER_STATUS
+        set_io  [ebx + device.io_addr], REG_MASTER_STATUS
         in      ax, dx
         test    ah, 0x80
         jnz     .fail ; no DMA for sending
 ; program frame address to be sent
-        set_io  REG_MASTER_ADDRESS
+        set_io  [ebx + device.io_addr], REG_MASTER_ADDRESS
-        mov     eax, [esp+4]
+        mov     eax, [bufferptr]
-        call    GetPgAddr
-        out     dx, eax
+        invoke  GetPhysAddr
-; program frame length
+        out     dx, eax
-        set_io  REG_MASTER_LEN
+; program frame length
-        mov     eax, [esp+8]
+        set_io  [ebx + device.io_addr], REG_MASTER_LEN
-;;;        and     eax, not 3
+        mov     eax, [buffersize]
         out     dx, ax
+; start DMA Down
-; start DMA Down
+        set_io  [ebx + device.io_addr], REG_COMMAND
-        set_io  REG_COMMAND
+        mov     ax, (10100b shl 11) + 1 ; StartDMADown
-        mov     ax, (10100b shl 11) + 1 ; StartDMADown
+        out     dx, ax
+  .finish:
-        out     dx, ax
+        popf
+        xor     eax, eax
-  .finish:
+        ret
-        xor     eax, eax
+  .fail:
+        DEBUGF  2,"Send failed\n"
-        ret     8
+        invoke  KernelFree, [bufferptr]
         popf
-  .fail:
+        or      eax, -1
-        stdcall KernelFree, [esp+4]
+        ret
 ;;     size of buffer in [esp+8]           ;;
 ;;     pointer to device structure in ebx  ;;
 ;;                                         ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+proc boomerang_transmit stdcall bufferptr, buffersize
-align 4
+        pushf
-boomerang_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",\
         [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     [buffersize], 1514
+        ja      .fail
-        cmp     dword [esp+8], MAX_ETH_FRAME_SIZE
+        cmp     [buffersize], 60
-        ja      .fail
+        jb      .fail
-        call    check_tx_status
+        call    check_tx_status                         ; Reset TX engine if needed
 ; calculate descriptor address
-        mov     esi, [device.prev_dpd]
+        mov     esi, [ebx + device.curr_tx]
-        DEBUGF  1,"Previous DPD: %x\n", esi
+        DEBUGF  1,"Previous TX desc: %x\n", esi
-        add     esi, dpd.size
+        add     esi, sizeof.tx_desc
-        lea     ecx, [device.dpd_buffer + (NUM_TX_DESC)*dpd.size]
+        lea     ecx, [ebx + device.tx_desc_buffer + (NUM_TX_DESC)*sizeof.tx_desc]
         cmp     esi, ecx
         jb      @f
-        lea     esi, [device.dpd_buffer]        ; Wrap if needed
+        lea     esi, [ebx + device.tx_desc_buffer]      ; Wrap if needed
        @@:
-        DEBUGF  1,"Found a free DPD: %x\n", esi
+        DEBUGF  1,"Using TX desc: %x\n", esi
 ; check DnListPtr
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_DN_LIST_PTR
+        set_io  [ebx + device.io_addr], REG_DN_LIST_PTR
         in      eax, dx
 ; mark if Dn_List_Ptr is cleared
         test    eax, eax
-        setz    [device.dn_list_ptr_cleared]
+        setz    [ebx + device.dn_list_ptr_cleared]
 ; finish if no more free descriptor is available - FIXME!
 ;        cmp     eax, esi
 ;        jz      .finish
 ; update statistics
-        inc     [device.packets_tx]
+        inc     [ebx + device.packets_tx]
-        mov     ecx, [esp+8]            ; buffer size
+        mov     ecx, [buffersize]
-        add     dword [device.bytes_tx], ecx
+        add     dword [ebx + device.bytes_tx], ecx
-        adc     dword [device.bytes_tx + 4], 0
+        adc     dword [ebx + device.bytes_tx + 4], 0
 ; program DPD
-        and     [esi+dpd.next_ptr], 0
+        and     [esi + tx_desc.next_ptr], 0
-        mov     eax, [esp+4]            ; Tx buffer address
+        mov     eax, [bufferptr]
-        mov     [esi+dpd.realaddr], eax
-        call    GetPgAddr
-        mov     [esi+dpd.frag_addr], eax
-        mov     ecx, [esp+8]            ; packet size
+        mov     [esi + tx_desc.realaddr], eax
-        or      ecx, 0x80000000         ; last fragment
+        invoke  GetPhysAddr
-        mov     [esi+dpd.frag_len], ecx
+        mov     [esi + tx_desc.frag_addr], eax
         mov     ecx, [buffersize]
-        mov     ecx, [esp+8]            ; packet size
+        or      ecx, 0x80000000         ; last fragment flag
-;        or      ecx, 0x8000             ; transmission complete notification
+        mov     [esi + tx_desc.frag_len], ecx
-        or      ecx, 1 shl 31
         mov     ecx, [buffersize]       ; packet size
-;        test    byte [device.has_hwcksm], 0xff
+        or      ecx, 0x80008000         ; set OWN bit + transmission complete notification flag
-;        jz      @f
+;        test    byte [ebx + device.has_hwcksm], 0xff
-;        or      ecx, (1 shl 26)         ; set AddTcpChecksum
+;        jz      @f
-;@@:
+;        or      ecx, (1 shl 26)         ; set AddTcpChecksum
-        mov     [esi+dpd.frame_start_hdr], ecx
+;@@:
+        mov     [esi + tx_desc.frame_start_hdr], ecx
-        DEBUGF  1,"DPD: lin=%x phys=%x len=%x start hdr=%x\n", [esi+dpd.realaddr]:8, [esi+dpd.frag_addr]:8, [esi+dpd.frag_len]:8, [esi+dpd.frame_start_hdr]:8
+        DEBUGF  1,"TX desc: lin=%x phys=%x len=%x start hdr=%x\n", [esi+tx_desc.realaddr]:8, [esi+tx_desc.frag_addr]:8, [esi+tx_desc.frag_len]:8, [esi+tx_desc.frame_start_hdr]:8
-; calculate physical address of dpd
+; calculate physical address of tx descriptor
         mov     eax, esi
-        GetRealAddr
+        invoke  GetPhysAddr
-        cmp     [device.dn_list_ptr_cleared], 0
+        cmp     [ebx + device.dn_list_ptr_cleared], 0
-        jz      .add_to_list
+        je      .add_to_list
 ; write Dn_List_Ptr
-        DEBUGF  1,"DPD phys addr=%x\n", eax
+        DEBUGF  1,"TX desc phys addr=%x\n", eax
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_DN_LIST_PTR
+        set_io  [ebx + device.io_addr], REG_DN_LIST_PTR
         out     dx, eax
         dec     ecx
         jnz     .wait_for_stall
   .dnstall_ok:
         DEBUGF  1,"DnStall ok!\n"
-        mov     ecx, [device.prev_dpd]
+        mov     ecx, [ebx + device.curr_tx]
-        mov     [ecx+dpd.next_ptr], eax
+        mov     [ecx + tx_desc.next_ptr], eax
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_DN_LIST_PTR
+        set_io  [ebx + device.io_addr], REG_DN_LIST_PTR
         in      eax, dx
         test    eax, eax
         DEBUGF  1,"DnList Ptr has been cleared\n"
         out     dx, eax
   .dnunstall:
 ; DnUnStall
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, ((110b shl 11)+3)
         out     dx, ax
+  .finish:
-  .finish:
+        mov     [ebx + device.curr_tx], esi
-        mov     [device.prev_dpd], esi
+        popf
         xor     eax, eax
+        ret
-        ret     8
+  .fail:
         DEBUGF  2,"Send failed\n"
-  .fail:
+        invoke  KernelFree, [bufferptr]
+        popf
+        or      eax, -1
+        ret
         stdcall KernelFree, [esp+4]
-        or      eax, -1
+endp
         ret     8
 ;---------------------------------
 ; Write MAC
 align 4
 write_mac:
         DEBUGF 1,"Writing mac\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
 ; switch to register window 2
         mov     ax, SELECT_REGISTER_WINDOW+2
 ; Read MAC
 align 4
+read_mac:
-read_mac:
+        DEBUGF 1,"Reading MAC\n"
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
 ; switch to register window 2
         mov     ax, SELECT_REGISTER_WINDOW+2
         out     dx, ax
-; write MAC addres back into the station address registers
+; Read the MAC and write it to device.mac
-        set_io  REG_STATION_ADDRESS_LO
+        set_io  [ebx + device.io_addr], REG_STATION_ADDRESS_LO
-        lea     edi, [device.mac]
+        lea     edi, [ebx + device.mac]
         insw
         inc     dx
         inc     dx
+        insw
+        inc     dx
-        insw
+        inc     dx
-        inc     dx
+        insw
         inc     dx
-        insw
+        DEBUGF 1,"%x-%x-%x-%x-%x-%x\n", \
         [ebx + device.mac+0]:2,[ebx + device.mac+1]:2,[ebx + device.mac+2]:2,\
-        DEBUGF 1,"%x-%x-%x-%x-%x-%x\n",[device.mac]:2,[device.mac+1]:2,[device.mac+2]:2,[device.mac+3]:2,[device.mac+4]:2,[device.mac+5]:2
+        [ebx + device.mac+3]:2,[ebx + device.mac+4]:2,[ebx + device.mac+5]:2
         ret
 ;------------------------------------
 ; Read MAC from eeprom
 align 4
-read_mac_eeprom:        ; Tested - ok
+read_mac_eeprom:
-        DEBUGF 1,"Reading mac from eeprom\n"
+        DEBUGF 1,"Reading MAC from eeprom\n"
+; read MAC from eeprom and write it to device.mac
+        mov     ecx, 3
-; read MAC from eeprom
+  .mac_loop:
         DEBUGF  1,"INT\n"
-; find pointer of device wich made IRQ occur
 ; find pointer of device wich made IRQ occur
         mov     esi, VORTEX_LIST
+        mov     ecx, [vortex_devices]
-        mov     ecx, [VORTEX_DEVICES]
+        test    ecx, ecx
-        test    ecx, ecx
+        jz      .nothing
-        jz      .nothing
+        mov     esi, vortex_list
   .nextdevice:
-        mov     ebx, dword [esi]
+        mov     ebx, [esi]
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
         ret
 .got_it:
-        DEBUGF  1,"Device: %x Status: %x ",ebx,eax:4
+        DEBUGF  1,"Device: %x Status: %x\n", ebx, eax:4
         test    ax, RxComplete
         jz      .noRX
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
   .rx_status_loop:
 ; examine RxStatus
         test    ah, 0x40
         jz      .check_length
 ; discard the top frame received advancing the next one
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, (01000b shl 11)
         out     dx, ax
         ja      .discard_frame ; frame is too long discard it
   .check_dma:
         mov     ecx, eax
 ; switch to register window 7
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, SELECT_REGISTER_WINDOW+7
         out     dx, ax
 ; check for master operation in progress
-        set_io  REG_MASTER_STATUS
+        set_io  [ebx + device.io_addr], REG_MASTER_STATUS
         in      ax, dx
         test    ah, 0x80
         jnz     .finish
   .read_frame:
 ; program buffer address to read in
         push    ecx
-        stdcall KernelAlloc, MAX_ETH_FRAME_SIZE
+        invoke  KernelAlloc, MAX_ETH_FRAME_SIZE
         pop     ecx
         test    eax, eax
         jz      .finish
         push    .discard_frame
         push    ecx
         push    eax
 ;        zero_to_dma eax
-        set_io  REG_MASTER_ADDRESS
+        set_io  [ebx + device.io_addr], REG_MASTER_ADDRESS
         out     dx, eax
 ; program frame length
-        set_io  REG_MASTER_LEN
+        set_io  [ebx + device.io_addr], REG_MASTER_LEN
         mov     ax, 1560
         out     dx, ax
 ; start DMA Up
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         mov     ax, (10100b shl 11) ; StartDMAUp
         out     dx, ax
 ; check for master operation in progress
-        set_io  REG_MASTER_STATUS   ; TODO: use timeout and reset after timeout expired
+        set_io  [ebx + device.io_addr], REG_MASTER_STATUS   ; TODO: use timeout and reset after timeout expired
   .dma_loop:
         in      ax, dx
         test    ah, 0x80
         jnz     .dma_loop
 ; registrate the received packet to kernel
         test    ax, DMADone
         jz      .noDMA
         push    ax
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  12
+        set_io  [ebx + device.io_addr], 12
         in      ax, dx
         test    ax, 0x1000
 .noDMA:
 .ACK:
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         DEBUGF  1,"INT\n"
 ; find pointer of device wich made IRQ occur
-        mov     ecx, [BOOMERANG_DEVICES]
+        mov     ecx, [boomerang_devices]
         test    ecx, ecx
         jz      .nothing
-        mov     esi, BOOMERANG_LIST
+        mov     esi, boomerang_list
   .nextdevice:
         mov     ebx, [esi]
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_INT_STATUS
+        set_io  [ebx + device.io_addr], REG_INT_STATUS
         in      ax, dx
-        test    ax, ax
+        test    ax, S_5_INTS
         jnz     .got_it
         ret
   .got_it:
-        DEBUGF  1,"Device: %x Status: %x ", ebx, ax
+        DEBUGF  1,"Device: %x Status: %x\n", ebx, ax
         push    ax
 ; disable all INTS
   .receive:
         DEBUGF  1,"UpComplete\n"
 ; check if packet is uploaded
-        mov     esi, [device.curr_upd]
+        mov     esi, [ebx + device.curr_rx]
-        test    byte [esi+upd.pkt_status+1], 0x80 ; upPktComplete
+        test    byte [esi+rx_desc.pkt_status+1], 0x80 ; upPktComplete
         jz      .finish
-        DEBUGF  1, "Current upd: %x\n", esi
+        DEBUGF  1, "Current RX desc: %x\n", esi
 ; packet is uploaded check for any error
   .check_error:
-        test    byte [esi+upd.pkt_status+1], 0x40 ; upError
+        test    byte [esi + rx_desc.pkt_status+1], 0x40 ; upError
         jz      .copy_packet_length
         DEBUGF  1,"Error in packet\n"
-        and     [esi+upd.pkt_status], 0           ; mark packet as read
+        and     [esi + rx_desc.pkt_status], 0           ; mark packet as read
         jmp     .finish
   .copy_packet_length:
-        mov     ecx, [esi+upd.pkt_status]
+        mov     ecx, [esi + rx_desc.pkt_status]
         and     ecx, 0x1fff
 ;        cmp     ecx, MAX_ETH_PKT_SIZE
 ;        jbe     .copy_packet
-;        and     [esi+upd.pkt_status], 0
+;        and     [esi+rx_desc.pkt_status], 0
 ;        jmp     .finish
 ;  .copy_packet:
-        DEBUGF  1, "Received %u bytes in buffer %x\n", ecx, [esi+upd.realaddr]:8
+        DEBUGF  1, "Received %u bytes in buffer %x\n", ecx, [esi + rx_desc.realaddr]:8
         push    dword .loop ;.finish
         push    ecx
-        push    [esi+upd.realaddr]
+        push    [esi + rx_desc.realaddr]
 ; update statistics
-        inc     [device.packets_rx]
+        inc     [ebx + device.packets_rx]
-        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
-; update UPD (Alloc new buffer for next packet)
+; update rx descriptor (Alloc new buffer for next packet)
-        stdcall KernelAlloc, MAX_ETH_FRAME_SIZE
+        invoke  KernelAlloc, MAX_ETH_FRAME_SIZE
-        mov     [esi + upd.realaddr], eax
+        mov     [esi + rx_desc.realaddr], eax
-        GetRealAddr
+        invoke  GetPhysAddr
-        mov     [esi + upd.frag_addr], eax
+        mov     [esi + rx_desc.frag_addr], eax
-        and     [esi + upd.pkt_status], 0
+        and     [esi + rx_desc.pkt_status], 0
-        mov     [esi + upd.frag_len], MAX_ETH_FRAME_SIZE or (1 shl 31)
+        mov     [esi + rx_desc.frag_len], MAX_ETH_FRAME_SIZE or (1 shl 31)
-; Update UPD pointer
+; Update rx descriptor pointer
-        add     esi, upd.size
+        add     esi, sizeof.rx_desc
-        lea     ecx, [device.upd_buffer+(NUM_RX_DESC)*upd.size]
+        lea     ecx, [ebx + device.rx_desc_buffer+(NUM_RX_DESC)*sizeof.rx_desc]
         cmp     esi, ecx
         jb      @f
-        lea     esi, [device.upd_buffer]
+        lea     esi, [ebx + device.rx_desc_buffer]
        @@:
-        mov     [device.curr_upd], esi
+        mov     [ebx + device.curr_rx], esi
-        DEBUGF  1, "Next upd: %x\n", esi
+        DEBUGF  1, "Next RX desc: %x\n", esi
-        jmp     Eth_input
+        jmp     [Eth_input]
   .loop:
         mov     ebx, [esp]
         jmp     .receive
   .finish:
         pop     ebx
 ; check if the NIC is in the upStall state
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
         test    word[esp], DownComplete
         jz      .noTX
         DEBUGF  1, "Downcomplete!\n"
         mov     ecx, NUM_TX_DESC
-        lea     esi, [device.dpd_buffer]
+        lea     esi, [ebx + device.tx_desc_buffer]
   .txloop:
-        test    [esi+dpd.frame_start_hdr], 1 shl 31
+        test    [esi+tx_desc.frame_start_hdr], 1 shl 31
         jz      .maybenext
-        and     [esi+dpd.frame_start_hdr], 0
+        and     [esi+tx_desc.frame_start_hdr], 0
         push    ecx
-        stdcall KernelFree, [esi+dpd.realaddr]
+        invoke  KernelFree, [esi+tx_desc.realaddr]
         pop     ecx
   .maybenext:
-        add     esi, dpd.size
+        add     esi, sizeof.tx_desc
         dec     ecx
         jnz     .txloop
 .noTX:
         pop     ax
-        set_io  0
+        set_io  [ebx + device.io_addr], 0
-        set_io  REG_COMMAND
+        set_io  [ebx + device.io_addr], REG_COMMAND
         or      ax, AckIntr
         out     dx, ax
-        set_io  REG_INT_STATUS
+        set_io  [ebx + device.io_addr], REG_INT_STATUS
         in      ax, dx
         test    ax, S_5_INTS
+; End of code
+data fixups
+end data
 include '../peimport.inc'
 ; End of code
-align 4                                         ; Place all initialised data here
+my_service           db '3C59X',0                    ; max 16 chars include zero
         dd label
 forward
         label db string, 0
+}
-VORTEX_DEVICES       dd 0
-BOOMERANG_DEVICES    dd 0
-version              dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
-my_service           db '3C59X',0                    ; max 16 chars include zero
 strtbl link_str, \
         "No valid link type detected", \
         "10BASE-T half duplex", \
         "10BASE-T full-duplex", \
 dw 0x9210, IS_TORNADO or HAS_NWAY or HAS_HWCKSM                                                                                 ; 3c920B-EMB-WNM Tornado
 HW_VERSIONS_SIZE = $ - hw_versions
+include_debug_strings                           ; All data wich FDO uses will be included here
-include_debug_strings                           ; All data wich FDO uses will be included here
+align 4
-section '.data' data readable writable align 16 ; place all uninitialized data place here
+vortex_devices          dd 0
+boomerang_devices       dd 0

Subversion Repositories Kolibri OS

(root)/drivers/ethernet/3c59x.asm – Rev 4470 → 5073