WebSVN – Kolibri OS – Diff – /kernel/trunk/network/eth_drv/ethernet.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;;  ETHERNET.INC                                                   ;;
;;                                                                 ;;
;;  Ethernet network layer for Menuet OS                           ;;
;;                                                                 ;;
;;  Version 0.4  22 September 2003                                 ;;
;;                                                                 ;;
;;  This file contains the following:                              ;;
;;      PCI bus scanning for valid devices                         ;;
;;      Table of supported ethernet drivers                        ;;
;;      Code to identify and activate a supported driver           ;;
;;      ARP handler                                                ;;
;;      Driver interface to the IP layer                           ;;
;;      Gateway support                                            ;;
;;                                                                 ;;
;;  Individual driver files are included here                      ;;
;;                                                                 ;;
;;  The PCI bus scanning code was ported from the etherboot        ;;
;;  5.0.6 project. The copyright statement for that code is        ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;;  remaining parts Copyright 2002 Mike Hibbett                    ;;
;;   mikeh@oceanfree.net                                           ;;
;;                                                                 ;;
;;  See file COPYING for details                                   ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
;********************************************************************
;   Interface
;      ethernet_driver   called by stack_handler in stack.inc
;      eth_probe         called by app_stack_handler in stack.inc
;
;********************************************************************
 
; Some useful information on data structures
 
;     Ethernet Packet - ARP Request example
;
;   0                   1                   2                   3
;   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
;
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   |       Dest   H/W Address                                      |
;   |                    ( 14 byte header )                         |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   |                               |     Source     H/W Address    |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   |                                                               |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   |    Protocol - ARP 08  06      |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   |  H/W Type  00           01    |  Protocol Type   08 00        |
;   |                   ( ARP Request packet )                      |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   | HLen    0x06  | PLen    0x04  |    OpCode        00   01      |
;   |               ( 0001 for request, 0002 for reply )            |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   | Source Hardware Address ( MAC Address )                       |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   |                               |  Source IP Address            |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   |                               | Destination Hardware Address  |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   |                                                               |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
;   | Destination IP Address                                        |
;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
; Include individual drivers source files at this point.
; If you create a new driver, include it below.
 
include "rtl8029.inc"
include "i8255x.inc"
include "rtl8139.inc"
include "3c59x.inc"
include "sis900.inc"
include "pcnet32.inc"
 
; DEBUGGING_STATE enables or disables output of received and transmitted
; data over the serial port
DEBUGGING_ENABLED           equ     1
DEBUGGING_DISABLED          equ     0
DEBUGGING_STATE             equ     DEBUGGING_DISABLED
 
; PCICards
; ========
; PCI vendor and hardware types for hardware supported by the above drivers
; If you add a driver, ensure you update this datastructure, otherwise the
; card will not be probed.
; Each driver is defined by 4 double words. These are
;   PCIVendorDevice  probeFunction ResetFunction PollFunction transmitFunction
; The last entry must be kept at all zeros, to indicate the end of the list
; As a PCI driver may support more than one hardware implementation, there may
; be several lines which refer to the same functions.
; The first driver found on the PCI bus will be the one used.
 
PCICARDS_ENTRY_SIZE         equ     20    ; Size of each PCICARDS entry
 
iglobal
PCICards:
dd  0x12098086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit
dd  0x10298086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit
dd  0x12298086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit
dd  0x10308086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit
dd  0x24498086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit
dd  0x802910ec, rtl8029_probe, rtl8029_reset, rtl8029_poll, rtl8029_transmit
dd  0x12111113, rtl8029_probe, rtl8029_reset, rtl8029_poll, rtl8029_transmit
dd  0x813910ec, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
; /+/ Íîâûå âåíäîðû ñåòåâûõ êàðò íà áàçå rtl8139
dd  0x813810ec, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x12111113, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x13601500, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x13604033, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x13001186, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x13401186, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0xab0613d1, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0xa1171259, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0xa11e1259, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0xab0614ea, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0xab0714ea, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x123411db, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x91301432, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x101202ac, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x0106018a, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x1211126c, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x81391743, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
dd  0x8139021b, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
; /-/
dd  0x590010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x592010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x597010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x595010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x595110b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x595210b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x900010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x900110b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x900410b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x900510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x900610b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x900A10b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x905010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x905110b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x905510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x905810b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x905A10b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x920010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x980010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x980510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x764610b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x505510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x605510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x605610b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x5b5710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x505710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x515710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x525710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x656010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x656210b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x656410b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x450010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
dd  0x09001039, SIS900_probe, SIS900_reset, SIS900_poll, SIS900_transmit
dd  0x20001022, pcnet32_probe, pcnet32_reset, pcnet32_poll, pcnet32_xmit
dd  0x26251022, pcnet32_probe, pcnet32_reset, pcnet32_poll, pcnet32_xmit
dd  0x20011022, pcnet32_probe, pcnet32_reset, pcnet32_poll, pcnet32_xmit
; following card is untested
dd  0x70161039, SIS900_probe, SIS900_reset, SIS900_poll, SIS900_transmit
dd  0,0,0,0,0  ; end of list marker, do not remove
endg
 
; PCI Bus defines
PCI_HEADER_TYPE             equ     0x0e  ;8 bit
PCI_BASE_ADDRESS_0          equ     0x10  ;32 bit
PCI_BASE_ADDRESS_5          equ     0x24  ;32 bits
PCI_BASE_ADDRESS_SPACE_IO   equ     0x01
PCI_VENDOR_ID               equ     0x00  ;16 bit
PCI_BASE_ADDRESS_IO_MASK    equ     0xFFFFFFFC
 
ETHER_IP                    equ     0x0008      ; Reversed from 0800 for intel
ETHER_ARP                   equ     0x0608      ; Reversed from 0806 for intel
ETHER_RARP                  equ     0x3580
ARP_REQ_OPCODE              equ     0x0100
ARP_REP_OPCODE              equ     0x0200
 
uglobal
  arp_rx_count:       dd  0
  ip_rx_count:        dd  0
  dumped_rx_count:    dd  0
  ip_tx_count:        dd  0
  node_addr:          db  0,0,0,0,0,0
  eth_rx_data_len:    dw  0
  eth_status:         dd  0
  io_addr:            dd  0
  hdrtype:            db  0
  vendor_device:      dd  0
  pci_data:           dd  0
  pci_dev:            dd  0
  pci_bus:            dd  0
 
  ; These will hold pointers to the selected driver functions
  drvr_probe:         dd  0
  drvr_reset:         dd  0
  drvr_poll:          dd  0
  drvr_transmit:      dd  0
 
  ; These hold the destination Host identity for ARP responses
  remote_ip_add:      dd  0
  remote_hw_add:      db  0, 0, 0, 0, 0, 0
endg
 
iglobal
  broadcast_add:      db  0xff,0xff,0xff,0xff,0xff,0xff
  subnet_mask:        dd  0x00ffffff
endg
 
uglobal
  ; This is used by getMACfromIP
  MACAddress:         db  0,0,0,0,0,0
  gateway_ip:         db  0, 0, 0, 0
  dns_ip:             dd  0
endg
 
; The follow is the ARP Table.
; This table must be manually updated and the kernel recompilied if
; changes are made to it.
; ARP_TABLE_SIZE defines the size of the table
; ARP_TABLE_ENTRIES defines the number of entries in the table
; Each entry is 10 bytes: 4 Byte IP address, 6 byte MAC Address,
;                         2 bytes status, 2 bytes TTL ( in seconds )
; Empty entries are filled with zeros
; The TTL field is decremented every second, and is deleted when it
; reaches 0. It is refreshed every time a packet is received
; If the TTL field is 0xFFFF it is a permanent entry and is never deleted
; The status field can be the following values
; 0x0000  entry not used
; 0x0001  entry holds a valid mapping
; 0x0002  entry contains an IP address, awaiting ARP response
; 0x0003  No response received to ARP request.
; The last status value is provided to allow the network layer to delete
; a packet that is queued awaiting an ARP response
 
ARP_NO_ENTRY                equ 0
ARP_VALID_MAPPING           equ 1
ARP_AWAITING_RESPONSE       equ 2
ARP_RESPONSE_TIMEOUT        equ 3
 
ARP_ENTRY_SIZE              equ     14          ; Number of bytes per entry
ARP_TABLE_SIZE              equ     20          ; Size of table
ARP_TABLE_ENTRIES           equ     0           ; Inital, hardcoded entries
 
