Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                                 ;;

;; Copyright (C) KolibriOS team 2004-2010. All rights reserved.    ;;

;; Distributed under terms of the GNU General Public License       ;;

;;                                                                 ;;

;;  RTL8029/ne2000 driver for KolibriOS                            ;;

;;                                                                 ;;

;;  based on RTL8029.asm driver for menuetos                       ;;

;;  and realtek8029.asm for SolarOS by Eugen Brasoveanu            ;;

;;                                                                 ;;

;;    Written by hidnplayr@kolibrios.org                           ;;

;;     with help from CleverMouse                                  ;;

;;                                                                 ;;

;;          GNU GENERAL PUBLIC LICENSE                             ;;

;;             Version 2, June 1991                                ;;

;;                                                                 ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

format MS COFF

        API_VERSION             =   0x01000100

        DRIVER_VERSION          =   5

        MAX_DEVICES             =   16

        DEBUG                   =   1

        __DEBUG__               =   1

        __DEBUG_LEVEL__         =   1

include 'proc32.inc'

include 'imports.inc'

include 'fdo.inc'

include 'netdrv.inc'

virtual at ebx

        device:

        ETH_DEVICE

        .io_addr          dd ?

        .irq_line         db ?

        .pci_bus          db ?

        .pci_dev          db ?

        .flags            db ?

        .vendor           db ?

        .asic_base        dw ?

        .memsize          db ?

        .rx_start         db ?

        .tx_start         db ?

        .bmem             dd ?

        .rmem             dd ?

        .romdata          rb 16

        .size = $ - device

end virtual

public START

public service_proc

public version

        P0_PSTART                 =   0x01

        P0_PSTOP                  =   0x02

        P0_BOUND                  =   0x03

        P0_TSR                    =   0x04

        P0_TPSR                   =   0x04

        P0_TBCR0                  =   0x05

        P0_TBCR1                  =   0x06

        P0_ISR                    =   0x07

        P0_RSAR0                  =   0x08

        P0_RSAR1                  =   0x09

        P0_RBCR0                  =   0x0A

        P0_RBCR1                  =   0x0B

        P0_RSR                    =   0x0C

        P0_RCR                    =   0x0C

        P0_TCR                    =   0x0D

        P0_DCR                    =   0x0E

        P0_IMR                    =   0x0F

        P1_PAR0                   =   0x01

        P1_PAR1                   =   0x02

        P1_PAR2                   =   0x03

        P1_PAR3                   =   0x04

        P1_PAR4                   =   0x05

        P1_PAR5                   =   0x06

        P1_CURR                   =   0x07

        P1_MAR0                   =   0x08

        CMD_PS0                   =   0x00        ;  Page 0 select

        CMD_PS1                   =   0x40        ;  Page 1 select

        CMD_PS2                   =   0x80        ;  Page 2 select

        CMD_RD2                   =   0x20        ;  Remote DMA control

        CMD_RD1                   =   0x10

        CMD_RD0                   =   0x08

        CMD_TXP                   =   0x04        ;  transmit packet

        CMD_STA                   =   0x02        ;  start

        CMD_STP                   =   0x01        ;  stop

        RCR_MON                   =   0x20        ;  monitor mode

        DCR_FT1                   =   0x40

        DCR_LS                    =   0x08        ;  Loopback select

        DCR_WTS                   =   0x01        ;  Word transfer select

        ISR_PRX                   =   0x01        ;  successful recv

        ISR_PTX                   =   0x02        ;  successful xmit

        ISR_RXE                   =   0x04        ;  receive error

        ISR_TXE                   =   0x08        ;  transmit error

        ISR_OVW                   =   0x10        ;  Overflow

        ISR_CNT                   =   0x20        ;  Counter overflow

        ISR_RDC                   =   0x40        ;  Remote DMA complete

        ISR_RST                   =   0x80        ;  reset

        IRQ_MASK                  =   ISR_PRX ; + ISR_PTX + ISR_TXE

        RSTAT_PRX                 =   0x01        ;  successful recv

        RSTAT_CRC                 =   0x02        ;  CRC error

        RSTAT_FAE                 =   0x04        ;  Frame alignment error

        RSTAT_OVER                =   0x08        ;  FIFO overrun

        TXBUF_SIZE                =   6

        RXBUF_END                 =   32

        PAGE_SIZE                 =   256

        ETH_ALEN                  =   6

        ETH_HLEN                  =   14

        ETH_ZLEN                  =   60

        ETH_FRAME_LEN             =   1514

        FLAG_PIO                  =   0x01

        FLAG_16BIT                =   0x02

        ASIC_PIO                  =   0

        VENDOR_NONE               =   0

        VENDOR_WD                 =   1

        VENDOR_NOVELL             =   2

        VENDOR_3COM               =   3

        NE_ASIC_OFFSET            =   0x10

        NE_RESET                  =   0x0F        ; Used to reset card

        NE_DATA                   =   0x00        ; Used to read/write NIC mem

        MEM_8192                  =   32

        MEM_16384                 =   64

        MEM_32768                 =   128

        ISA_MAX_ADDR              =   0x400

