kolibrios-gitea/kernel/branches/net/drivers/pcnet32.asm
hidnplayr ce2dee6a2b Renaming exported function 'EthReceiver' to 'ETH_input'
git-svn-id: svn://kolibrios.org@2981 a494cfbc-eb01-0410-851d-a64ba20cac60
2012-10-07 14:23:05 +00:00

1468 lines
44 KiB
NASM

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;; PCnet driver for KolibriOS ;;
;; ;;
;; By hidnplayr & clevermouse ;;
;; ;;
;; Based on the PCnet32 driver for MenuetOS, by Jarek Pelczar ;;
;; ;;
;; GNU GENERAL PUBLIC LICENSE ;;
;; Version 2, June 1991 ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; $Revision$
format MS COFF
API_VERSION = 0x01000100
DEBUG = 1
__DEBUG__ = 1
__DEBUG_LEVEL__ = 1
MAX_DEVICES = 4
MAX_ETH_FRAME_SIZE = 1514
include 'proc32.inc'
include 'imports.inc'
include 'fdo.inc'
include 'netdrv.inc'
public START
public service_proc
public version
virtual at ebx
device:
ETH_DEVICE
; device specific
.private:
.mode_ dw ?
.tlen_rlen dw ?
.phys_addr dp ?
.reserved dw ?
.filter dq ?
.rx_ring_phys dd ?
.tx_ring_phys dd ?
.cur_rx db ?
.cur_tx db ?
.dirty_rx dd ?
.dirty_tx dd ?
.tx_full db ?
.options dd ?
.full_duplex db ?
.chip_version dd ?
.mii db ?
.ltint db ?
.dxsuflo db ?
.fset db ?
.fdx db ?
.rx_buffer dd ?
.tx_buffer dd ?
.io_addr dd ?
.irq_line db ?
.pci_bus db ?
.pci_dev db ?
.access_read_csr dd ?
.access_write_csr dd ?
.access_read_bcr dd ?
.access_write_bcr dd ?
.access_read_rap dd ?
.access_write_rap dd ?
.access_reset dd ?
device_size = $ - device
end virtual
struc buf_head {
.base dd ?
.length dw ?
.status dw ?
.msg_length dw ?
.misc dw ?
.reserved dd ?
.size:
}
virtual at 0
buf_head buf_head
end virtual
PCNET_PORT_AUI = 0x00
PCNET_PORT_10BT = 0x01
PCNET_PORT_GPSI = 0x02
PCNET_PORT_MII = 0x03
PCNET_PORT_PORTSEL = 0x03
PCNET_PORT_ASEL = 0x04
PCNET_PORT_100 = 0x40
PCNET_PORT_FD = 0x80
PCNET_DMA_MASK = 0xffffffff
PCNET_LOG_TX_BUFFERS = 2
PCNET_LOG_RX_BUFFERS = 2
PCNET_TX_RING_SIZE = 4
PCNET_TX_RING_MOD_MASK = (PCNET_TX_RING_SIZE-1)
PCNET_TX_RING_LEN_BITS = (PCNET_LOG_TX_BUFFERS shl 12)
PCNET_RX_RING_SIZE = 4
PCNET_RX_RING_MOD_MASK = (PCNET_RX_RING_SIZE-1)
PCNET_RX_RING_LEN_BITS = (PCNET_LOG_RX_BUFFERS shl 4)
PCNET_PKT_BUF_SZ = 1544
PCNET_PKT_BUF_SZ_NEG = 0xf9f8
PCNET_WIO_RDP = 0x10
PCNET_WIO_RAP = 0x12
PCNET_WIO_RESET = 0x14
PCNET_WIO_BDP = 0x16
PCNET_DWIO_RDP = 0x10
PCNET_DWIO_RAP = 0x14
PCNET_DWIO_RESET = 0x18
PCNET_DWIO_BDP = 0x1C
PCNET_TOTAL_SIZE = 0x20
; CSR registers
PCNET_CSR_CSR = 0x00
PCNET_CSR_IAB0 = 0x01
PCNET_CSR_IAB1 = 0x02
PCNET_CSR_IMR = 0x03
PCNET_CSR_TFEAT = 0x04
PCNET_CSR_EXTCTL1 = 0x05
PCNET_CSR_DTBLLEN = 0x06
PCNET_CSR_EXTCTL2 = 0x07
PCNET_CSR_MAR0 = 0x08
PCNET_CSR_MAR1 = 0x09
PCNET_CSR_MAR2 = 0x0A
PCNET_CSR_MAR3 = 0x0B
PCNET_CSR_PAR0 = 0x0C
PCNET_CSR_PAR1 = 0x0D
PCNET_CSR_PAR2 = 0x0E
PCNET_CSR_MODE = 0x0F
PCNET_CSR_RXADDR0 = 0x18
PCNET_CSR_RXADDR1 = 0x19
PCNET_CSR_TXADDR0 = 0x1E
PCNET_CSR_TXADDR1 = 0x1F
PCNET_CSR_TXPOLL = 0x2F
PCNET_CSR_RXPOLL = 0x31
PCNET_CSR_RXRINGLEN = 0x4C
PCNET_CSR_TXRINGLEN = 0x4E
PCNET_CSR_DMACTL = 0x50
PCNET_CSR_BUSTIMER = 0x52
PCNET_CSR_MEMERRTIMEO = 0x64
PCNET_CSR_ONNOWMISC = 0x74
PCNET_CSR_ADVFEAT = 0x7A
PCNET_CSR_MACCFG = 0x7D
PCNET_CSR_CHIPID0 = 0x58
PCNET_CSR_CHIPID1 = 0x59
; Control and Status Register (CSR0)
PCNET_CSR_INIT = 1 shl 0
PCNET_CSR_START = 1 shl 1
PCNET_CSR_STOP = 1 shl 2
PCNET_CSR_TX = 1 shl 3
PCNET_CSR_TXON = 1 shl 4
PCNET_CSR_RXON = 1 shl 5
PCNET_CSR_INTEN = 1 shl 6
PCNET_CSR_INTR = 1 shl 7
PCNET_CSR_IDONE = 1 shl 8
PCNET_CSR_TINT = 1 shl 9
PCNET_CSR_RINT = 1 shl 10
PCNET_CSR_MERR = 1 shl 11
PCNET_CSR_MISS = 1 shl 12
PCNET_CSR_CERR = 1 shl 13
; Interrupt masks and deferral control (CSR3)
PCNET_IMR_BSWAP = 0x0004
PCNET_IMR_ENMBA = 0x0008 ; enable modified backoff alg
PCNET_IMR_DXMT2PD = 0x0010
PCNET_IMR_LAPPEN = 0x0020 ; lookahead packet processing enb
PCNET_IMR_DXSUFLO = 0x0040 ; disable TX stop on underflow
PCNET_IMR_IDONE = 0x0100
PCNET_IMR_TINT = 0x0200
PCNET_IMR_RINT = 0x0400
PCNET_IMR_MERR = 0x0800
PCNET_IMR_MISS = 0x1000
PCNET_IMR = PCNET_IMR_TINT+PCNET_IMR_RINT+PCNET_IMR_IDONE+PCNET_IMR_MERR+PCNET_IMR_MISS
; Test and features control (CSR4)
PCNET_TFEAT_TXSTRTMASK = 0x0004
PCNET_TFEAT_TXSTRT = 0x0008
PCNET_TFEAT_RXCCOFLOWM = 0x0010 ; Rx collision counter oflow
PCNET_TFEAT_RXCCOFLOW = 0x0020
PCNET_TFEAT_UINT = 0x0040
PCNET_TFEAT_UINTREQ = 0x0080
PCNET_TFEAT_MISSOFLOWM = 0x0100
PCNET_TFEAT_MISSOFLOW = 0x0200
PCNET_TFEAT_STRIP_FCS = 0x0400
PCNET_TFEAT_PAD_TX = 0x0800
PCNET_TFEAT_TXDPOLL = 0x1000
PCNET_TFEAT_DMAPLUS = 0x4000
; Extended control and interrupt 1 (CSR5)
PCNET_EXTCTL1_SPND = 0x0001 ; suspend
PCNET_EXTCTL1_MPMODE = 0x0002 ; magic packet mode
PCNET_EXTCTL1_MPENB = 0x0004 ; magic packet enable
PCNET_EXTCTL1_MPINTEN = 0x0008 ; magic packet interrupt enable
PCNET_EXTCTL1_MPINT = 0x0010 ; magic packet interrupt
PCNET_EXTCTL1_MPPLBA = 0x0020 ; magic packet phys. logical bcast
PCNET_EXTCTL1_EXDEFEN = 0x0040 ; excessive deferral interrupt enb.
PCNET_EXTCTL1_EXDEF = 0x0080 ; excessive deferral interrupt
PCNET_EXTCTL1_SINTEN = 0x0400 ; system interrupt enable
PCNET_EXTCTL1_SINT = 0x0800 ; system interrupt
PCNET_EXTCTL1_LTINTEN = 0x4000 ; last TX interrupt enb
PCNET_EXTCTL1_TXOKINTD = 0x8000 ; TX OK interrupt disable
; RX/TX descriptor len (CSR6)
PCNET_DTBLLEN_RLEN = 0x0F00
PCNET_DTBLLEN_TLEN = 0xF000
; Extended control and interrupt 2 (CSR7)
PCNET_EXTCTL2_MIIPDTINTE = 0x0001
PCNET_EXTCTL2_MIIPDTINT = 0x0002
PCNET_EXTCTL2_MCCIINTE = 0x0004
PCNET_EXTCTL2_MCCIINT = 0x0008
PCNET_EXTCTL2_MCCINTE = 0x0010
PCNET_EXTCTL2_MCCINT = 0x0020
PCNET_EXTCTL2_MAPINTE = 0x0040
PCNET_EXTCTL2_MAPINT = 0x0080
PCNET_EXTCTL2_MREINTE = 0x0100
PCNET_EXTCTL2_MREINT = 0x0200
PCNET_EXTCTL2_STINTE = 0x0400
PCNET_EXTCTL2_STINT = 0x0800
PCNET_EXTCTL2_RXDPOLL = 0x1000
PCNET_EXTCTL2_RDMD = 0x2000
PCNET_EXTCTL2_RXFRTG = 0x4000
PCNET_EXTCTL2_FASTSPNDE = 0x8000
; Mode (CSR15)
PCNET_MODE_RXD = 0x0001 ; RX disable
PCNET_MODE_TXD = 0x0002 ; TX disable
PCNET_MODE_LOOP = 0x0004 ; loopback enable
PCNET_MODE_TXCRCD = 0x0008
PCNET_MODE_FORCECOLL = 0x0010
PCNET_MODE_RETRYD = 0x0020
PCNET_MODE_INTLOOP = 0x0040
PCNET_MODE_PORTSEL = 0x0180
PCNET_MODE_RXVPAD = 0x2000
PCNET_MODE_RXNOBROAD = 0x4000
PCNET_MODE_PROMISC = 0x8000
; BCR (Bus Control Registers)
PCNET_BCR_MMRA = 0x00 ; Master Mode Read Active
PCNET_BCR_MMW = 0x01 ; Master Mode Write Active
PCNET_BCR_MISCCFG = 0x02
PCNET_BCR_LED0 = 0x04
PCNET_BCR_LED1 = 0x05
PCNET_BCR_LED2 = 0x06
PCNET_BCR_LED3 = 0x07
PCNET_BCR_DUPLEX = 0x09
PCNET_BCR_BUSCTL = 0x12
PCNET_BCR_EECTL = 0x13
PCNET_BCR_SSTYLE = 0x14
PCNET_BCR_PCILAT = 0x16
PCNET_BCR_PCISUBVENID = 0x17
PCNET_BCR_PCISUBSYSID = 0x18
PCNET_BCR_SRAMSIZE = 0x19
PCNET_BCR_SRAMBOUND = 0x1A
PCNET_BCR_SRAMCTL = 0x1B
PCNET_BCR_MIICTL = 0x20
PCNET_BCR_MIIADDR = 0x21
PCNET_BCR_MIIDATA = 0x22
PCNET_BCR_PCIVENID = 0x23
PCNET_BCR_PCIPCAP = 0x24
PCNET_BCR_DATA0 = 0x25
PCNET_BCR_DATA1 = 0x26
PCNET_BCR_DATA2 = 0x27
PCNET_BCR_DATA3 = 0x28
PCNET_BCR_DATA4 = 0x29
PCNET_BCR_DATA5 = 0x2A
PCNET_BCR_DATA6 = 0x2B
PCNET_BCR_DATA7 = 0x2C
PCNET_BCR_ONNOWPAT0 = 0x2D
PCNET_BCR_ONNOWPAT1 = 0x2E
PCNET_BCR_ONNOWPAT2 = 0x2F
PCNET_BCR_PHYSEL = 0x31
; RX status register
PCNET_RXSTAT_BPE = 0x0080 ; bus parity error
PCNET_RXSTAT_ENP = 0x0100 ; end of packet
PCNET_RXSTAT_STP = 0x0200 ; start of packet
PCNET_RXSTAT_BUFF = 0x0400 ; buffer error
PCNET_RXSTAT_CRC = 0x0800 ; CRC error
PCNET_RXSTAT_OFLOW = 0x1000 ; rx overrun
PCNET_RXSTAT_FRAM = 0x2000 ; framing error
PCNET_RXSTAT_ERR = 0x4000 ; error summary
PCNET_RXSTAT_OWN = 0x8000
; TX status register
PCNET_TXSTAT_TRC = 0x0000000F ; transmit retries
PCNET_TXSTAT_RTRY = 0x04000000 ; retry
PCNET_TXSTAT_LCAR = 0x08000000 ; lost carrier
PCNET_TXSTAT_LCOL = 0x10000000 ; late collision
PCNET_TXSTAT_EXDEF = 0x20000000 ; excessive deferrals
PCNET_TXSTAT_UFLOW = 0x40000000 ; transmit underrun
PCNET_TXSTAT_BUFF = 0x80000000 ; buffer error
PCNET_TXCTL_OWN = 0x80000000
PCNET_TXCTL_ERR = 0x40000000 ; error summary
PCNET_TXCTL_ADD_FCS = 0x20000000 ; add FCS to pkt
PCNET_TXCTL_MORE_LTINT = 0x10000000
PCNET_TXCTL_ONE = 0x08000000
PCNET_TXCTL_DEF = 0x04000000
PCNET_TXCTL_STP = 0x02000000
PCNET_TXCTL_ENP = 0x01000000
PCNET_TXCTL_BPE = 0x00800000
PCNET_TXCTL_MBO = 0x0000F000
PCNET_TXCTL_BUFSZ = 0x00000FFF
section '.flat' code readable align 16
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; proc START ;;
;; ;;
;; (standard driver proc) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
proc START stdcall, state:dword
cmp [state], 1
jne .exit
.entry:
DEBUGF 1,"Loading PCnet driver\n"
stdcall RegService, my_service, service_proc
ret
.fail:
.exit:
xor eax, eax
ret
endp
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; proc SERVICE_PROC ;;
;; ;;
;; (standard driver 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 .fail
cmp [IOCTL.inp_size], 3 ; Data input must be at least 3 bytes
jl .fail
mov eax, [IOCTL.input]
cmp byte [eax], 1 ; 1 means device number and bus number (pci) are given
jne .fail ; other types arent supported for this card yet
; check if the device is already listed
mov ecx, [devices]
test ecx, ecx
jz .firstdevice
mov esi, device_list
; mov eax, [IOCTL.input] ; get the pci bus and device numbers
mov ax , [eax+1] ;
.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
; This device doesnt have its own eth_device structure yet, lets create one
.firstdevice:
cmp [devices], MAX_DEVICES ; First check if the driver can handle one more card
jge .fail
allocate_and_clear ebx, device_size, .fail
; Fill in the direct call addresses into the struct
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
; save the pci bus and device numbers
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]
DEBUGF 1,"Hooking into device, dev:%x, bus:%x, irq:%x, addr:%x\n",\
[device.pci_dev]:1,[device.pci_bus]:1,[device.irq_line]:1,[device.io_addr]:4
allocate_and_clear [device.tx_buffer], PCNET_RX_RING_SIZE * (PCNET_PKT_BUF_SZ + buf_head.size), .err
allocate_and_clear [device.rx_buffer], PCNET_TX_RING_SIZE * (PCNET_PKT_BUF_SZ + buf_head.size), .err
; Ok, the eth_device structure is ready, let's probe the device
; Because initialization fires IRQ, IRQ handler must be aware of this device
mov eax, [devices] ; Add the device structure to our device list
mov [device_list+4*eax], ebx ; (IRQ handler uses this list to find device)
inc [devices] ;
call probe ; this function will output in eax
test eax, eax
jnz .destroy ; If an error occured, exit
mov [device.type], NET_TYPE_ETH
call NetRegDev
cmp eax, -1
je .destroy
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
; If an error occured, remove all allocated data and exit (returning -1 in eax)
.destroy:
; todo: reset device into virgin state
dec [devices]
.err:
DEBUGF 1,"Error, removing all data !\n"
stdcall KernelFree, [device.rx_buffer]
stdcall KernelFree, [device.tx_buffer]
stdcall KernelFree, ebx
.fail:
or eax, -1
ret
;------------------------------------------------------
endp
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
;; ;;
;; Actual Hardware dependent code starts here ;;
;; ;;
;;/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\;;
align 4
unload:
; TODO: (in this particular order)
;
; - Stop the device
; - Detach int handler
; - Remove device from local list (RTL8139_LIST)
; - call unregister function in kernel
; - Remove all allocated structures and buffers the card used
or eax,-1
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; probe: enables the device (if it really is a PCnet device)
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 4
probe:
mov edx, [device.io_addr]
call wio_reset
xor ecx, ecx
call wio_read_csr
cmp eax, 4
jne .try_dwio
; Try Word I/O
mov ax , 88
add edx, PCNET_WIO_RAP
out dx , ax
nop
nop
in ax , dx
sub edx, PCNET_WIO_RAP
cmp ax , 88
jne .try_dwio
call switch_to_wio
jmp .L1
.try_dwio:
call dwio_reset
xor ecx, ecx
call dwio_read_csr
cmp eax, 4
jne .no_dev
; Try Dword I/O
add edx, PCNET_DWIO_RAP
mov eax, 88
out dx , eax
nop
nop
in eax, dx
sub edx, PCNET_DWIO_RAP
and eax, 0xffff
cmp eax, 88
jne .no_dev
call switch_to_dwio
jmp .L1
.no_dev:
DEBUGF 1,"PCnet device not found!\n"
mov eax, 1
ret
.L1:
mov ecx, PCNET_CSR_CHIPID0
call [device.access_read_csr]
mov esi, eax
mov ecx, PCNET_CSR_CHIPID1
call [device.access_read_csr]
shl eax, 16
or eax, esi
mov ecx, eax
and ecx, 0xfff
cmp ecx, 3
jne .no_dev
shr eax, 12
and eax, 0xffff
mov [device.chip_version], eax
DEBUGF 1,"chip version ok\n"
mov [device.fdx], 0
mov [device.mii], 0
mov [device.fset], 0
mov [device.dxsuflo], 0
mov [device.ltint], 0
cmp eax, 0x2420
je .L2
cmp eax, 0x2430
je .L2
mov [device.fdx], 1
cmp eax, 0x2621
je .L4
cmp eax, 0x2623
je .L5
cmp eax, 0x2624
je .L6
cmp eax, 0x2625
je .L7
cmp eax, 0x2626
je .L8
cmp eax, 0x2627
je .L9
DEBUGF 1,"Invalid chip rev\n"
jmp .no_dev
.L2:
mov [device.name], device_l2
jmp .L10
.L4:
mov [device.name], device_l4
; mov [device.fdx], 1
jmp .L10
.L5:
mov [device.name], device_l5
; mov [device.fdx], 1
mov [device.mii], 1
mov [device.fset], 1
mov [device.ltint], 1
jmp .L10
.L6:
mov [device.name], device_l6
; mov [device.fdx], 1
mov [device.mii], 1
mov [device.fset], 1
jmp .L10
.L7:
mov [device.name], device_l7
; mov [device.fdx], 1
mov [device.mii], 1
jmp .L10
.L8:
mov [device.name], device_l8
; mov [device.fdx], 1
mov ecx, PCNET_CSR_RXPOLL
call dword [device.access_read_bcr]
call dword [device.access_write_bcr]
jmp .L10
.L9:
mov [device.name], device_l9
; mov [device.fdx], 1
mov [device.mii], 1
.L10:
DEBUGF 1,"device name: %s\n",[device.name]
cmp [device.fset], 1
jne .L11
mov ecx, PCNET_BCR_BUSCTL
call [device.access_read_bcr]
or eax, 0x800
call [device.access_write_bcr]
mov ecx, PCNET_CSR_DMACTL
call [device.access_read_csr]
; and eax, 0xc00
; or eax, 0xc00
mov eax, 0xc00
call [device.access_write_csr]
mov [device.dxsuflo],1
mov [device.ltint],1
.L11:
make_bus_master [device.pci_bus], [device.pci_dev]
mov eax, PCNET_PORT_ASEL
mov [device.options], eax
mov [device.mode_], word 0x0003
mov [device.tlen_rlen], word (PCNET_TX_RING_LEN_BITS or PCNET_RX_RING_LEN_BITS)
mov dword [device.filter], 0
mov dword [device.filter+4], 0
mov eax, PCNET_IMR
mov ecx, PCNET_CSR_IMR ; Write interrupt mask
call [device.access_write_csr]
align 4
reset:
; 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
test eax, eax
jnz @f
DEBUGF 1,"\nCould not attach int handler!\n"
; or eax, -1
; ret
@@:
mov edx, [device.io_addr]
call [device.access_reset]
; Switch pcnet32 to 32bit mode
mov ecx, PCNET_BCR_SSTYLE
mov eax, 2
call [device.access_write_bcr]
; set/reset autoselect bit
mov ecx, PCNET_BCR_MISCCFG
call [device.access_read_bcr]
and eax,not 2
test [device.options], PCNET_PORT_ASEL
jz .L1
or eax, 2
.L1:
call [device.access_write_bcr]
; Handle full duplex setting
cmp byte [device.full_duplex], 0
je .L2
mov ecx, PCNET_BCR_DUPLEX
call [device.access_read_bcr]
and eax, not 3
test [device.options], PCNET_PORT_FD
jz .L3
or eax, 1
cmp [device.options], PCNET_PORT_FD or PCNET_PORT_AUI
jne .L4
or eax, 2
jmp .L4
.L3:
test [device.options], PCNET_PORT_ASEL
jz .L4
cmp [device.chip_version], 0x2627
jne .L4
or eax, 3
.L4:
mov ecx, PCNET_BCR_DUPLEX
call [device.access_write_bcr]
.L2:
; set/reset GPSI bit in test register
mov ecx, 124
call [device.access_read_csr]
mov ecx, [device.options]
and ecx, PCNET_PORT_PORTSEL
cmp ecx, PCNET_PORT_GPSI
jne .L5
or eax, 0x10
.L5:
call [device.access_write_csr]
cmp [device.mii], 0
je .L6
test [device.options], PCNET_PORT_ASEL
jnz .L6
mov ecx, PCNET_BCR_MIICTL
call [device.access_read_bcr]
and eax,not 0x38
test [device.options], PCNET_PORT_FD
jz .L7
or eax, 0x10
.L7:
test [device.options], PCNET_PORT_100
jz .L8
or eax, 0x08
.L8:
call [device.access_write_bcr]
jmp .L9
.L6:
test [device.options], PCNET_PORT_ASEL
jz .L9
mov ecx, PCNET_BCR_MIICTL
DEBUGF 1,"ASEL, enable auto-negotiation\n"
call [device.access_read_bcr]
and eax, not 0x98
or eax, 0x20
call [device.access_write_bcr]
.L9:
cmp [device.ltint],0
je .L10
mov ecx,5
call [device.access_read_csr]
or eax,(1 shl 14)
call [device.access_write_csr]
.L10:
mov eax,[device.options]
and eax,PCNET_PORT_PORTSEL
shl eax,7
mov [device.mode_],ax
mov dword [device.filter], -1
mov dword [device.filter+4], -1
call read_mac
lea esi, [device.mac]
lea edi, [device.phys_addr]
movsd
movsw
call init_ring
lea eax, [device.private]
GetRealAddr
push eax
and eax, 0xffff
mov ecx, 1
call [device.access_write_csr]
pop eax
shr eax,16
mov ecx,2
call [device.access_write_csr]
mov ecx,4
mov eax,0x0915
call [device.access_write_csr]
mov ecx,0
mov eax,1
call [device.access_write_csr]
mov [device.tx_full],0
mov [device.cur_rx],0
mov [device.cur_tx],0
mov [device.dirty_rx],0
mov [device.dirty_tx],0
mov ecx,100
.L11:
push ecx
xor ecx,ecx
call [device.access_read_csr]
pop ecx
test ax,0x100
jnz .L12
loop .L11
.L12:
DEBUGF 1,"hardware reset\n"
xor ecx, ecx
mov eax, 0x0002
call [device.access_write_csr]
xor ecx, ecx
call [device.access_read_csr]
xor ecx, ecx
mov eax, PCNET_CSR_INTEN or PCNET_CSR_START
call [device.access_write_csr]
; Set the mtu, kernel will be able to send now
mov [device.mtu], 1514
DEBUGF 1,"PCNET reset complete\n"
xor eax, eax
ret
align 4
init_ring:
mov ecx, PCNET_RX_RING_SIZE
mov edi, [device.rx_buffer]
mov eax, edi
GetRealAddr
mov [device.rx_ring_phys], eax
add eax, PCNET_RX_RING_SIZE * buf_head.size
.rx_init:
mov [edi + buf_head.base], eax
mov [edi + buf_head.length], PCNET_PKT_BUF_SZ_NEG
mov [edi + buf_head.status], 0x8000
and dword [edi + buf_head.msg_length], 0
and dword [edi + buf_head.reserved], 0
add eax, PCNET_PKT_BUF_SZ
add edi, buf_head.size
loop .rx_init
mov ecx, PCNET_TX_RING_SIZE
mov edi, [device.tx_buffer]
mov eax, edi
GetRealAddr
mov [device.tx_ring_phys], eax
add eax, PCNET_TX_RING_SIZE * buf_head.size
.tx_init:
mov [edi + buf_head.base], eax
and dword [edi + buf_head.length], 0
and dword [edi + buf_head.msg_length], 0
and dword [edi + buf_head.reserved], 0
add eax, PCNET_PKT_BUF_SZ
add edi, buf_head.size
loop .tx_init
mov [device.tlen_rlen], (PCNET_TX_RING_LEN_BITS or PCNET_RX_RING_LEN_BITS)
ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Transmit ;;
;; ;;
;; In: buffer pointer in [esp+4] ;;
;; size of buffer in [esp+8] ;;
;; pointer to device structure in ebx ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
align 4
transmit:
DEBUGF 1,"Transmitting packet, buffer:%x, size:%u\n",[esp+4],[esp+8]
mov eax, [esp+4]
DEBUGF 1,"To: %x-%x-%x-%x-%x-%x From: %x-%x-%x-%x-%x-%x Type:%x%x\n",\
[eax+00]:2,[eax+01]:2,[eax+02]:2,[eax+03]:2,[eax+04]:2,[eax+05]:2,\
[eax+06]:2,[eax+07]:2,[eax+08]:2,[eax+09]:2,[eax+10]:2,[eax+11]:2,\
[eax+13]:2,[eax+12]:2
cmp dword [esp+8], 1514
jg .nospace ; packet is too long
cmp dword [esp+8], 60
jl .nospace ; packet is too short
; check descriptor
movzx eax, [device.cur_tx]
imul edi, eax, PCNET_PKT_BUF_SZ
shl eax, 4
add eax, [device.tx_buffer]
add edi, [device.tx_buffer]
add edi, PCNET_TX_RING_SIZE * buf_head.size
test byte [eax + buf_head.status + 1], 80h
jnz .nospace
; descriptor is free, copy data
mov esi, [esp+4]
mov ecx, [esp+8]
mov edx, ecx
shr ecx, 2
and edx, 3
rep movsd
mov ecx, edx
rep movsb
; set length
mov ecx, [esp+8]
neg ecx
mov [eax + buf_head.length], cx
; put to transfer queue
mov [eax + buf_head.status], 0x8300
; trigger an immediate send
xor ecx, ecx ; CSR0
call [device.access_read_csr]
or eax, PCNET_CSR_TX
call [device.access_write_csr]
; get next descriptor 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, ...
inc [device.cur_tx]
and [device.cur_tx], 3
DEBUGF 2," - Packet Sent! "
; Update stats
inc [device.packets_tx]
mov eax, [esp+8]
add dword [device.bytes_tx], eax
adc dword [device.bytes_tx + 4], 0
.finish:
DEBUGF 2," - Done!\n"
stdcall KernelFree, [esp+4]
xor eax, eax
ret 8
.nospace:
DEBUGF 1, 'ERROR: no free transmit descriptors\n'
stdcall KernelFree, [esp+4]
or eax, -1
ret 8
;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Interrupt handler ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;
align 4
int_handler:
DEBUGF 1,"\n%s int\n", my_service
; find pointer of device wich made IRQ occur
mov ecx, [devices]
test ecx, ecx
jz .nothing
mov esi, device_list
.nextdevice:
mov ebx, [esi]
mov edx, [device.io_addr] ; get IRQ reason
push ecx
xor ecx, ecx ; CSR0
call [device.access_read_csr]
pop ecx
test al, al
js .got_it
.continue:
add esi, 4
dec ecx
jnz .nextdevice
.nothing:
ret ; If no device was found, abort (The irq was probably for a device, not registered to this driver
.got_it:
DEBUGF 1,"Device: %x Status: %x ", ebx, eax:2
;-------------------------------------------------------
; Possible reasons:
; initialization done - ignore
; transmit done - ignore
; packet received - handle
; Clear ALL IRQ reasons.
; N.B. One who wants to handle more than one reason must be ready
; to two or more reasons in one IRQ.
xor ecx, ecx
call [device.access_write_csr]
; Received packet ok?
test ax, PCNET_CSR_RINT
jz @f
push ebx
.receiver_test_loop:
pop ebx
movzx eax, [device.cur_rx]
; and eax, PCNET_RX_RING_MOD_MASK
mov edi, eax
imul esi, eax, PCNET_PKT_BUF_SZ ;
add esi, [device.rx_buffer] ; esi now points to rx buffer
add esi, PCNET_RX_RING_SIZE * buf_head.size
shl edi, 4 ; desc * 16 (16 is size of one ring entry)
add edi, [device.rx_buffer] ; edi now points to current rx ring entry
mov cx , [edi + buf_head.status]
test cx , PCNET_RXSTAT_OWN ; If this bit is set, the controller OWN's the packet, if not, we do
jnz .abort
test cx , PCNET_RXSTAT_ENP
jz .abort
test cx , PCNET_RXSTAT_STP
jz .abort
movzx ecx, [edi + buf_head.msg_length] ; get packet length in ecx
sub ecx, 4 ;
push ecx
stdcall KernelAlloc, ecx ; Allocate a buffer to put packet into
pop ecx
test eax, eax ; Test if we allocated succesfully
jz .abort ;
; Update stats
add dword [device.bytes_rx], ecx
adc dword [device.bytes_rx + 4], 0
inc dword [device.packets_rx]
push ebx
push .receiver_test_loop ;
push ecx ; for eth_receiver
push eax ;
xchg edi, eax
push ecx
shr ecx, 2
cld
rep movsd
pop ecx
and ecx, 3
rep movsb
; mov word [eax + buf_head.length], PCNET_PKT_BUF_SZ_NEG
mov word [eax + buf_head.status], PCNET_RXSTAT_OWN ; Set OWN bit back to 1 (controller may write to tx-buffer again now)
inc [device.cur_rx] ; update descriptor
and [device.cur_rx], 3 ;
jmp Eth_input
.abort:
@@:
ret
;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Write MAC address ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;
align 4
write_mac: ; in: mac pushed onto stack (as 3 words)
DEBUGF 1,"Writing MAC: %x-%x-%x-%x-%x-%x",[esp+0]:2,[esp+1]:2,[esp+2]:2,[esp+3]:2,[esp+4]:2,[esp+5]:2
mov edx, [device.io_addr]
add dx, 2
xor eax, eax
mov ecx, PCNET_CSR_PAR0
@@:
pop ax
call [device.access_write_csr]
DEBUGF 1,"."
inc ecx
cmp ecx, PCNET_CSR_PAR2
jl @r
DEBUGF 1,"\n"
; Notice this procedure does not ret, but continues to read_mac instead.
;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Read MAC address ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;
align 4
read_mac:
DEBUGF 1,"Reading MAC"
mov edx, [device.io_addr]
add dx, 6
@@:
dec dx
dec dx
in ax, dx
push ax
DEBUGF 1,"."
cmp edx, [device.io_addr]
jg @r
DEBUGF 1," %x-%x-%x-%x-%x-%x\n",[esp+0]:2,[esp+1]:2,[esp+2]:2,[esp+3]:2,[esp+4]:2,[esp+5]:2
lea edi, [device.mac]
pop ax
stosw
pop ax
stosw
pop ax
stosw
ret
align 4
switch_to_wio:
DEBUGF 1,"Switching to 16-bit mode\n"
mov [device.access_read_csr], wio_read_csr
mov [device.access_write_csr], wio_write_csr
mov [device.access_read_bcr], wio_read_bcr
mov [device.access_write_bcr], wio_write_bcr
mov [device.access_read_rap], wio_read_rap
mov [device.access_write_rap], wio_write_rap
mov [device.access_reset], wio_reset
ret
align 4
switch_to_dwio:
DEBUGF 1,"Switching to 32-bit mode\n"
mov [device.access_read_csr], dwio_read_csr
mov [device.access_write_csr], dwio_write_csr
mov [device.access_read_bcr], dwio_read_bcr
mov [device.access_write_bcr], dwio_write_bcr
mov [device.access_read_rap], dwio_read_rap
mov [device.access_write_rap], dwio_write_rap
mov [device.access_reset], dwio_reset
ret
; ecx - index
; return:
; eax - data
align 4
wio_read_csr:
add edx, PCNET_WIO_RAP
mov ax , cx
out dx , ax
add edx, PCNET_WIO_RDP - PCNET_WIO_RAP
in ax , dx
and eax, 0xffff
sub edx, PCNET_WIO_RDP
ret
; eax - data
; ecx - index
align 4
wio_write_csr:
add edx, PCNET_WIO_RAP
xchg eax, ecx
out dx , ax
xchg eax, ecx
add edx, PCNET_WIO_RDP - PCNET_WIO_RAP
out dx , ax
sub edx, PCNET_WIO_RDP
ret
; ecx - index
; return:
; eax - data
align 4
wio_read_bcr:
add edx, PCNET_WIO_RAP
mov ax , cx
out dx , ax
add edx, PCNET_WIO_BDP - PCNET_WIO_RAP
in ax , dx
and eax, 0xffff
sub edx, PCNET_WIO_BDP
ret
; eax - data
; ecx - index
align 4
wio_write_bcr:
add edx, PCNET_WIO_RAP
xchg eax, ecx
out dx , ax
xchg eax, ecx
add edx, PCNET_WIO_BDP - PCNET_WIO_RAP
out dx , ax
sub edx, PCNET_WIO_BDP
ret
align 4
wio_read_rap:
add edx, PCNET_WIO_RAP
in ax , dx
and eax, 0xffff
sub edx, PCNET_WIO_RAP
ret
; eax - val
align 4
wio_write_rap:
add edx, PCNET_WIO_RAP
out dx , ax
sub edx, PCNET_WIO_RAP
ret
align 4
wio_reset:
push eax
add edx, PCNET_WIO_RESET
in ax , dx
pop eax
sub edx, PCNET_WIO_RESET
ret
; ecx - index
; return:
; eax - data
align 4
dwio_read_csr:
add edx, PCNET_DWIO_RAP
mov eax, ecx
out dx , eax
add edx, PCNET_DWIO_RDP - PCNET_DWIO_RAP
in eax, dx
and eax, 0xffff
sub edx, PCNET_DWIO_RDP
ret
; ecx - index
; eax - data
align 4
dwio_write_csr:
add edx, PCNET_DWIO_RAP
xchg eax, ecx
out dx , eax
add edx, PCNET_DWIO_RDP - PCNET_DWIO_RAP
xchg eax, ecx
out dx , eax
sub edx, PCNET_DWIO_RDP
ret
; ecx - index
; return:
; eax - data
align 4
dwio_read_bcr:
add edx, PCNET_DWIO_RAP
mov eax, ecx
out dx , eax
add edx, PCNET_DWIO_BDP - PCNET_DWIO_RAP
in eax, dx
and eax, 0xffff
sub edx, PCNET_DWIO_BDP
ret
; ecx - index
; eax - data
align 4
dwio_write_bcr:
add edx, PCNET_DWIO_RAP
xchg eax, ecx
out dx , eax
add edx, PCNET_DWIO_BDP - PCNET_DWIO_RAP
xchg eax, ecx
out dx , eax
sub edx, PCNET_DWIO_BDP
ret
align 4
dwio_read_rap:
add edx, PCNET_DWIO_RAP
in eax, dx
and eax, 0xffff
sub edx, PCNET_DWIO_RAP
ret
; eax - val
align 4
dwio_write_rap:
add edx, PCNET_DWIO_RAP
out dx , eax
sub edx, PCNET_DWIO_RAP
ret
align 4
dwio_reset:
push eax
add edx, PCNET_DWIO_RESET
in eax, dx
pop eax
sub edx, PCNET_DWIO_RESET
ret
; End of code
align 4 ; Place all initialised data here
devices dd 0
version dd (5 shl 16) or (API_VERSION and 0xFFFF)
my_service db 'PCnet',0 ; max 16 chars include zero
device_l2 db "PCnet/PCI 79C970",0
device_l4 db "PCnet/PCI II 79C970A",0
device_l5 db "PCnet/FAST 79C971",0
device_l6 db "PCnet/FAST+ 79C972",0
device_l7 db "PCnet/FAST III 79C973",0
device_l8 db "PCnet/Home 79C978",0
device_l9 db "PCnet/FAST III 79C975",0
options_mapping:
dd PCNET_PORT_ASEL ; 0 Auto-select
dd PCNET_PORT_AUI ; 1 BNC/AUI
dd PCNET_PORT_AUI ; 2 AUI/BNC
dd PCNET_PORT_ASEL ; 3 not supported
dd PCNET_PORT_10BT or PCNET_PORT_FD ; 4 10baseT-FD
dd PCNET_PORT_ASEL ; 5 not supported
dd PCNET_PORT_ASEL ; 6 not supported
dd PCNET_PORT_ASEL ; 7 not supported
dd PCNET_PORT_ASEL ; 8 not supported
dd PCNET_PORT_MII ; 9 MII 10baseT
dd PCNET_PORT_MII or PCNET_PORT_FD ; 10 MII 10baseT-FD
dd PCNET_PORT_MII ; 11 MII (autosel)
dd PCNET_PORT_10BT ; 12 10BaseT
dd PCNET_PORT_MII or PCNET_PORT_100 ; 13 MII 100BaseTx
dd PCNET_PORT_MII or PCNET_PORT_100 or PCNET_PORT_FD ; 14 MII 100BaseTx-FD
dd PCNET_PORT_ASEL ; 15 not supported
include_debug_strings ; All data wich FDO uses will be included here
section '.data' data readable writable align 16 ; place all uninitialized data place here
device_list rd MAX_DEVICES ; This list contains all pointers to device structures the driver is handling