uglobal
  ARPTable:
  times ( ARP_TABLE_SIZE - ARP_TABLE_ENTRIES ) * ARP_ENTRY_SIZE  db 0
endg
 
iglobal
  NumARP:        db    ARP_TABLE_ENTRIES
endg
 
;***************************************************************************
;   Function
;      eth_probe
;   Description
;      Searches for an ethernet card. If found, the card is enabled and
;      the ethernet -> IP link established
;
;      This function scans the PCI bus looking for a supported device.
;      ISA bus is currently not supported.
;
;        eax is 0 if no hardware found
;***************************************************************************
eth_probe:
    ; Find a card on the PCI bus, and get it's address
    call    scan_bus                    ; Find the ethernet cards PIC address
    xor     eax, eax
    cmp     [io_addr], eax
    je      ep_00x                      ; Return 0 in eax if no cards found
 
    call    dword [drvr_probe]          ; Call the drivers probe function
 
    mov     eax, [io_addr]              ; return a non zero value
 
ep_00x:
    ret
 
;***************************************************************************
;   Function
;      ethernet_driver
;
;   Description
;       The ethernet RX and TX handler
;       This is a kernel function, called by stack_handler
;
;***************************************************************************
ethernet_driver:
    ; Do nothing if the driver is inactive
    cmp     [ethernet_active], byte 0
    je      eth_exit
 
    call    eth_rx
    call    eth_tx
 
eth_exit:
    ret
 
;***************************************************************************
;   Function
;      eth_rx
;
;   Description
;      Polls the ethernet card for received data. Extracts if present
;       Depending on the Protocol within the packet:
;         ARP : Pass to ARP_handler. This may result in an ARP reply
;               being tx'ed
;         IP  : Store in an IP buffer
;
;***************************************************************************
eth_rx:
    xor     ax, ax
    mov     [eth_rx_data_len], ax
    call    dword [drvr_poll]       ; Call the drivers poll function
 
    mov     ax, [eth_rx_data_len]
    cmp     ax, 0
    je      erx_exit
 
if DEBUGGING_STATE = DEBUGGING_ENABLED
    pusha
    mov     eax, 0                    ;Indicate that this is a received packet
    mov     cx, [eth_rx_data_len]
    mov     esi, Ether_buffer
    cmp     word [esi + 12], ETHER_IP
    jnz     erxd_done
;    cmp     byte [esi + 14 + 9], 0x06  ; TCP
;    jnz     erxd_done
    call    eth_dump
erxd_done:
    popa
end if
 
    ; Check the protocol. Call appropriate handler
    mov     eax, Ether_buffer
    add     eax, 12                  ; The address of the protocol word
 
    mov     ax, [eax]
 
    cmp     ax, ETHER_ARP
    je      erx_001                  ; It is ARP
 
    cmp     ax, ETHER_IP
    je      erx_002                  ; It's IP
 
;    inc     dword [dumped_rx_count]
 
    jmp     erx_exit               ; If not IP or ARP, ignore
 
erx_001:
    mov     eax, [arp_rx_count]
    inc     eax
    mov     [arp_rx_count], eax
 
    ; At this point, the packet is still in the Ether_buffer
    call    arp_handler
 
    jmp     erx_exit
 
erx_002:
    mov     eax, [ip_rx_count]
    inc     eax
    mov     [ip_rx_count], eax
 
    ; Check to see if the MAC address is in our arp table
    ; refresh the arp ttl if so
 
    mov     esi, Ether_buffer
    add     esi, 6
 
    call    refreshARP
 
    call    ether_IP_handler
 
    jmp     erx_exit
 
erx_exit:
    ret
 
;***************************************************************************
;   Function
;      eth_tx
;
;   Description
;      Looks at the NET1OUT_QUEUE for data to send.
;      Stores that destination IP in a location used by the tx routine
;      Looks up the MAC address in the ARP table; stores that where
;      the tx routine can get it
;      Get the length of the data. Store that where the tx routine wants it
;      Call tx
;      Places buffer on empty queue when the tx routine finished
;
;***************************************************************************
eth_tx:
    ; Look for a buffer to tx
    mov     eax, NET1OUT_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
    je      eth_exit            ; Exit if no buffer available
 
    push    eax
 
    ; convert buffer pointer eax to the absolute address
    mov     ecx, IPBUFFSIZE
    mul     ecx
    add     eax, IPbuffs
 
    ; Extract the destination IP
    ; find the destination IP in the ARP table, get MAC
    ; store this MAC in 'MACAddress'
    mov     ebx, eax               ; Save buffer address
    mov     edx, [ebx + 16]        ; get destination address
 
    ; If the destination address is 255.255.255.255,
    ; set the MACAddress to all ones ( broadcast )
    mov     [MACAddress], dword 0xffffffff
    mov     [MACAddress + 4], word 0xffff
    cmp     edx, 0xffffffff
    je      etx_send                ; If it is broadcast, just send
 
    call    getMACfromIP           ; Get the MAC address.
 
    cmp     eax, ARP_VALID_MAPPING
    jz      etx_send
 
    ; No valid entry. Are we waiting for a response?
    cmp     eax, ARP_AWAITING_RESPONSE
    jne     etx_001
 
    ; Re-queue the packet, and exit
    pop     ebx
    mov     eax, NET1OUT_QUEUE
    call    queue
    jmp     etx_exit
 
etx_001:
    ; HAs the request been sent, but timed out?
    cmp     eax, ARP_RESPONSE_TIMEOUT
    jne     etx_002
 
    pop     eax
    call    freeBuff
    jmp     etx_exit
 
etx_002:
    ; There is no entry. Re queue the request, and ask ARP to send a request
 
    ; IP address is in edx
    push    edx
    call    arp_request
    pop     ebx
 
    ; Add an entry in the ARP table, awaiting response
 
    cmp     byte [NumARP], ARP_TABLE_SIZE
    je      etx_003            ; We cannot add a new entry in the table
 
    inc     byte [NumARP]
 
    movzx   eax, byte [NumARP]
    mov     ecx, ARP_ENTRY_SIZE
    mul     ecx
    sub     eax, ARP_ENTRY_SIZE
 
    mov     [eax + ARPTable], ebx
    xor     ebx, ebx
    mov     [eax + ARPTable + 4], ebx
    mov     [eax + ARPTable + 8], bx
 
    ; set the status field up - awaiting response
    mov     cl, 0x00
    mov     [eax + ARPTable + 10], cl
    mov     cl, 0x02
    mov     [eax + ARPTable + 11], cl
 
    ; Initialise the time to live field - 10s
    mov     cx, 0x000A
    mov     [eax + ARPTable + 12], cx
 
etx_003:
    pop     ebx                        ; Get the buffer back
    mov     eax, NET1OUT_QUEUE
    call    queue
    jmp     etx_exit
 
etx_send:
    xor     ecx, ecx
    mov     ch, [ebx+2]
    mov     cl, [ebx+3]          ; ; Size of IP packet to send
 
    mov     esi, ebx
 
    mov     edi, MACAddress
 
if DEBUGGING_STATE = DEBUGGING_ENABLED
    pusha
    mov     cx, 42
    mov     eax, 1                    ; Indicate that this is a tx packet
    call    eth_dump
    popa
end if
 
    mov     bx, ETHER_IP
    call    dword [drvr_transmit]       ; Call the drivers transmit function
 
    ; OK, we have sent a packet, so increment the count
    inc     dword [ip_tx_count]
 
    ; And finally, return the buffer to the free queue
    pop     eax
    call    freeBuff
 
etx_exit:
    ret
 
;***************************************************************************
;   Function
;      ether_IP_handler
;
;   Description
;      Called when an IP ethernet packet is received on the ethernet
;      Header + Data is in Ether_buffer[]
;      We just need to get a buffer from the 'free' queue, and
;      store the packet in it, then insert the packet number into the
;      IPRX queue.
;      If no queue entry is available, the packet is silently discarded
;      All registers may be destroyed
;
;***************************************************************************
ether_IP_handler:
    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
    je      eiph00x
 
    ; convert buffer pointer eax to the absolute address
    push    eax
    mov     ecx, IPBUFFSIZE
    mul     ecx
    add     eax, IPbuffs
 
    mov     edi, eax
 
    ; get a pointer to the start of the DATA
    mov     esi, Ether_buffer + 14
 
    ; Now store it all away
    mov     ecx, IPBUFFSIZE / 4     ; Copy all of the available
                              ; data across - worse case
    cld
    rep     movsd
 
    ; And finally, place the buffer in the IPRX queue
    pop     ebx
    mov     eax, IPIN_QUEUE
    call    queue
 