section '.flat' code readable align 16

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;

;; proc START

;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

align 4

proc START stdcall, state:dword

        cmp     [state], 1

        jne     .exit

  .entry:

        DEBUGF 2,"Registering rtl8029 service \n"

        stdcall RegService, my_service, service_proc

        ret

  .fail:

  .exit:

        xor     eax, eax

        ret

endp

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;

;; proc SERVICE_PROC

;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

align 4

proc service_proc stdcall, ioctl:dword

        mov     edx, [ioctl]

        mov     eax, [IOCTL.io_code]

;------------------------------------------------------

                       ;---------------

        cmp     eax, 0 ;SRV_GETVERSION

        jne     @F     ;---------------

        cmp     [IOCTL.out_size], 4

        jl      .fail

        mov     eax, [IOCTL.output]

        mov     [eax], dword API_VERSION

        xor     eax, eax

        ret

;------------------------------------------------------

  @@:                  ;---------

        cmp     eax, 1 ;SRV_HOOK

        jne     @F     ;---------

        DEBUGF  2,"Checking if device is already listed..\n"

        mov     eax, [IOCTL.input]

        cmp     [IOCTL.inp_size], 3

        jl      .fail

        cmp     byte [eax], 1

        je      .pci

        cmp     [IOCTL.inp_size], 4

        jl      .fail

        cmp     byte [eax], 0

        je      .isa

        jmp     .fail

  .pci:

; check if the device is already listed

        mov     esi, device_list

        mov     ecx, [devices]

        test    ecx, ecx

        jz      .firstdevice_pci

        mov     ax , [eax+1]                            ; get the pci bus and device numbers

  .nextdevice:

        mov     ebx, [esi]

        cmp     ax , word [device.pci_bus]              ; compare with pci and device num in device list (notice the usage of word instead of byte)

        je      .find_devicenum                         ; Device is already loaded, let's find it's device number

        add     esi, 4

        loop    .nextdevice

  .firstdevice_pci:

        call    create_new_struct

        mov     eax, [IOCTL.input]

        mov     cl , [eax+1]

        mov     [device.pci_bus], cl

        mov     cl , [eax+2]

        mov     [device.pci_dev], cl

; Now, it's time to find the base io addres of the PCI device

        find_io [device.pci_bus], [device.pci_dev], [device.io_addr]

