forked from KolibriOS/kolibrios
1210 lines
31 KiB
NASM
1210 lines
31 KiB
NASM
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; ;;
|
|
;; 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 equ 0x01000100
|
|
DRIVER_VERSION equ 5
|
|
|
|
MAX_DEVICES equ 16
|
|
|
|
DEBUG equ 1
|
|
__DEBUG__ equ 1
|
|
__DEBUG_LEVEL__ equ 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 equ 0x01
|
|
P0_PSTOP equ 0x02
|
|
P0_BOUND equ 0x03
|
|
P0_TSR equ 0x04
|
|
P0_TPSR equ 0x04
|
|
P0_TBCR0 equ 0x05
|
|
P0_TBCR1 equ 0x06
|
|
P0_ISR equ 0x07
|
|
P0_RSAR0 equ 0x08
|
|
P0_RSAR1 equ 0x09
|
|
P0_RBCR0 equ 0x0A
|
|
P0_RBCR1 equ 0x0B
|
|
P0_RSR equ 0x0C
|
|
P0_RCR equ 0x0C
|
|
P0_TCR equ 0x0D
|
|
P0_DCR equ 0x0E
|
|
P0_IMR equ 0x0F
|
|
|
|
P1_PAR0 equ 0x01
|
|
P1_PAR1 equ 0x02
|
|
P1_PAR2 equ 0x03
|
|
P1_PAR3 equ 0x04
|
|
P1_PAR4 equ 0x05
|
|
P1_PAR5 equ 0x06
|
|
P1_CURR equ 0x07
|
|
P1_MAR0 equ 0x08
|
|
|
|
CMD_PS0 equ 0x00 ; Page 0 select
|
|
CMD_PS1 equ 0x40 ; Page 1 select
|
|
CMD_PS2 equ 0x80 ; Page 2 select
|
|
CMD_RD2 equ 0x20 ; Remote DMA control
|
|
CMD_RD1 equ 0x10
|
|
CMD_RD0 equ 0x08
|
|
CMD_TXP equ 0x04 ; transmit packet
|
|
CMD_STA equ 0x02 ; start
|
|
CMD_STP equ 0x01 ; stop
|
|
|
|
RCR_MON equ 0x20 ; monitor mode
|
|
|
|
DCR_FT1 equ 0x40
|
|
DCR_LS equ 0x08 ; Loopback select
|
|
DCR_WTS equ 0x01 ; Word transfer select
|
|
|
|
ISR_PRX equ 0x01 ; successful recv
|
|
ISR_PTX equ 0x02 ; successful xmit
|
|
ISR_RXE equ 0x04 ; receive error
|
|
ISR_TXE equ 0x08 ; transmit error
|
|
ISR_OVW equ 0x10 ; Overflow
|
|
ISR_CNT equ 0x20 ; Counter overflow
|
|
ISR_RDC equ 0x40 ; Remote DMA complete
|
|
ISR_RST equ 0x80 ; reset
|
|
|
|
IRQ_MASK equ ISR_PRX ; + ISR_PTX + ISR_TXE
|
|
|
|
RSTAT_PRX equ 0x01 ; successful recv
|
|
RSTAT_CRC equ 0x02 ; CRC error
|
|
RSTAT_FAE equ 0x04 ; Frame alignment error
|
|
RSTAT_OVER equ 0x08 ; FIFO overrun
|
|
|
|
TXBUF_SIZE equ 6
|
|
RXBUF_END equ 32
|
|
PAGE_SIZE equ 256
|
|
|
|
ETH_ALEN equ 6
|
|
ETH_HLEN equ 14
|
|
ETH_ZLEN equ 60
|
|
ETH_FRAME_LEN equ 1514
|
|
|
|
FLAG_PIO equ 0x01
|
|
FLAG_16BIT equ 0x02
|
|
ASIC_PIO equ 0
|
|
|
|
VENDOR_NONE equ 0
|
|
VENDOR_WD equ 1
|
|
VENDOR_NOVELL equ 2
|
|
VENDOR_3COM equ 3
|
|
|
|
NE_ASIC_OFFSET equ 0x10
|
|
NE_RESET equ 0x0F ; Used to reset card
|
|
NE_DATA equ 0x00 ; Used to read/write NIC mem
|
|
|
|
MEM_8192 equ 32
|
|
MEM_16384 equ 64
|
|
MEM_32768 equ 128
|
|
|
|
ISA_MAX_ADDR equ 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 2,"IRQ %x ",eax:2
|
|
|
|
; find pointer of device wich made INT occur
|
|
mov esi, device_list
|
|
mov ecx, [devices]
|
|
.nextdevice:
|
|
mov ebx, [esi]
|
|
|
|
set_io 0
|
|
set_io P0_ISR
|
|
in al, dx
|
|
|
|
DEBUGF 2,"isr %x ",eax:2
|
|
|
|
test al, ISR_PRX ; packet received ok ?
|
|
jnz .rx
|
|
|
|
add esi, 4
|
|
|
|
loop .nextdevice
|
|
ret
|
|
|
|
|
|
; looks like we've found a device wich received a packet..
|
|
.rx:
|
|
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 EthReceiver ; send it to the kernel
|
|
|
|
.fail:
|
|
add esp, 14+8
|
|
.fail_2:
|
|
DEBUGF 2,"done\n"
|
|
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
|
|
|
|
mov ax, si
|
|
set_io P0_RSAR0
|
|
out dx, al
|
|
shr ax, 8
|
|
set_io P0_RSAR1
|
|
out dx, al
|
|
|
|
mov al, CMD_RD0 + CMD_STA
|
|
set_io 0
|
|
out dx, al
|
|
|
|
mov dx, [device.asic_base]
|
|
|
|
test [device.flags], FLAG_16BIT
|
|
jz epr_003
|
|
|
|
DEBUGF 1,"in 16-bits mode"
|
|
|
|
shr cx, 1 ; note that if the number was odd, carry flag will be set
|
|
pushf ; save the flags for later
|
|
|
|
epr_002:
|
|
in ax, dx
|
|
stosw
|
|
loopw epr_002
|
|
|
|
inc cx
|
|
popf
|
|
jnc epr_004
|
|
|
|
epr_003:
|
|
in al, dx
|
|
stosb
|
|
loopw epr_003
|
|
|
|
|
|
epr_004:
|
|
set_io 0
|
|
set_io P0_ISR
|
|
|
|
epr_005: ; Wait for Remote DMA Complete
|
|
in al, dx
|
|
test al, ISR_RDC
|
|
jz epr_005
|
|
; and al, not ISR_RDC
|
|
out dx, al ; clear the bit
|
|
|
|
|
|
DEBUGF 1,"\n"
|
|
ret
|
|
|
|
|
|
|
|
|
|
;***************************************************************************
|
|
; Function
|
|
; eth_pio_write
|
|
;
|
|
; Description
|
|
; writes a frame to the ethernet card via Programmed I/O
|
|
; dst in di
|
|
; cnt in cx
|
|
; src in esi
|
|
;***************************************************************************
|
|
eth_pio_write:
|
|
|
|
DEBUGF 1,"Eth PIO Write from %x to %x, %u bytes ",esi,di,cx
|
|
|
|
set_io 0
|
|
mov al, CMD_RD2 + CMD_STA
|
|
out dx, al
|
|
|
|
set_io P0_ISR
|
|
mov al, ISR_RDC
|
|
out dx, al
|
|
|
|
set_io P0_RBCR0
|
|
mov al, cl
|
|
out dx, al
|
|
|
|
set_io P0_RBCR1
|
|
mov al, ch
|
|
out dx, al
|
|
|
|
mov ax, di
|
|
set_io P0_RSAR0
|
|
out dx, al
|
|
shr ax, 8
|
|
set_io P0_RSAR1
|
|
out dx, al
|
|
|
|
set_io 0
|
|
mov al, CMD_RD1 + CMD_STA
|
|
out dx, al
|
|
|
|
mov dx, [device.asic_base]
|
|
test [device.flags], FLAG_16BIT
|
|
jz epw_003
|
|
|
|
DEBUGF 1,"in 16-bits mode"
|
|
|
|
shr cx, 1 ; note that if the number was odd, carry flag will be set
|
|
pushf ; save the flags for later
|
|
|
|
epw_002:
|
|
lodsw
|
|
out dx, ax
|
|
loopw epw_002
|
|
|
|
popf
|
|
jnc epw_004
|
|
inc cx
|
|
|
|
epw_003:
|
|
lodsb
|
|
out dx, al
|
|
loopw epw_003
|
|
|
|
epw_004:
|
|
set_io 0
|
|
set_io P0_ISR
|
|
|
|
epw_005: ; Wait for Remote DMA Complete
|
|
in al, dx
|
|
test al, ISR_RDC
|
|
jz epw_005
|
|
; and al, not ISR_RDC
|
|
out dx, al ; clear the bit
|
|
|
|
|
|
DEBUGF 1,"\n"
|
|
ret
|
|
|
|
|
|
|
|
;all initialized data place here
|
|
align 4
|
|
|
|
devices dd 0
|
|
version dd (DRIVER_VERSION shl 16) or (API_VERSION and 0xFFFF)
|
|
my_service db 'RTL8029/ne2000',0 ;max 16 chars include zero
|
|
|
|
device_1 db 'Realtek 8029',0
|
|
device_2 db 'Realtek 8019',0
|
|
device_3 db 'Realtek 8019AS',0
|
|
device_4 db 'ne2000',0
|
|
device_5 db 'DP8390',0
|
|
|
|
test_data db 'NE*000 memory',0
|
|
|
|
include_debug_strings
|
|
|
|
section '.data' data readable writable align 16 ;place all uninitialized data place here
|
|
|
|
device_list rd MAX_DEVICES
|
|
|
|
|
|
|
|
|
|
|