eiph00x:
    ret
 
;***************************************************************************
;
;  ARP CODE FOLLOWS
;
;  The ARP code is used by ethernet drivers to translate an destination
;  IP address into an ethernet hardware address. Functions to broadcast
;  requests and handle response are (or will be) here.
;  The IP layer has no knowledge of ARP, as this is a network interface
;  issue
;
;***************************************************************************
 
;***************************************************************************
;   Function
;      arp_timer
;
;   Description
;      Called every 1s
;      It is responsible for removing expired routes
;      All registers may be destroyed
;
;***************************************************************************
arp_timer:
    ; loop through all the ARP entries, decrementing each one
    ; that doesn't have a TTL of 0xFFFF
    movzx   eax, byte [NumARP]
 
arp_001:
    cmp     eax, 0
    je      arp_003
 
    push    eax
    dec     eax
    mov     ecx, ARP_ENTRY_SIZE
    mul     ecx
    cmp     word [ eax + ARPTable + 12], 0xFFFF
    je      arp_002
 
    cmp     word [ eax + ARPTable + 12], 0
    je      arp_002
 
    dec     word [eax + ARPTable + 12]
 
arp_002:
    pop     eax
    dec     eax
    jmp     arp_001
 
    ; Now, look for entries with a TTL of 0
    ; Valid entries and response timeout entries get removed
    ; awaiting response gets converted into a response timeout, with a
    ; short life time - this allows queued packets to be flushed
arp_003:
    movzx   edx, byte [NumARP]
    cmp     edx, 0
    je      arp_exit
 
    ; EDX holds the # of entries to search through
    mov     eax, 0
 
arp_005:
    cmp     word [ eax + ARPTable + 12], 0
    jne     arp_004
 
    ; If it's status code is 0001 or 0003, delete the entry
    cmp     word [eax + ARPTable + 10], 0x0100
    je      arp_007
    cmp     word [eax + ARPTable + 10], 0x0300
    je      arp_007
 
    ; The only other valid code is 0002 - indicating a
    ; timeout while waiting for a response. Change the
    ; entry to response timed out
 
    mov     [eax + ARPTable + 10], word 0x0300
    mov     [eax + ARPTable + 12], word 0x000A
    jmp     arp_004
 
arp_007:
    ; Delete this entry
    mov     edi, ARPTable
    add     edi, eax
    mov     esi, edi
    add     esi, ARP_ENTRY_SIZE
 
    mov     ecx, (ARP_TABLE_SIZE - 1) * ARP_ENTRY_SIZE
    sub     ecx, eax
 
    rep     movsb
 
    dec     byte [NumARP]
    jmp     arp_006
 
arp_004:
    add     eax, ARP_ENTRY_SIZE
arp_006:
    dec     edx
    cmp     edx, 0
    jne     arp_005
 
arp_exit:
    ret
 
;***************************************************************************
;   Function
;      arp_request
;
;   Description
;      Sends an ARP request on the ethernet
;        The requested IP address is in edx
;      All registers may be destroyed
;
;***************************************************************************
arp_request:
    mov     ebx, Ether_buffer
    mov     ax, 0x0100
    mov     [ebx], ax
    add     ebx, 2
 
    mov     ax, 0x0008
    mov     [ebx], ax
    add     ebx, 2
 
    mov     ax, 0x0406
    mov     [ebx], ax
    add     ebx, 2
 
    mov     ax, 0x0100
    mov     [ebx], ax
    add     ebx, 2
 
    mov     ecx, node_addr
    mov     eax, [ecx]
    mov     [ebx], eax
    add     ecx, 4
    add     ebx, 4
    mov     ax, [ecx]
    mov     [ebx], ax
    add     ebx, 2
    mov     eax, [stack_ip]
    mov     [ebx], eax
    add     ebx, 4
 
    xor     eax, eax
    mov     [ebx], eax
    add     ebx, 4
    mov     [ebx], ax
 
    add     ebx, 2
    mov     [ebx], edx
 
    ; Now, send it!
 
    ; Pointer to 48 bit destination address in edi
    ; Type of packet in bx
    ; size of packet in ecx
    ; pointer to packet data in esi
    mov      edi, broadcast_add
 
;if DEBUGGING_STATE = DEBUGGING_ENABLED
;    pusha
;    mov     eax, 1                    ; Indicate that this is a tx packet
;    mov     ecx, 28
;   mov      esi, Ether_buffer
;    call    eth_dump
;    popa
;end if
 
    mov     bx, ETHER_ARP
    mov     ecx, 28
    mov     esi, Ether_buffer
    call    dword [drvr_transmit]       ; Call the drivers transmit function
    ret
 
;***************************************************************************
;   Function
;      arp_handler
;
;   Description
;      Called when an ARP packet is received on the ethernet
;      Header + Data is in Ether_buffer[]
;       It looks to see if the packet is a request to resolve this Hosts
;       IP address. If it is, send the ARP reply packet.
;      This Hosts IP address is in dword [stack_ip]  ( in network format )
;       This Hosts MAC address is in node_addr[6]
;      All registers may be destroyed
;
;***************************************************************************
arp_handler:
    ; Is this a REQUEST?
    ; Is this a request for My Host IP
    ; Yes - So construct a response message.
    ; Send this message to the ethernet card for transmission
 
    mov     ebx, Ether_buffer
 
    mov     edx, ebx
    add     edx, 20
    mov     ax, [edx]
    cmp     ax, ARP_REQ_OPCODE      ; Is this a request packet?
    jne     arph_resp            ; No - so test for response
 
    mov     edx, ebx
    add     edx, 38
    mov     eax, [edx]
 
    cmp     eax, [stack_ip]         ; Is it looking for my IP address?
    jne     arph_exit            ; No - so quit now
 
    ; OK, it is a request for my MAC address. Build the frame and send it
 
    ; Save the important data from the original packet
    ; remote MAC address first
    mov     ecx, remote_hw_add
    mov     edx, ebx
    add     edx, 22               ; edx points to Source h/w address
    mov     eax, [edx]
    mov     [ecx], eax
    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
 
    ; So now we can reuse the packet. ebx still holds the address of
    ; the header + packet
    ; We dont need the header ( first 14 bytes )
 
    mov     edx, ebx
    add     edx, 20
    mov     ax, ARP_REP_OPCODE
    mov     [edx], ax
    add     edx, 2
 
    mov     ecx, node_addr
    mov     eax, [ecx]
    mov     [edx], eax
    add     ecx, 4
    add     edx, 4
    mov     ax, [ecx]
    mov     [edx], ax
    add     edx, 2
    mov     eax, [stack_ip]
    mov     [edx], eax
    add     edx, 4
    mov     ecx, remote_hw_add
    mov     eax, [ecx]
    mov     [edx], eax
    add     ecx, 4
    add     edx, 4
    mov     ax, [ecx]
    mov     [edx], ax
 
    add     edx, 2
    mov     eax, [remote_ip_add]
    mov     [edx], eax
 
    ; Now, send it!
 
    ; Pointer to 48 bit destination address in edi
    ; Type of packet in bx
    ; size of packet in ecx
    ; pointer to packet data in esi
    mov     edi, remote_hw_add
 
;if DEBUGGING_STATE = DEBUGGING_ENABLED
;    pusha
;    mov     eax, 1                    ; Indicate that this is a tx packet
;    mov     ecx, 28
;   mov      esi, Ether_buffer + 14
 ;   call    eth_dump
;    popa
;end if
 
    mov     bx, ETHER_ARP
    mov     ecx, 28
    mov     esi, Ether_buffer + 14
    call    dword [drvr_transmit]       ; Call the drivers transmit function
    jmp     arph_exit
 
arph_resp:
    cmp     ax, ARP_REP_OPCODE      ; Is this a replypacket?
    jne     arph_resp            ; No - so quit
 
    ; This was a reply, probably directed at me.
    ; save the remotes MAC & IP
    mov     ecx, remote_hw_add
    mov     edx, ebx
    add     edx, 22               ; edx points to Source h/w address
    mov     eax, [edx]
    mov     [ecx], eax
    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
    mov     [hdrtype], al
    jmp     sb_002
 
sb_001:
    mov     al, [hdrtype]
    and     al, 0x80
    cmp     al, 0x80
    jne     sb_inc_devf
 
sb_002:
    mov     edx, PCI_VENDOR_ID
    call    pcibios_read_config_dword
    mov     [vendor_device], eax
    cmp     eax, 0xffffffff
    je      sb_empty
    cmp     eax, 0
    jne     sb_check_vendor
 