; We've found the io address, find IRQ now

        find_irq [device.pci_bus], [device.pci_dev], [device.irq_line]

        jmp     .hook

  .isa:

        mov     esi, device_list

        mov     ecx, [devices]

        test    ecx, ecx

        jz      .firstdevice_isa

        mov     al , [eax+3]

        movzx   edi, word [eax+1]

  .nextdevice_isa:

        mov     ebx, [esi]

        cmp     edi, [device.io_addr]

        jne     .maybenext

        cmp     al , [device.irq_line]

        je      find_device_num

  .maybenext:

        add     esi, 4

        loop    .nextdevice_isa

  .firstdevice_isa:

        call    create_new_struct

        mov     eax, [IOCTL.input]

        movzx   ecx , word [eax+1]

        mov     [device.io_addr], ecx

        mov     cl, [eax+3]

        mov     [device.irq_line], cl

  .hook:

        DEBUGF  2,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\

        [device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4

        call    probe                                                   ; this function will output in eax

        test    eax, eax

        jnz     .err                                                    ; If an error occured, exit

        mov     eax, [devices]

        mov     [device_list+4*eax], ebx

        inc     [devices]

        mov     [device.type], NET_TYPE_ETH

        call    NetRegDev

        cmp     eax, -1

        jz      .err

        ret

; If the device was already loaded, find the device number and return it in eax

  .find_devicenum:

        DEBUGF  1,"Trying to find device number of already registered device\n"

        call    NetPtrToNum                                             ; This kernel procedure converts a pointer to device struct in ebx

                                                                        ; into a device number in edi

        mov     eax, edi                                                ; Application wants it in eax instead

        DEBUGF  1,"Kernel says: %u\n", eax

        ret

  .err:

        DEBUGF  1,"Failed, removing device structure\n"

        stdcall KernelFree, ebx

        jmp     .fail

;------------------------------------------------------

  @@:

.fail:

        or      eax, -1

        ret

;------------------------------------------------------

endp

create_new_struct:

        cmp     [devices], MAX_DEVICES

        jge     .fail

        allocate_and_clear ebx, device.size, .fail      ; Allocate the buffer for device structure

        mov     [device.reset], reset

        mov     [device.transmit], transmit

        mov     [device.get_MAC], read_mac

        mov     [device.set_MAC], write_mac

        mov     [device.unload], unload

        mov     [device.name], my_service

        ret

  .fail:

        add     esp, 4          ; return to caller of 'hook'

        or      eax, -1

        ret

find_device_num:

        DEBUGF  1,"Trying to find device number of already registered device\n"

        mov     ebx, eax

        call    NetPtrToNum                                             ; This kernel procedure converts a pointer to device struct in ebx

                                                                        ; into a device number in edi

        mov     eax, edi                                                ; Application wants it in eax instead

        DEBUGF  1,"Kernel says: %u\n", eax

        ret

;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;

;;                                                                        ;;

;;        Actual Hardware dependent code starts here                      ;;

;;                                                                        ;;

;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;

unload:   ; TODO

        or      eax, -1

        ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;

;;  probe: enables the device and clears the rx buffer

;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

probe:

        mov     [device.vendor], VENDOR_NONE

        mov     [device.bmem], 0

        mov     eax,[device.io_addr]

        add     eax, NE_ASIC_OFFSET

        mov     [device.asic_base], ax

        DEBUGF  2,"Trying 16-bit mode\n"

        or      [device.flags], FLAG_16BIT or FLAG_PIO

        mov     [device.memsize], MEM_32768

        mov     [device.tx_start], 64

        mov     [device.rx_start], TXBUF_SIZE + 64

        set_io  0

        set_io  P0_DCR

        mov     al, DCR_WTS + DCR_FT1 + DCR_LS

        out     dx, al

        set_io  P0_PSTART

        mov     al, MEM_16384

        out     dx, al

        set_io  P0_PSTOP

        mov     al, MEM_32768

        out     dx, al

        mov     esi, test_data

        mov     di, 16384

        mov     cx, 14

        call    eth_pio_write

        mov     si, 16384

        mov     cx, 14

        lea     edi, [device.romdata]

        call    eth_pio_read

        lea     esi, [device.romdata]

        mov     edi, test_data

        mov     ecx, 13

     repz    cmpsb

     jz      ep_set_vendor

        DEBUGF  2,"Trying 8-bit mode\n"

        mov     [device.flags], FLAG_PIO

        mov     [device.memsize], MEM_16384

        mov     [device.tx_start], 32

        mov     [device.rx_start], TXBUF_SIZE + 32

        mov     dx, [device.asic_base]

        add     dx, NE_RESET

        in      al, dx

        out     dx, al

        in      al, 0x84

        set_io  0

        mov     al, CMD_RD2 + CMD_STP

        out     dx, al

        set_io  P0_RCR

        mov     al, RCR_MON

        out     dx, al

        set_io  P0_DCR

        mov     al, DCR_FT1 + DCR_LS

        out     dx, al

        set_io  P0_PSTART

        mov     al, MEM_8192

        out     dx, al

        set_io  P0_PSTOP

        mov     al, MEM_16384

        out     dx, al

        mov     esi, test_data

        mov     di, 8192

        mov     cx, 14

        call    eth_pio_write

        mov     si, 8192

        mov     cx, 14

        lea     edi, [device.romdata]

        call    eth_pio_read

        mov     esi, test_data

        lea     edi, [device.romdata]

        mov     ecx, 13

    repz      cmpsb

    jz        ep_set_vendor

        DEBUGF  2,"This is not a valid ne2000 device!\n"

        or      eax, -1

        ret

ep_set_vendor:

        cmp     [device.io_addr], ISA_MAX_ADDR

        jbe     ep_001

        DEBUGF  2,"Card is using PCI bus\n"

;        or      [flags], FLAG_16BIT

ep_001:

        mov     [device.vendor], VENDOR_NOVELL

ep_check_have_vendor:

        mov     al, [device.vendor]

        cmp     al, VENDOR_NONE

;        je      rtl8029_exit

        cmp     al, VENDOR_3COM

        je      reset

        mov     eax, [device.bmem]

        mov     [device.rmem], eax

        call    read_mac

        push    .hack

        sub     esp, 6

        mov     edi, esp

        lea     esi, [device.mac]

        movsd

        movsw

        jmp     write_mac

       .hack:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;

;;   reset: Place the chip into a virgin state

;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

reset:

        DEBUGF  2,"Resetting device\n"

; attach int handler

        movzx   eax, [device.irq_line]

        DEBUGF  1,"Attaching int handler to irq %x\n",eax:1

        stdcall AttachIntHandler, eax, int_handler, dword 0

; Stop mode

        set_io  0

        mov     al, CMD_PS0 + CMD_RD2 + CMD_STP

        out     dx, al

        set_io  P0_DCR

        test    [device.flags], FLAG_16BIT

        jz      nsr_001

        mov     al, 0x49

        jmp     nsr_002

nsr_001:

        mov     al, 0x48

nsr_002:

        out     dx, al

; clear remote bytes count

        set_io  0

        xor     al, al

        set_io  P0_RBCR0

        out     dx, al

        set_io  P0_RBCR1

        out     dx, al

; initialize Receive configuration register

        set_io  P0_RCR

        mov     al, 0x20        ; monitor mode

        out     dx, al

; transmit configuration register

        set_io  P0_TCR

        mov     al, 2           ; internal loopback

        out     dx, al

; transmit page stuff

        set_io  P0_TPSR

        mov     al, [device.tx_start]

        out     dx, al

; set receive control register ;;;;

        set_io  P0_RCR

        mov     al, 4           ; accept broadcast

        out     dx, al

; pagestart

        set_io  P0_PSTART

        mov     al, [device.rx_start]

        out     dx, al

; pagestop

        set_io  P0_PSTOP

        mov     al, [device.memsize]

        out     dx, al

; page boundary

        set_io  P0_BOUND

        mov     al, [device.memsize]

        dec     al

        out     dx, al

;;clear IRQ mask

;        set_io  P0_IMR

;        xor     al, al

;        out     dx, al

        set_io  0

        mov     al, CMD_PS1 + CMD_RD2 + CMD_STP ; page 1, stop mode

        out     dx, al

        set_io  P1_CURR

        mov     al, [device.rx_start]

        out     dx, al

        set_io  0

        mov     al, CMD_PS0 + CMD_RD2 + CMD_STA ; go to page 0

        out     dx, al

; Read MAC address

        call    read_mac

; clear interupt status

        set_io  0

        set_io  P0_ISR

        mov     al, 0xff

        out     dx, al

; set IRQ mask

        set_io  P0_IMR

        mov     al, IRQ_MASK

        out     dx, al

;; start mode

;        set_io  0

;        mov     al, CMD_STA

;        out     dx, al

; clear transmit control register

        set_io  P0_TCR

        mov     al, 0           ; no loopback

        out     dx, al

; clear packet/byte counters

        xor     eax, eax

        lea     edi, [device.bytes_tx]

        mov     ecx, 6

        rep     stosd

; Set the mtu, kernel will be able to send now

        mov     [device.mtu], 1514

; Indicate that we have successfully reset the card

        xor     eax, eax

        DEBUGF  2,"Done!\n"

        ret

;***************************************************************************

;   Function

;      transmit

; buffer in [esp+4], size in [esp+8], pointer to device struct in ebx

;***************************************************************************

align 4

transmit:

        mov     esi, [esp + 4]

        mov     ecx, [esp + 8]

        DEBUGF  2,"Transmitting packet, buffer:%x, size:%u\n",esi, ecx

        DEBUGF  2,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",[esi+0]:2,[esi+1]:2,[esi+2]:2,[esi+3]:2,[esi+4]:2,[esi+5]:2,[esi+6]:2,[esi+7]:2,[esi+8]:2,[esi+9]:2,[esi+10]:2,[esi+11]:2,[esi+13]:2,[esi+12]:2

        cmp     ecx, ETH_FRAME_LEN

        jg      .err ; packet is too long

        cmp     ecx, 60

        jl      .err ; packet is too short

        movzx   edi, [device.tx_start]

        shl     edi, 8

        push    cx

        call    eth_pio_write

        pop     cx

        set_io  0

        mov     al, CMD_PS0 + CMD_RD2 + CMD_STA

        out     dx, al

        set_io  P0_TPSR

        mov     al, [device.tx_start]

        out     dx, al

        set_io  P0_TBCR0

        mov     al, cl

        out     dx, al

        set_io  P0_TBCR1

        mov     al, ch

        out     dx, al

        set_io  0

        mov     al, CMD_PS0 + CMD_TXP + CMD_RD2 + CMD_STA

        out     dx, al

        DEBUGF  2," - Packet Sent!\n"

        inc     [device.packets_tx]

        mov     eax, [esp + 8]                   ; Get packet size in eax

        add     dword [device.bytes_tx], eax

        adc     dword [device.bytes_tx + 4], 0

        stdcall KernelFree, [esp+4]

        xor     eax, eax

        ret     8

.err:

        or      eax, -1

        stdcall KernelFree, [esp+4]

        ret     8

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;

; Interrupt handler

;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

align 4

int_handler:

        DEBUGF  1,"\n%s int\n", my_service

; find pointer of device wich made INT occur

        mov     ecx, [devices]

        test    ecx, ecx

        jz      .nothing

        mov     esi, device_list

  .nextdevice:

        mov     ebx, [esi]

        set_io  0

        set_io  P0_ISR

        in      al, dx

        test    al, al

        jnz     .got_it

  .continue:

        add     esi, 4

        dec     ecx

        jnz     .nextdevice

  .nothing:

        ret

  .got_it:

        DEBUGF  1,"Device: %x Status: %x ", ebx, eax:2

        test    al, ISR_PRX    ; packet received ok ?

        jz      .no_rx

; looks like we've found a device wich received a packet..

        stdcall KernelAlloc, ETH_FRAME_LEN  ; size doesnt really matter as packet size is smaller then kernel's page size

        test    eax, eax

        jz      .fail_2

;--------------------------------------

; allocate memory for temp variables in stack

        sub     esp, 14+8

        eth_type        equ esp

        pkthdr          equ esp + 2

        pktoff          equ esp + 6

        eth_rx_data_ptr equ esp + 8

        eth_tmp_len     equ esp + 12

; These will be used by eth_receiver when the packet gets there

        pointer         equ esp + 14

        size            equ esp + 18

;-------------------------------------

        mov     [pointer], eax

        mov     [eth_rx_data_ptr], eax

        set_io  P0_BOUND

        in      al, dx

        inc     al

        cmp     al, [device.memsize]

        jb      .nsp_001

        mov     al, [device.rx_start]

.nsp_001:

        mov     ch, al

        set_io  0

        mov     al, CMD_PS1

        out     dx, al

        set_io  P1_CURR

        in      al, dx               ; get current page

        mov     cl, al

        set_io  0

        mov     al, CMD_PS0

        out     dx, al

        cmp     cl, [device.memsize]

        jb      .nsp_002

        mov     cl, [device.rx_start]

.nsp_002:

        cmp     cl, ch

        je      .fail

        xor     ax, ax

        mov     ah, ch

        mov     [pktoff], ax

        mov     al, [device.flags]

        test    al, FLAG_PIO

        jz      .nsp_003

        mov     si, word [pktoff]

        lea     edi, [pkthdr]

        mov     cx, 4

        call    eth_pio_read

        jmp     .nsp_004

.nsp_003:

        mov     edi, [device.rmem]

        movzx   eax, word [pktoff]

        add     edi, eax

        mov     eax, [edi]

        mov     [pkthdr], eax

.nsp_004:

        add     word[pktoff] , 4

        xor     eax, eax

        mov     ax , [pkthdr + 2]

        sub     ax , 4

        DEBUGF  2,"Received %u bytes\n",eax

        add     dword [device.bytes_rx], eax  ; Update stats

        adc     dword [device.bytes_rx + 4], 0

        inc     dword [device.packets_rx]     ;

        mov     [eth_tmp_len], ax

        mov     dword[size], eax

        cmp     ax, ETH_ZLEN

        jb      .fail

        cmp     ax , ETH_FRAME_LEN

        ja      .fail

        mov     al , [pkthdr]

        test    al , RSTAT_PRX

        jz      .fail

   ; Right, we can now get the data

        movzx   esi, [device.memsize]

        sub     si , [pktoff]

        cmp     [eth_tmp_len], si

        jbe     .nsp_005

        DEBUGF  2,"WRAP!\n"

        mov     al , [device.flags]

        test    al , FLAG_PIO

        jz      .nsp_006

        push    esi

        mov     cx , si

        mov     si , [pktoff+4]

        mov     edi, [eth_rx_data_ptr+4]

        call    eth_pio_read

        pop     esi

        jmp     .nsp_007

.nsp_006:

        DEBUGF  2,"PIO mode not supported by HW!\n"

   ; Not implemented, as we are using PIO mode on this card

.nsp_007:

        xor     al, al

        mov     ah, [device.rx_start]

        mov     [pktoff], ax

        add     [eth_rx_data_ptr], esi

        sub     [eth_tmp_len], si

.nsp_005:

        test    [device.flags], FLAG_PIO

        jz      .nsp_008

        movzx   esi, word [pktoff]

        movzx   ecx, word [eth_tmp_len]

        mov     edi, [eth_rx_data_ptr]

        call    eth_pio_read

        jmp     .nsp_009

.nsp_008:

        DEBUGF  2,"PIO mode not supported by HW!\n"

   ; Not implemented, as we are using PIO mode on this card

.nsp_009:

        mov     al, [pkthdr+1]

        cmp     al, [device.rx_start]

        jne     .nsp_010

        mov     al, [device.memsize]

.nsp_010:

        set_io  0

        set_io  P0_BOUND

        dec     al

        out     dx, al

        add     esp, 14

        jmp     Eth_input

.fail:

        add     esp, 14+8

.fail_2:

        DEBUGF  2,"done\n"

  .no_rx:

        ret

;;;;;;;;;;;;;;;;;;;;;;;

;;                   ;;

;; Write MAC address ;;

;;                   ;;

;;;;;;;;;;;;;;;;;;;;;;;

align 4

write_mac:      ; in: mac on stack (6 bytes)

        DEBUGF  1,"Writing MAC: "

        set_io  0

        mov     al, CMD_PS1; + CMD_RD2 + CMD_STP

        out     dx, al

        set_io  P1_PAR0

        mov     esi, esp

        mov     cx, 6

 @@:

        lodsb

        out     dx, al

        inc     dx

        loopw   @r

        add     esp, 6

; Notice this procedure does not ret, but continues to read_mac instead.

;;;;;;;;;;;;;;;;;;;;;;

;;                  ;;

;; Read MAC address ;;

;;                  ;;

;;;;;;;;;;;;;;;;;;;;;;

read_mac:

        DEBUGF  1,"Reading MAC: "

;        set_io  0

;        mov     al, CMD_PS1; + CMD_RD2 + CMD_STP ; select page 1

;        out     dx, al

;

;        set_io  P1_PAR0

;        lea     edi, [mac]

;

;        mov     cx, 6

; .loop:

;        in      al, dx

;        stosb

;        inc     dx

;        loopw   .loop

;

;        set_io  0

;        mov     al, CMD_PS0; + CMD_RD2 + CMD_STA  ; set page back to 0

;        out     dx, al

        mov     si, 0

        mov     cx, 16

        lea     edi, [device.romdata]

        call    eth_pio_read

        lea     esi, [device.romdata]

        lea     edi, [device.mac]

        mov     ecx, 6

  .loop:

        movsb

        test    [device.flags], FLAG_16BIT

        jz      .8bit

        inc     esi

  .8bit:

        loop    .loop

        DEBUGF  1,"%x-%x-%x-%x-%x-%x\n",[edi-6]:2,[edi-5]:2,[edi-4]:2,[edi-3]:2,[edi-2]:2,[edi-1]:2

        ret

;***************************************************************************

;   Function

;      eth_pio_read

;

;   Description

;       Read a frame from the ethernet card via Programmed I/O

;      src in si

;      cnt in cx

;       dst in edi

;***************************************************************************

eth_pio_read:

        DEBUGF  1,"Eth PIO Read from %x to %x, %u bytes ",si,edi,cx

        set_io  0

        mov     al, CMD_RD2 + CMD_STA

        out     dx, al

        mov     al, cl

        set_io  P0_RBCR0

        out     dx, al

        mov     al, ch

        set_io  P0_RBCR1

        out     dx, al