add     edx, 4
    add     ecx, 4
    mov     ax, [edx]
    mov     [ecx],ax

    ; and also the remote IP address
    add     edx, 2
    mov     eax,[edx]
    mov     [remote_ip_add], eax

    ; Now, add an entry in the table for this IP address if it doesn't exist

    push    eax
    movzx   eax, byte [NumARP]
    mov     ecx, ARP_ENTRY_SIZE
    mul     ecx
    pop     edx
    movzx   ecx, byte [NumARP]
    cmp     ecx, 0
    je      arph_002

arph_001:
    sub     eax, ARP_ENTRY_SIZE
    cmp     [eax + ARPTable], edx
    loopnz  arph_001                      ; Return back if non match

    jnz     arph_002                   ; None found, add to end

    mov     ecx, [remote_hw_add]
    mov     [eax + ARPTable + 4], ecx
    mov     cx, [remote_hw_add+4]
    mov     [eax + ARPTable + 8], cx

    ; specify the type - a valid entry
    mov     cl, 0x00
    mov     [eax + ARPTable + 10], cl
    mov     cl, 0x01
    mov     [eax + ARPTable + 11], cl

    ; Initialise the time to live field - 1 hour
    mov     cx, 0x0E10
    mov     [eax + ARPTable + 12], cx
    jmp     arph_exit

arph_002:

    cmp     byte [NumARP], ARP_TABLE_SIZE
    je      arph_exit

    inc     byte [NumARP]

    movzx   eax, byte [NumARP]
    mov     ecx, ARP_ENTRY_SIZE
    mul     ecx
    sub     eax, ARP_ENTRY_SIZE

    mov     ecx, [remote_ip_add]
    mov     [eax + ARPTable], ecx
    mov     ecx, [remote_hw_add]
    mov     [eax + ARPTable + 4], ecx
    mov     cx, [remote_hw_add+4]
    mov     [eax + ARPTable + 8], cx

    mov     cl, 0x00
    mov     [eax + ARPTable + 10], cl
    mov     cl, 0x01
    mov     [eax + ARPTable + 11], cl

    ; Initialise the time to live field - 1 hour
    mov     cx, 0x0E10
    mov     [eax + ARPTable + 12], cx

arph_exit:
    ret

; pointer to MAC in esi
refreshARP:
    mov     ebx, [esi]
    mov     dx, [esi+4]
    push    edx
    movzx   eax, byte [NumARP]
    mov     ecx, ARP_ENTRY_SIZE
    mul     ecx
    pop     edx
    movzx   ecx, byte [NumARP]
    cmp     ecx, 0
    je      rf_exit

rf_001:
    sub     eax, ARP_ENTRY_SIZE
    cmp     [eax + ARPTable+4], ebx

    je      rf_002
    loop    rf_001
    jmp     rf_exit

rf_002:
    cmp     [eax + ARPTable+8], dx
    je      rf_gotone
    loop    rf_001
    jmp     rf_exit

rf_gotone:
    ; Initialise the time to live field - 1 hour
    mov     cx, 0x0E10
    mov     [eax + ARPTable + 12], cx

rf_exit:
    ret

;***************************************************************************
;   Function
;      getMACfromIP
;
;   Description
;       Takes an IP address in edx and scans the ARP table for
;        a matching entry
;       If a match is found, it's MAC address is stored in MACAddress.
;      Otherwise the value 0 is writen to MACAddress
;      eax holds ARP table entry status code ( ARP_ )
;      ebx unchanged
;
;***************************************************************************
getMACfromIP:
    ; first, check destination IP to see if it is on 'this' network.
    ; The test is:
    ; if ( destIP & subnet_mask == stack_ip & subnet_mask )
    ;   desitnation is local
    ; else
    ;  destination is remote, so pass to gateway

    mov     eax, edx
    and     eax, [subnet_mask]
    mov     ecx, [stack_ip]
    and     ecx, [subnet_mask]
    cmp     eax, ecx
    je      gm0

    mov     edx, [gateway_ip]
gm0:
    push    edx
    xor     eax, eax
    mov     [MACAddress], eax
    mov     [MACAddress + 4], ax

    movzx   eax, byte [NumARP]
    mov     ecx, ARP_ENTRY_SIZE
    mul     ecx

    pop     edx

    movzx   ecx, byte [NumARP]
    cmp     ecx, 0
    je      gm_none
gm1:
    sub     eax, ARP_ENTRY_SIZE
    cmp     [eax + ARPTable], edx
    loopnz  gm1                      ; Return back if non match
    jnz     gm_none                   ; Quit if none found

    ; eax holds index
    mov     ecx, [eax + ARPTable + 4]
    mov     [MACAddress], ecx
    mov     cx, [eax + ARPTable + 8]
    mov     [MACAddress+4], cx

    ; Return the entry status in eax
    mov     ch, [eax + ARPTable + 10]
    mov     cl, [eax + ARPTable + 11]
    movzx   eax, cx
    jmp     gm_exit

gm_none:
    mov     eax, ARP_NO_ENTRY

gm_exit:
    ret

;***************************************************************************
;
;  PCI CODE FOLLOWS
;
;  the following functions provide access to the PCI interface.
;  These functions are used by scan_bus, and also some ethernet drivers
;
;***************************************************************************