sb_empty:
    mov     [hdrtype], byte 0
    jmp     sb_inc_devf
 
sb_check_vendor:
    ; iterate though PCICards until end or match found
    mov     esi, PCICards
 
sb_check:
    cmp     [esi], dword 0
    je      sb_inc_devf                ; Quit if at last entry
    cmp     eax, [esi]
    je      sb_got_card
    add     esi, PCICARDS_ENTRY_SIZE
    jmp     sb_check
 
sb_got_card:
    ; indicate that we have found the card
    mov     [pci_data], eax
    mov     [pci_dev], ecx
    mov     [pci_bus], ebx
 
    ; Define the driver functions
    push    eax
    mov     eax, [esi+4]
    mov     [drvr_probe], eax
    mov     eax, [esi+8]
    mov     [drvr_reset], eax
    mov     eax, [esi+12]
    mov     [drvr_poll], eax
    mov     eax, [esi+16]
    mov     [drvr_transmit], eax
    pop     eax
 
    mov     edx, PCI_BASE_ADDRESS_0
 
sb_reg_check:
    call    pcibios_read_config_dword
    mov     [io_addr], eax
    and     eax, PCI_BASE_ADDRESS_IO_MASK
    cmp     eax, 0
    je      sb_inc_reg
    mov     eax, [io_addr]
    and     eax, PCI_BASE_ADDRESS_SPACE_IO
    cmp     eax, 0
    je      sb_inc_reg
 
    mov     eax, [io_addr]
    and     eax, PCI_BASE_ADDRESS_IO_MASK
    mov     [io_addr], eax
 
sb_exit1:
    ret
 
sb_inc_reg:
    add     edx, 4
    cmp     edx, PCI_BASE_ADDRESS_5
    jbe     sb_reg_check
 
sb_inc_devf:
    inc     ecx
    cmp     ecx, 255
    jb      sb_devf_loop
    inc     ebx
    cmp     ebx, 256
    jb      sb_bus_loop
 
    ; We get here if we didn't find our card
    ; set io_addr to 0 as an indication
    xor     eax, eax
    mov     [io_addr], eax
 
sb_exit2:
    ret
 
;***************************************************************************
;
;  DEBUGGING CODE FOLLOWS
;
;  If debugging data output is not required, ALL code & data below may
;  be removed.
;
;***************************************************************************
 
if DEBUGGING_STATE = DEBUGGING_ENABLED
 
;***************************************************************************
;   Function
;      eth_dump
;
;   Description
;       Dumps a tx or rx ethernet packet over the rs232 link
;       This is a debugging routine that seriously slows down the stack.
;       Use with caution.
;
;       Baud rate is 57600, 8n1  com1
;         eax : type (0 == rx, 1 == tx )
;          cx : # of bytes in buffer
;         esi : address of buffer start
;         edi : pointer to MACAddress ( tx only )
;
;***************************************************************************
eth_dump:
    pusha
 
    ; Set the port to the desired speed
    mov     ebx, 0x3f8                     ; combase
 
    mov     edx, ebx
    add     edx, 3                        ; data format register
    mov     al, 0x80                    ; enable access to divisor latch
    out     dx, al
 
    mov     edx, ebx
    add     edx, 1                        ; interrupt enable register
    mov     al, 0x00                    ; No interruts enabled
    out     dx, al
 
    mov     edx, ebx
    mov     al, 0x20 / 16                ; set baud rate to 57600 0x10 =115200
    out     dx, al
 
    mov     edx, ebx
    add     edx, 3                        ; data format register
    mov     al, 0x03                    ; 8 data bits
    out     dx, al
 
    mov     edx, ebx
    add     edx, 4                        ; Modem control register
    mov     al, 0x08                    ; out2 enabled. No handshaking.
    out     dx, al
 
    mov     edx, ebx
    add     edx, 1                        ; interrupt enable register
    mov     al, 0x01                    ; Receive data interrupt enabled,
    out     dx, al
 
    popa
 
    ; First, display the type of the buffer.
    ; If it is a tx buffer, display the macaddress
 
    pusha
 
    cmp     eax, 0
    jne     dd001
 
    mov     bl, 0x0a
    call    tx_byted
    mov     bl, 0x0d
    call    tx_byted
 
    ; Output "RX:"
    mov     bl, 'R'
    call    tx_byted
    mov     bl, 'X'
    call    tx_byted
    mov     bl, ':'
    call    tx_byted
    jmp     dump_data
 
dd001:
    mov     bl, 0x0a
    call    tx_byted
    mov     bl, 0x0d
    call    tx_byted
 
    ; Output TX: xxxxxxxxxxxx
    mov     bl, 'T'
    call    tx_byted
    mov     bl, 'X'
    call    tx_byted
    mov     bl, ':'
    call    tx_byted
    mov     bl, ' '
    call    tx_byted
 
    ; Display MAC address
    xor     eax, eax
    mov     al, [edi]
    shr     al, 4
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    xor     eax, eax
    mov     al, [edi]
    and     al, 0x0f
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    inc     edi
    xor     eax, eax
    mov     al, [edi]
    shr     al, 4
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    xor     eax, eax
    mov     al, [edi]
    and     al, 0x0f
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    inc     edi
    xor     eax, eax
    mov     al, [edi]
    shr     al, 4
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    xor     eax, eax
    mov     al, [edi]
    and     al, 0x0f
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    inc     edi
    xor     eax, eax
    mov     al, [edi]
    shr     al, 4
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    xor     eax, eax
    mov     al, [edi]
    and     al, 0x0f
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    inc     edi
    xor     eax, eax
    mov     al, [edi]
    shr     al, 4
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    xor     eax, eax
    mov     al, [edi]
    and     al, 0x0f
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    inc     edi
    xor     eax, eax
    mov     al, [edi]
    shr     al, 4
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    xor     eax, eax
    mov     al, [edi]
    and     al, 0x0f
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
dump_data:
    popa
 
    ; OK, we come in here with
    ; cx == number of byte to send
    ; esi == buffer start
    ;
dd_000:
    mov     bl, 0x0a
    call    tx_byted
    mov     bl, 0x0d
    call    tx_byted
 
    mov     eax, 16        ; Number of characters on the line
    mov     edi, esi    ; Save first byte position for later
 
    push    ecx
 
dd_001:
    push    eax
 
    ; Print a byte, and a space
    xor     eax, eax
    mov     al, [esi]
    shr     al, 4
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    xor     eax, eax
    mov     al, [esi]
    and     al, 0x0f
    mov     bl, [eax + hexchars]
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    mov     bl, ' '
    call    tx_byted
 
    pop     eax
 
    inc     esi
    dec     ecx
    cmp     ecx, 0
    je      dd_0011            ; Print the ASCII format
 
    dec     eax
 
    cmp     eax, 0
    je      dd_002            ; Print the ASCII format
    jmp     dd_001            ; Print rest of line
 
dd_0011:
    ; First, complete the 16 bytes of data, by printing spaces
    dec     eax
    cmp     eax, 0
    je      dd_002
 
    push    eax
    mov     bl, ' '
    call    tx_byted
    mov     bl, ' '
    call    tx_byted
    mov     bl, ' '
    call    tx_byted
    pop     eax
    jmp     dd_0011
 
dd_002:
    pop     ecx
    mov     esi, edi        ; Go back to the start of the line data
 
    mov     eax, 16
 
outLineAscii:
    push    eax
 
    xor     eax, eax
    mov     al, [esi]
    mov     bl, '.'
 
    cmp     al, 0x1F
    jle     outAscii
    cmp     al, 0x7e
    jge     outAscii
 
    mov     bl, al
 
outAscii:
    call    tx_byted ; byte in bl eax ebx edx destroyed
 
    pop     eax
    dec     ecx
    inc     esi
    cmp     ecx, 0
    je      dd_003
 
    dec     eax
    cmp     eax, 0
    je      dd_003
    jmp     outLineAscii
 
dd_003:
    cmp     ecx, 0
    je      dd_004
    jmp     dd_000
 
dd_004:
    ret
 
;***************************************************************************
;   Function
;      tx_byte
;
;   Description
;       Send a byte in bl out of the com port 1
;       destroys eax, edx
;
;***************************************************************************
tx_byted:
    push    ebx                     ; Save the byte
 
    mov     ebx, 0x3f8            ; get the com port address
 
    ; Wait for transmit buffer to empty. This could take 1ms @ 9600baud
 
    mov     edx, ebx
    add     edx, 5
 