;***************************************************************************
;   Function
;      config_cmd
;
;   Description
;       creates a command dword  for use with the PCI bus
;       bus # in ebx
;      devfn in ecx
;       where in edx
;
;      command dword returned in eax
;       Only eax destroyed
;***************************************************************************
config_cmd:
    push    ecx
    mov     eax, ebx
    shl     eax, 16
    or      eax, 0x80000000
    shl     ecx, 8
    or      eax, ecx
    pop     ecx
    or      eax, edx
    and     eax, 0xFFFFFFFC
    ret

;***************************************************************************
;   Function
;      pcibios_read_config_byte
;
;   Description
;       reads a byte from the PCI config space
;       bus # in ebx
;      devfn in ecx
;       where in edx ( ls 16 bits significant )
;
;      byte returned in al ( rest of eax zero )
;       Only eax/edx destroyed
;***************************************************************************
pcibios_read_config_byte:
    call    config_cmd
    push    dx
    mov     dx, 0xCF8
    out     dx, eax
    pop     dx

    xor     eax, eax
    and     dx, 0x03
    add     dx, 0xCFC
;   and     dx, 0xFFC
    in      al, dx
    ret

;***************************************************************************
;   Function
;      pcibios_read_config_word
;
;   Description
;       reads a word from the PCI config space
;       bus # in ebx
;      devfn in ecx
;       where in edx ( ls 16 bits significant )
;
;      word returned in ax ( rest of eax zero )
;       Only eax/edx destroyed
;***************************************************************************
pcibios_read_config_word:
    call    config_cmd
    push    dx
    mov     dx, 0xCF8
    out     dx, eax
    pop     dx

    xor     eax, eax
    and     dx, 0x02
    add     dx, 0xCFC
;   and     dx, 0xFFC
    in      ax, dx
    ret

;***************************************************************************
;   Function
;      pcibios_read_config_dword
;
;   Description
;       reads a dword from the PCI config space
;       bus # in ebx
;      devfn in ecx
;       where in edx ( ls 16 bits significant )
;
;      dword returned in eax
;       Only eax/edx destroyed
;***************************************************************************
pcibios_read_config_dword:
    push    edx
    call    config_cmd
    push    dx
    mov     dx, 0xCF8
    out     dx, eax
    pop     dx
    xor     eax, eax
    mov     dx, 0xCFC
    in      eax, dx
    pop     edx
    ret

;***************************************************************************
;   Function
;      pcibios_write_config_byte
;
;   Description
;       write a byte in al to the PCI config space
;       bus # in ebx
;      devfn in ecx
;       where in edx ( ls 16 bits significant )
;
;       Only eax/edx destroyed
;***************************************************************************
pcibios_write_config_byte:
    push    ax
    call    config_cmd
    push    dx
    mov     dx, 0xCF8
    out     dx, eax
    pop     dx
    pop     ax

    and     dx, 0x03
    add     dx, 0xCFC
    out     dx, al
    ret

;***************************************************************************
;   Function
;      pcibios_write_config_word
;
;   Description
;       write a word in ax to the PCI config space
;       bus # in ebx
;      devfn in ecx
;       where in edx ( ls 16 bits significant )
;
;       Only eax/edx destroyed
;***************************************************************************
pcibios_write_config_word:
    push    ax
    call    config_cmd
    push    dx
    mov     dx, 0xCF8
    out     dx, eax
    pop     dx
    pop     ax

    and     dx, 0x02
    add     dx, 0xCFC
    out     dx, ax
    ret

;***************************************************************************
;   Function
;      delay_us
;
;   Description
;       delays for 30 to 60 us
;
;        I would prefer this routine to be able to delay for
;       a selectable number of microseconds, but this works for now.
;
;       If you know a better way to do 2us delay, pleae tell me!
;***************************************************************************
delay_us:
    push    eax
    push    ecx

    mov     ecx,2

    in      al,0x61
    and     al,0x10
    mov     ah,al
    cld

dcnt1:
    in      al,0x61
    and     al,0x10
    cmp     al,ah
    jz      dcnt1

    mov     ah,al
    loop    dcnt1

    pop     ecx
    pop     eax

    ret

;***************************************************************************
;   Function
;      scan_bus
;
;   Description
;       Scans the PCI bus for a supported device
;        If a supported device is found, the drvr_ variables are initialised
;       to that drivers functions ( as defined in the PCICards table)
;
;        io_addr   holds card I/O space. 32 bit, but only LS 16 bits valid
;        pci_data  holds the PCI vendor + device code
;       pci_dev   holds PCI bus dev #
;       pci_bus   holds PCI bus #
;
;        io_addr will be zero if no card found
;
;***************************************************************************
scan_bus:
    xor     eax, eax
    mov     [hdrtype], al
    mov     [pci_data], eax

    xor     ebx, ebx         ; ebx = bus# 0 .. 255

sb_bus_loop:
    xor     ecx, ecx         ; ecx = devfn# 0 .. 254  ( not 255? )

sb_devf_loop:
    mov     eax, ecx
    and     eax, 0x07

    cmp     eax, 0
    jne     sb_001

    mov     edx, PCI_HEADER_TYPE
    call    pcibios_read_config_byte