wait_txd:
    in      al, dx                   ; read uart serialisation status
    and     al, 0x40
    cmp     al, 0
    jz      wait_txd                  ; loop until free
 
    mov     edx, ebx
    pop     eax                     ; restore the byte to send
    out     dx, al
    ret
 
iglobal
  ; This is used for translating hex to ASCII for display or output
  hexchars    db '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
endg
end if

Rev 2	Rev 108
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; ETHERNET.INC ;;	3	;; ETHERNET.INC ;;
4	;; ;;	4	;; ;;
5	;; Ethernet network layer for Menuet OS ;;	5	;; Ethernet network layer for Menuet OS ;;
6	;; ;;	6	;; ;;
7	;; Version 0.4 22 September 2003 ;;	7	;; Version 0.4 22 September 2003 ;;
8	;; ;;	8	;; ;;
9	;; This file contains the following: ;;	9	;; This file contains the following: ;;
10	;; PCI bus scanning for valid devices ;;	10	;; PCI bus scanning for valid devices ;;
11	;; Table of supported ethernet drivers ;;	11	;; Table of supported ethernet drivers ;;
12	;; Code to identify and activate a supported driver ;;	12	;; Code to identify and activate a supported driver ;;
13	;; ARP handler ;;	13	;; ARP handler ;;
14	;; Driver interface to the IP layer ;;	14	;; Driver interface to the IP layer ;;
15	;; Gateway support ;;	15	;; Gateway support ;;
16	;; ;;	16	;; ;;
17	;; Individual driver files are included here ;;	17	;; Individual driver files are included here ;;
18	;; ;;	18	;; ;;
19	;; The PCI bus scanning code was ported from the etherboot ;;	19	;; The PCI bus scanning code was ported from the etherboot ;;
20	;; 5.0.6 project. The copyright statement for that code is ;;	20	;; 5.0.6 project. The copyright statement for that code is ;;
21	;; ;;	21	;; ;;
22	;; GNU GENERAL PUBLIC LICENSE ;;	22	;; GNU GENERAL PUBLIC LICENSE ;;
23	;; Version 2, June 1991 ;;	23	;; Version 2, June 1991 ;;
24	;; ;;	24	;; ;;
25	;; remaining parts Copyright 2002 Mike Hibbett ;;	25	;; remaining parts Copyright 2002 Mike Hibbett ;;
26	;; mikeh@oceanfree.net ;;	26	;; mikeh@oceanfree.net ;;
27	;; ;;	27	;; ;;
28	;; See file COPYING for details ;;	28	;; See file COPYING for details ;;
29	;; ;;	29	;; ;;
30	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	30	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
31		31
32	;********************************************************************	32	;********************************************************************
33	; Interface	33	; Interface
34	; ethernet_driver called by stack_handler in stack.inc	34	; ethernet_driver called by stack_handler in stack.inc
35	; eth_probe called by app_stack_handler in stack.inc	35	; eth_probe called by app_stack_handler in stack.inc
36	;	36	;
37	;********************************************************************	37	;********************************************************************
38		38
39	; Some useful information on data structures	39	; Some useful information on data structures
40		40
41	; Ethernet Packet - ARP Request example	41	; Ethernet Packet - ARP Request example
42	;	42	;
43	; 0 1 2 3	43	; 0 1 2 3
44	; 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1	44	; 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
45	;	45	;
46	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	46	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
47	; \| Dest H/W Address \|	47	; \| Dest H/W Address \|
48	; \| ( 14 byte header ) \|	48	; \| ( 14 byte header ) \|
49	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	49	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
50	; \| \| Source H/W Address \|	50	; \| \| Source H/W Address \|
51	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	51	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
52	; \| \|	52	; \| \|
53	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	53	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
54	; \| Protocol - ARP 08 06 \|	54	; \| Protocol - ARP 08 06 \|
55	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	55	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
56		56
57	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	57	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
58	; \| H/W Type 00 01 \| Protocol Type 08 00 \|	58	; \| H/W Type 00 01 \| Protocol Type 08 00 \|
59	; \| ( ARP Request packet ) \|	59	; \| ( ARP Request packet ) \|
60	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	60	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
61	; \| HLen 0x06 \| PLen 0x04 \| OpCode 00 01 \|	61	; \| HLen 0x06 \| PLen 0x04 \| OpCode 00 01 \|
62	; \| ( 0001 for request, 0002 for reply ) \|	62	; \| ( 0001 for request, 0002 for reply ) \|
63	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	63	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
64	; \| Source Hardware Address ( MAC Address ) \|	64	; \| Source Hardware Address ( MAC Address ) \|
65	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	65	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
66	; \| \| Source IP Address \|	66	; \| \| Source IP Address \|
67	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	67	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
68	; \| \| Destination Hardware Address \|	68	; \| \| Destination Hardware Address \|
69	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	69	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
70	; \| \|	70	; \| \|
71	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	71	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
72	; \| Destination IP Address \|	72	; \| Destination IP Address \|
73	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+	73	; +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
74		74
75	; Include individual drivers source files at this point.	75	; Include individual drivers source files at this point.
76	; If you create a new driver, include it below.	76	; If you create a new driver, include it below.
77		77
78	include "rtl8029.inc"	78	include "rtl8029.inc"
79	include "i8255x.inc"	79	include "i8255x.inc"
80	include "rtl8139.inc"	80	include "rtl8139.inc"
81	include "3c59x.inc"	81	include "3c59x.inc"
82	include "sis900.inc"	82	include "sis900.inc"
83	include "pcnet32.inc"	83	include "pcnet32.inc"
84		84
85	; DEBUGGING_STATE enables or disables output of received and transmitted	85	; DEBUGGING_STATE enables or disables output of received and transmitted
86	; data over the serial port	86	; data over the serial port
87	DEBUGGING_ENABLED equ 1	87	DEBUGGING_ENABLED equ 1
88	DEBUGGING_DISABLED equ 0	88	DEBUGGING_DISABLED equ 0
89	DEBUGGING_STATE equ DEBUGGING_DISABLED	89	DEBUGGING_STATE equ DEBUGGING_DISABLED
90		90
91	; PCICards	91	; PCICards
92	; ========	92	; ========
93	; PCI vendor and hardware types for hardware supported by the above drivers	93	; PCI vendor and hardware types for hardware supported by the above drivers
94	; If you add a driver, ensure you update this datastructure, otherwise the	94	; If you add a driver, ensure you update this datastructure, otherwise the
95	; card will not be probed.	95	; card will not be probed.
96	; Each driver is defined by 4 double words. These are	96	; Each driver is defined by 4 double words. These are
97	; PCIVendorDevice probeFunction ResetFunction PollFunction transmitFunction	97	; PCIVendorDevice probeFunction ResetFunction PollFunction transmitFunction
98	; The last entry must be kept at all zeros, to indicate the end of the list	98	; The last entry must be kept at all zeros, to indicate the end of the list
99	; As a PCI driver may support more than one hardware implementation, there may	99	; As a PCI driver may support more than one hardware implementation, there may
100	; be several lines which refer to the same functions.	100	; be several lines which refer to the same functions.
101	; The first driver found on the PCI bus will be the one used.	101	; The first driver found on the PCI bus will be the one used.
102		102
103	PCICARDS_ENTRY_SIZE equ 20 ; Size of each PCICARDS entry	103	PCICARDS_ENTRY_SIZE equ 20 ; Size of each PCICARDS entry
104		104
105	iglobal	105	iglobal
106	PCICards:	106	PCICards:
107	dd 0x12098086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit	107	dd 0x12098086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit
108	dd 0x10298086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit	108	dd 0x10298086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit
109	dd 0x12298086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit	109	dd 0x12298086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit
110	dd 0x10308086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit	110	dd 0x10308086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit
111	dd 0x24498086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit	111	dd 0x24498086, I8255x_probe, I8255x_reset, I8255x_poll, I8255x_transmit
112	dd 0x802910ec, rtl8029_probe, rtl8029_reset, rtl8029_poll, rtl8029_transmit	112	dd 0x802910ec, rtl8029_probe, rtl8029_reset, rtl8029_poll, rtl8029_transmit
113	dd 0x12111113, rtl8029_probe, rtl8029_reset, rtl8029_poll, rtl8029_transmit	113	dd 0x12111113, rtl8029_probe, rtl8029_reset, rtl8029_poll, rtl8029_transmit
114	dd 0x813910ec, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit	114	dd 0x813910ec, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		115	; /+/ Íîâûå âåíäîðû ñåòåâûõ êàðò íà áàçå rtl8139
-		116	dd 0x813810ec, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		117	dd 0x12111113, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		118	dd 0x13601500, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		119	dd 0x13604033, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		120	dd 0x13001186, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		121	dd 0x13401186, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		122	dd 0xab0613d1, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		123	dd 0xa1171259, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		124	dd 0xa11e1259, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		125	dd 0xab0614ea, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		126	dd 0xab0714ea, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		127	dd 0x123411db, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		128	dd 0x91301432, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		129	dd 0x101202ac, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		130	dd 0x0106018a, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		131	dd 0x1211126c, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		132	dd 0x81391743, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		133	dd 0x8139021b, rtl8139_probe, rtl8139_reset, rtl8139_poll, rtl8139_transmit
-		134	; /-/
115	dd 0x590010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	135	dd 0x590010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
116	dd 0x592010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	136	dd 0x592010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
117	dd 0x597010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	137	dd 0x597010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
118	dd 0x595010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	138	dd 0x595010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
119	dd 0x595110b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	139	dd 0x595110b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
120	dd 0x595210b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	140	dd 0x595210b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
121	dd 0x900010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	141	dd 0x900010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
122	dd 0x900110b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	142	dd 0x900110b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
123	dd 0x900410b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	143	dd 0x900410b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
124	dd 0x900510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	144	dd 0x900510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
125	dd 0x900610b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	145	dd 0x900610b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
126	dd 0x900A10b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	146	dd 0x900A10b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
127	dd 0x905010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	147	dd 0x905010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
128	dd 0x905110b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	148	dd 0x905110b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
129	dd 0x905510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	149	dd 0x905510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
130	dd 0x905810b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	150	dd 0x905810b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
131	dd 0x905A10b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	151	dd 0x905A10b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
132	dd 0x920010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	152	dd 0x920010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
133	dd 0x980010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	153	dd 0x980010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
134	dd 0x980510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	154	dd 0x980510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
135	dd 0x764610b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	155	dd 0x764610b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
136	dd 0x505510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	156	dd 0x505510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
137	dd 0x605510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	157	dd 0x605510b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
138	dd 0x605610b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	158	dd 0x605610b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
139	dd 0x5b5710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	159	dd 0x5b5710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
140	dd 0x505710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	160	dd 0x505710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
141	dd 0x515710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	161	dd 0x515710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
142	dd 0x525710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	162	dd 0x525710b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
143	dd 0x656010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	163	dd 0x656010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
144	dd 0x656210b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	164	dd 0x656210b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
145	dd 0x656410b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	165	dd 0x656410b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
146	dd 0x450010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit	166	dd 0x450010b7, e3c59x_probe, e3c59x_reset, e3c59x_poll, e3c59x_transmit
147	dd 0x09001039, SIS900_probe, SIS900_reset, SIS900_poll, SIS900_transmit	167	dd 0x09001039, SIS900_probe, SIS900_reset, SIS900_poll, SIS900_transmit
148	dd 0x20001022, pcnet32_probe, pcnet32_reset, pcnet32_poll, pcnet32_xmit	168	dd 0x20001022, pcnet32_probe, pcnet32_reset, pcnet32_poll, pcnet32_xmit
149	dd 0x26251022, pcnet32_probe, pcnet32_reset, pcnet32_poll, pcnet32_xmit	169	dd 0x26251022, pcnet32_probe, pcnet32_reset, pcnet32_poll, pcnet32_xmit
150	dd 0x20011022, pcnet32_probe, pcnet32_reset, pcnet32_poll, pcnet32_xmit	170	dd 0x20011022, pcnet32_probe, pcnet32_reset, pcnet32_poll, pcnet32_xmit
151	; following card is untested	171	; following card is untested
152	dd 0x70161039, SIS900_probe, SIS900_reset, SIS900_poll, SIS900_transmit	172	dd 0x70161039, SIS900_probe, SIS900_reset, SIS900_poll, SIS900_transmit
153	dd 0,0,0,0,0 ; end of list marker, do not remove	173	dd 0,0,0,0,0 ; end of list marker, do not remove
154	endg	174	endg
155		175
156	; PCI Bus defines	176	; PCI Bus defines
157	PCI_HEADER_TYPE equ 0x0e ;8 bit	177	PCI_HEADER_TYPE equ 0x0e ;8 bit
158	PCI_BASE_ADDRESS_0 equ 0x10 ;32 bit	178	PCI_BASE_ADDRESS_0 equ 0x10 ;32 bit
159	PCI_BASE_ADDRESS_5 equ 0x24 ;32 bits	179	PCI_BASE_ADDRESS_5 equ 0x24 ;32 bits
160	PCI_BASE_ADDRESS_SPACE_IO equ 0x01	180	PCI_BASE_ADDRESS_SPACE_IO equ 0x01
161	PCI_VENDOR_ID equ 0x00 ;16 bit	181	PCI_VENDOR_ID equ 0x00 ;16 bit
162	PCI_BASE_ADDRESS_IO_MASK equ 0xFFFFFFFC	182	PCI_BASE_ADDRESS_IO_MASK equ 0xFFFFFFFC
163		183
164	ETHER_IP equ 0x0008 ; Reversed from 0800 for intel	184	ETHER_IP equ 0x0008 ; Reversed from 0800 for intel
165	ETHER_ARP equ 0x0608 ; Reversed from 0806 for intel	185	ETHER_ARP equ 0x0608 ; Reversed from 0806 for intel
166	ETHER_RARP equ 0x3580	186	ETHER_RARP equ 0x3580
167	ARP_REQ_OPCODE equ 0x0100	187	ARP_REQ_OPCODE equ 0x0100
168	ARP_REP_OPCODE equ 0x0200	188	ARP_REP_OPCODE equ 0x0200
169		189
170	uglobal	190	uglobal
171	arp_rx_count: dd 0	191	arp_rx_count: dd 0
172	ip_rx_count: dd 0	192	ip_rx_count: dd 0
173	dumped_rx_count: dd 0	193	dumped_rx_count: dd 0
174	ip_tx_count: dd 0	194	ip_tx_count: dd 0
175	node_addr: db 0,0,0,0,0,0	195	node_addr: db 0,0,0,0,0,0
176	eth_rx_data_len: dw 0	196	eth_rx_data_len: dw 0
177	eth_status: dd 0	197	eth_status: dd 0
178	io_addr: dd 0	198	io_addr: dd 0
179	hdrtype: db 0	199	hdrtype: db 0
180	vendor_device: dd 0	200	vendor_device: dd 0
181	pci_data: dd 0	201	pci_data: dd 0
182	pci_dev: dd 0	202	pci_dev: dd 0
183	pci_bus: dd 0	203	pci_bus: dd 0
184		204
185	; These will hold pointers to the selected driver functions	205	; These will hold pointers to the selected driver functions
186	drvr_probe: dd 0	206	drvr_probe: dd 0
187	drvr_reset: dd 0	207	drvr_reset: dd 0
188	drvr_poll: dd 0	208	drvr_poll: dd 0
189	drvr_transmit: dd 0	209	drvr_transmit: dd 0
190		210
191	; These hold the destination Host identity for ARP responses	211	; These hold the destination Host identity for ARP responses
192	remote_ip_add: dd 0	212	remote_ip_add: dd 0
193	remote_hw_add: db 0, 0, 0, 0, 0, 0	213	remote_hw_add: db 0, 0, 0, 0, 0, 0
194	endg	214	endg
195		215
196	iglobal	216	iglobal
197	broadcast_add: db 0xff,0xff,0xff,0xff,0xff,0xff	217	broadcast_add: db 0xff,0xff,0xff,0xff,0xff,0xff
198	subnet_mask: dd 0x00ffffff	218	subnet_mask: dd 0x00ffffff
199	endg	219	endg
200		220
201	uglobal	221	uglobal
202	; This is used by getMACfromIP	222	; This is used by getMACfromIP
203	MACAddress: db 0,0,0,0,0,0	223	MACAddress: db 0,0,0,0,0,0
204	gateway_ip: db 0, 0, 0, 0	224	gateway_ip: db 0, 0, 0, 0
205	dns_ip: dd 0	225	dns_ip: dd 0
206	endg	226	endg
207		227
208	; The follow is the ARP Table.	228	; The follow is the ARP Table.
209	; This table must be manually updated and the kernel recompilied if	229	; This table must be manually updated and the kernel recompilied if
210	; changes are made to it.	230	; changes are made to it.
211	; ARP_TABLE_SIZE defines the size of the table	231	; ARP_TABLE_SIZE defines the size of the table
212	; ARP_TABLE_ENTRIES defines the number of entries in the table	232	; ARP_TABLE_ENTRIES defines the number of entries in the table
213	; Each entry is 10 bytes: 4 Byte IP address, 6 byte MAC Address,	233	; Each entry is 10 bytes: 4 Byte IP address, 6 byte MAC Address,
214	; 2 bytes status, 2 bytes TTL ( in seconds )	234	; 2 bytes status, 2 bytes TTL ( in seconds )
215	; Empty entries are filled with zeros	235	; Empty entries are filled with zeros
216	; The TTL field is decremented every second, and is deleted when it	236	; The TTL field is decremented every second, and is deleted when it
217	; reaches 0. It is refreshed every time a packet is received	237	; reaches 0. It is refreshed every time a packet is received
218	; If the TTL field is 0xFFFF it is a permanent entry and is never deleted	238	; If the TTL field is 0xFFFF it is a permanent entry and is never deleted
219	; The status field can be the following values	239	; The status field can be the following values
220	; 0x0000 entry not used	240	; 0x0000 entry not used
221	; 0x0001 entry holds a valid mapping	241	; 0x0001 entry holds a valid mapping
222	; 0x0002 entry contains an IP address, awaiting ARP response	242	; 0x0002 entry contains an IP address, awaiting ARP response
223	; 0x0003 No response received to ARP request.	243	; 0x0003 No response received to ARP request.
224	; The last status value is provided to allow the network layer to delete	244	; The last status value is provided to allow the network layer to delete
225	; a packet that is queued awaiting an ARP response	245	; a packet that is queued awaiting an ARP response
226		246
227	ARP_NO_ENTRY equ 0	247	ARP_NO_ENTRY equ 0
228	ARP_VALID_MAPPING equ 1	248	ARP_VALID_MAPPING equ 1
229	ARP_AWAITING_RESPONSE equ 2	249	ARP_AWAITING_RESPONSE equ 2
230	ARP_RESPONSE_TIMEOUT equ 3	250	ARP_RESPONSE_TIMEOUT equ 3
231		251
232	ARP_ENTRY_SIZE equ 14 ; Number of bytes per entry	252	ARP_ENTRY_SIZE equ 14 ; Number of bytes per entry
233	ARP_TABLE_SIZE equ 20 ; Size of table	253	ARP_TABLE_SIZE equ 20 ; Size of table
234	ARP_TABLE_ENTRIES equ 0 ; Inital, hardcoded entries	254	ARP_TABLE_ENTRIES equ 0 ; Inital, hardcoded entries
235		255
236	uglobal	256	uglobal
237	ARPTable:	257	ARPTable:
238	times ( ARP_TABLE_SIZE - ARP_TABLE_ENTRIES ) * ARP_ENTRY_SIZE db 0	258	times ( ARP_TABLE_SIZE - ARP_TABLE_ENTRIES ) * ARP_ENTRY_SIZE db 0
239	endg	259	endg
240		260
241	iglobal	261	iglobal
242	NumARP: db ARP_TABLE_ENTRIES	262	NumARP: db ARP_TABLE_ENTRIES
243	endg	263	endg
244		264
245	;***************************************************************************	265	;***************************************************************************
246	; Function	266	; Function
247	; eth_probe	267	; eth_probe
248	; Description	268	; Description
249	; Searches for an ethernet card. If found, the card is enabled and	269	; Searches for an ethernet card. If found, the card is enabled and
250	; the ethernet -> IP link established	270	; the ethernet -> IP link established
251	;	271	;
252	; This function scans the PCI bus looking for a supported device.	272	; This function scans the PCI bus looking for a supported device.
253	; ISA bus is currently not supported.	273	; ISA bus is currently not supported.
254	;	274	;
255	; eax is 0 if no hardware found	275	; eax is 0 if no hardware found
256	;***************************************************************************	276	;***************************************************************************
257	eth_probe:	277	eth_probe:
258	; Find a card on the PCI bus, and get it's address	278	; Find a card on the PCI bus, and get it's address
259	call scan_bus ; Find the ethernet cards PIC address	279	call scan_bus ; Find the ethernet cards PIC address
260	xor eax, eax	280	xor eax, eax
261	cmp [io_addr], eax	281	cmp [io_addr], eax
262	je ep_00x ; Return 0 in eax if no cards found	282	je ep_00x ; Return 0 in eax if no cards found
263		283
264	call dword [drvr_probe] ; Call the drivers probe function	284	call dword [drvr_probe] ; Call the drivers probe function
265		285
266	mov eax, [io_addr] ; return a non zero value	286	mov eax, [io_addr] ; return a non zero value
267		287
268	ep_00x:	288	ep_00x:
269	ret	289	ret
270		290
271	;***************************************************************************	291	;***************************************************************************
272	; Function	292	; Function
273	; ethernet_driver	293	; ethernet_driver
274	;	294	;
275	; Description	295	; Description
276	; The ethernet RX and TX handler	296	; The ethernet RX and TX handler
277	; This is a kernel function, called by stack_handler	297	; This is a kernel function, called by stack_handler
278	;	298	;
279	;***************************************************************************	299	;***************************************************************************
280	ethernet_driver:	300	ethernet_driver:
281	; Do nothing if the driver is inactive	301	; Do nothing if the driver is inactive
282	cmp [ethernet_active], byte 0	302	cmp [ethernet_active], byte 0
283	je eth_exit	303	je eth_exit
284		304
285	call eth_rx	305	call eth_rx
286	call eth_tx	306	call eth_tx
287		307
288	eth_exit:	308	eth_exit:
289	ret	309	ret
290		310
291	;***************************************************************************	311	;***************************************************************************
292	; Function	312	; Function
293	; eth_rx	313	; eth_rx
294	;	314	;
295	; Description	315	; Description
296	; Polls the ethernet card for received data. Extracts if present	316	; Polls the ethernet card for received data. Extracts if present
297	; Depending on the Protocol within the packet:	317	; Depending on the Protocol within the packet:
298	; ARP : Pass to ARP_handler. This may result in an ARP reply	318	; ARP : Pass to ARP_handler. This may result in an ARP reply
299	; being tx'ed	319	; being tx'ed
300	; IP : Store in an IP buffer	320	; IP : Store in an IP buffer
301	;	321	;
302	;***************************************************************************	322	;***************************************************************************
303	eth_rx:	323	eth_rx:
304	xor ax, ax	324	xor ax, ax
305	mov [eth_rx_data_len], ax	325	mov [eth_rx_data_len], ax
306	call dword [drvr_poll] ; Call the drivers poll function	326	call dword [drvr_poll] ; Call the drivers poll function
307		327
308	mov ax, [eth_rx_data_len]	328	mov ax, [eth_rx_data_len]
309	cmp ax, 0	329	cmp ax, 0
310	je erx_exit	330	je erx_exit
311		331
312	if DEBUGGING_STATE = DEBUGGING_ENABLED	332	if DEBUGGING_STATE = DEBUGGING_ENABLED
313	pusha	333	pusha
314	mov eax, 0 ;Indicate that this is a received packet	334	mov eax, 0 ;Indicate that this is a received packet
315	mov cx, [eth_rx_data_len]	335	mov cx, [eth_rx_data_len]
316	mov esi, Ether_buffer	336	mov esi, Ether_buffer
317	cmp word [esi + 12], ETHER_IP	337	cmp word [esi + 12], ETHER_IP
318	jnz erxd_done	338	jnz erxd_done
319	; cmp byte [esi + 14 + 9], 0x06 ; TCP	339	; cmp byte [esi + 14 + 9], 0x06 ; TCP
320	; jnz erxd_done	340	; jnz erxd_done
321	call eth_dump	341	call eth_dump
322	erxd_done:	342	erxd_done:
323	popa	343	popa
324	end if	344	end if
325		345
326	; Check the protocol. Call appropriate handler	346	; Check the protocol. Call appropriate handler
327	mov eax, Ether_buffer	347	mov eax, Ether_buffer
328	add eax, 12 ; The address of the protocol word	348	add eax, 12 ; The address of the protocol word
329		349
330	mov ax, [eax]	350	mov ax, [eax]
331		351
332	cmp ax, ETHER_ARP	352	cmp ax, ETHER_ARP
333	je erx_001 ; It is ARP	353	je erx_001 ; It is ARP
334		354
335	cmp ax, ETHER_IP	355	cmp ax, ETHER_IP
336	je erx_002 ; It's IP	356	je erx_002 ; It's IP
337		357
338	; inc dword [dumped_rx_count]	358	; inc dword [dumped_rx_count]
339		359
340	jmp erx_exit ; If not IP or ARP, ignore	360	jmp erx_exit ; If not IP or ARP, ignore
341		361
342	erx_001:	362	erx_001:
343	mov eax, [arp_rx_count]	363	mov eax, [arp_rx_count]
344	inc eax	364	inc eax
345	mov [arp_rx_count], eax	365	mov [arp_rx_count], eax
346		366
347	; At this point, the packet is still in the Ether_buffer	367	; At this point, the packet is still in the Ether_buffer
348	call arp_handler	368	call arp_handler
349		369
350	jmp erx_exit	370	jmp erx_exit
351		371
352	erx_002:	372	erx_002:
353	mov eax, [ip_rx_count]	373	mov eax, [ip_rx_count]
354	inc eax	374	inc eax
355	mov [ip_rx_count], eax	375	mov [ip_rx_count], eax
356		376
357	; Check to see if the MAC address is in our arp table	377	; Check to see if the MAC address is in our arp table
358	; refresh the arp ttl if so	378	; refresh the arp ttl if so
359		379
360	mov esi, Ether_buffer	380	mov esi, Ether_buffer
361	add esi, 6	381	add esi, 6
362		382
363	call refreshARP	383	call refreshARP
364		384
365	call ether_IP_handler	385	call ether_IP_handler
366		386
367	jmp erx_exit	387	jmp erx_exit
368		388
369	erx_exit:	389	erx_exit:
370	ret	390	ret
371		391
372	;***************************************************************************	392	;***************************************************************************
373	; Function	393	; Function
374	; eth_tx	394	; eth_tx
375	;	395	;
376	; Description	396	; Description
377	; Looks at the NET1OUT_QUEUE for data to send.	397	; Looks at the NET1OUT_QUEUE for data to send.
378	; Stores that destination IP in a location used by the tx routine	398	; Stores that destination IP in a location used by the tx routine
379	; Looks up the MAC address in the ARP table; stores that where	399	; Looks up the MAC address in the ARP table; stores that where
380	; the tx routine can get it	400	; the tx routine can get it
381	; Get the length of the data. Store that where the tx routine wants it	401	; Get the length of the data. Store that where the tx routine wants it
382	; Call tx	402	; Call tx
383	; Places buffer on empty queue when the tx routine finished	403	; Places buffer on empty queue when the tx routine finished
384	;	404	;
385	;***************************************************************************	405	;***************************************************************************
386	eth_tx:	406	eth_tx:
387	; Look for a buffer to tx	407	; Look for a buffer to tx
388	mov eax, NET1OUT_QUEUE	408	mov eax, NET1OUT_QUEUE
389	call dequeue	409	call dequeue
390	cmp ax, NO_BUFFER	410	cmp ax, NO_BUFFER
391	je eth_exit ; Exit if no buffer available	411	je eth_exit ; Exit if no buffer available
392		412
393	push eax	413	push eax
394		414
395	; convert buffer pointer eax to the absolute address	415	; convert buffer pointer eax to the absolute address
396	mov ecx, IPBUFFSIZE	416	mov ecx, IPBUFFSIZE
397	mul ecx	417	mul ecx
398	add eax, IPbuffs	418	add eax, IPbuffs
399		419
400	; Extract the destination IP	420	; Extract the destination IP
401	; find the destination IP in the ARP table, get MAC	421	; find the destination IP in the ARP table, get MAC
402	; store this MAC in 'MACAddress'	422	; store this MAC in 'MACAddress'
403	mov ebx, eax ; Save buffer address	423	mov ebx, eax ; Save buffer address
404	mov edx, [ebx + 16] ; get destination address	424	mov edx, [ebx + 16] ; get destination address
405		425
406	; If the destination address is 255.255.255.255,	426	; If the destination address is 255.255.255.255,
407	; set the MACAddress to all ones ( broadcast )	427	; set the MACAddress to all ones ( broadcast )
408	mov [MACAddress], dword 0xffffffff	428	mov [MACAddress], dword 0xffffffff
409	mov [MACAddress + 4], word 0xffff	429	mov [MACAddress + 4], word 0xffff
410	cmp edx, 0xffffffff	430	cmp edx, 0xffffffff
411	je etx_send ; If it is broadcast, just send	431	je etx_send ; If it is broadcast, just send
412		432
413	call getMACfromIP ; Get the MAC address.	433	call getMACfromIP ; Get the MAC address.
414		434
415	cmp eax, ARP_VALID_MAPPING	435	cmp eax, ARP_VALID_MAPPING
416	jz etx_send	436	jz etx_send
417		437
418	; No valid entry. Are we waiting for a response?	438	; No valid entry. Are we waiting for a response?
419	cmp eax, ARP_AWAITING_RESPONSE	439	cmp eax, ARP_AWAITING_RESPONSE
420	jne etx_001	440	jne etx_001
421		441
422	; Re-queue the packet, and exit	442	; Re-queue the packet, and exit
423	pop ebx	443	pop ebx
424	mov eax, NET1OUT_QUEUE	444	mov eax, NET1OUT_QUEUE
425	call queue	445	call queue
426	jmp etx_exit	446	jmp etx_exit
427		447
428	etx_001:	448	etx_001:
429	; HAs the request been sent, but timed out?	449	; HAs the request been sent, but timed out?
430	cmp eax, ARP_RESPONSE_TIMEOUT	450	cmp eax, ARP_RESPONSE_TIMEOUT
431	jne etx_002	451	jne etx_002
432		452
433	pop eax	453	pop eax
434	call freeBuff	454	call freeBuff
435	jmp etx_exit	455	jmp etx_exit
436		456
437	etx_002:	457	etx_002:
438	; There is no entry. Re queue the request, and ask ARP to send a request	458	; There is no entry. Re queue the request, and ask ARP to send a request
439		459
440	; IP address is in edx	460	; IP address is in edx
441	push edx	461	push edx
442	call arp_request	462	call arp_request
443	pop ebx	463	pop ebx
444		464
445	; Add an entry in the ARP table, awaiting response	465	; Add an entry in the ARP table, awaiting response
446		466
447	cmp byte [NumARP], ARP_TABLE_SIZE	467	cmp byte [NumARP], ARP_TABLE_SIZE
448	je etx_003 ; We cannot add a new entry in the table	468	je etx_003 ; We cannot add a new entry in the table
449		469
450	inc byte [NumARP]	470	inc byte [NumARP]
451		471
452	movzx eax, byte [NumARP]	472	movzx eax, byte [NumARP]
453	mov ecx, ARP_ENTRY_SIZE	473	mov ecx, ARP_ENTRY_SIZE
454	mul ecx	474	mul ecx
455	sub eax, ARP_ENTRY_SIZE	475	sub eax, ARP_ENTRY_SIZE
456		476
457	mov [eax + ARPTable], ebx	477	mov [eax + ARPTable], ebx
458	xor ebx, ebx	478	xor ebx, ebx
459	mov [eax + ARPTable + 4], ebx	479	mov [eax + ARPTable + 4], ebx
460	mov [eax + ARPTable + 8], bx	480	mov [eax + ARPTable + 8], bx
461		481
462	; set the status field up - awaiting response	482	; set the status field up - awaiting response
463	mov cl, 0x00	483	mov cl, 0x00
464	mov [eax + ARPTable + 10], cl	484	mov [eax + ARPTable + 10], cl
465	mov cl, 0x02	485	mov cl, 0x02
466	mov [eax + ARPTable + 11], cl	486	mov [eax + ARPTable + 11], cl
467		487
468	; Initialise the time to live field - 10s	488	; Initialise the time to live field - 10s
469	mov cx, 0x000A	489	mov cx, 0x000A
470	mov [eax + ARPTable + 12], cx	490	mov [eax + ARPTable + 12], cx
471		491
472	etx_003:	492	etx_003:
473	pop ebx ; Get the buffer back	493	pop ebx ; Get the buffer back
474	mov eax, NET1OUT_QUEUE	494	mov eax, NET1OUT_QUEUE
475	call queue	495	call queue
476	jmp etx_exit	496	jmp etx_exit
477		497
478	etx_send:	498	etx_send:
479	xor ecx, ecx	499	xor ecx, ecx
480	mov ch, [ebx+2]	500	mov ch, [ebx+2]

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/eth_drv/ethernet.inc – Rev 2 → 108