Category : Network Files
Archive   : PKTD11A.ZIP
Filename : CTRONDNI.ASM

version equ 1

include defs.asm

; Packet driver for Cabletron DNI Exxxx series cards.
; Portions Copyright 1992-1993 Kai Getrost.
;
; Since I have no official programming info on the DNI cards, nor do I
; have a Microchannel version of the card, this driver doesn't work on
; an MCA bus (to my knowledge). There's code in here to do stuff when
; running on an MCA bus, but most of it is guesswork. To enable it,
; uncomment the MCA_STUFF define below, and move the 6 lines of code
; before "include 8390.asm" to the head of recv in 8390.asm.
; -KNG 930924
;
; Define for MCA code:
;MCA_STUFF equ 1

;For brain-dead assemblers:
REP_INSB equ db 0f3h, 06ch
REP_INSW equ db 0f3h, 06dh
REP_OUTSB equ db 0f3h, 06eh
REP_OUTSW equ db 0f3h, 06fh


EN_OFF equ 0
CT_DATAPORT equ 10h ; data transfer port
SM_TSTART_PG equ 1
SM_RSTART_PG equ 9
SM_RSTOP_PG equ 20h ; 40h on MCA cards
TEST_VAL equ 1234h

include 8390.inc

;This used to be in 8390.asm:
pause_ macro
push ax
in al, 61h ;use al, not ax!
pop ax
endm

reset_8390 macro
local foo
loadport
setport EN_CCMD
mov al, ENC_STOP
pause_
out dx, al
mov cx, 80h
foo:
pause_
loop foo
endm

terminate_board macro
mov dh, CANT_TERMINATE
stc
endm


code segment word public
assume cs:code, ds:code

public int_no, io_addr
int_no db 3, 0, 0, 0 ;IRQ #; must be dword for get_number
io_addr dw 300h, 0 ;IO port to use

public driver_class, driver_type, driver_name, driver_function, parameter_list
driver_class db BLUEBOOK, IEEE8023, 0 ;from the packet spec
driver_type db 51 ;from Cabletron's driver
driver_name db "Cabletron DNI", 0 ;name of the driver.
driver_function db 2 ;2 = basic/extended
parameter_list label byte
db 1 ;major rev of packet driver
db 9 ;minor rev of packet driver
db 14 ;length of parameter list
db EADDR_LEN ;length of MAC-layer address
dw GIANT ;MTU, including MAC headers
dw MAX_MULTICAST * EADDR_LEN ;buffer size of multicast addrs
dw 0 ;(# of back-to-back MTU rcvs) - 1
dw 0 ;(# of successive xmits) - 1
int_num dw 0 ;Interrupt # to hook for post-EOI
;processing, 0 == none

is_16bit db 0 ;set to 1 if 16 bit card
out_jmp dw out_88 ;block_output method
in_jmp dw in_88 ;block_input method
shmem_seg dw ? ;shared memory segment


extrn sys_features: byte
extrn is_186: byte

public block_input
;enter with AX = board address, CX = count, ES:DI -> buffer to copy to
;buffer-wraparound added 920901 -kng
block_input:
assume ds:nothing ; force CS overrides for data refs

;First check for buffer wraparound:
mov si, ax ;save start page
add ax, cx ;compute end of this frame
mov dh, cs:sm_rstop_ptr
or dh, dh
jz in_okcpy ;no mem, ok to copy (?)
xor dl, dl
cmp ax, dx ;is it beyond end of buffer?
jbe in_okcpy ;jump if not

;Frame is wrapped around; do copy in 2 parts:
push cx ;save total length
mov cx, dx
sub cx, si ;get length of first part
push cx ;save it
call get_block
pop bx
pop cx
sub cx, bx ;get length of second part
mov si, SM_RSTART_PG*256 + 0
in_okcpy:
call get_block
ret

;Copy contiguous block of data. SI = page, CX = len, ES:DI = buffer
;From ne1000.asm, modified (shared mem added for MCA cards).
get_block:
cld ; set right direction
ifdef MCA_STUFF
test sys_features, SYS_MCA
jnz in_mem
endif
loadport
setport EN_CCMD
pause_
mov al, ENC_NODMA + ENC_PAGE0 + ENC_START
out dx, al

mov ax, cx ;get the count to be output.
setport EN0_RCNTLO ; remote byte count 0
pause_
out dx, al
setport EN0_RCNTHI
pause_
mov al, ah
out dx, al

mov ax, si ; get our page back
setport EN0_RSARLO
pause_
out dx, al ; set as hi address
setport EN0_RSARHI
pause_
mov al, ah
out dx, al

setport EN_CCMD
pause_
mov al, ENC_RREAD + ENC_START ; read and start
out dx, al
setport CT_DATAPORT
pause_

jmp [in_jmp] ; do the copy

in_88: ; Default, use 8088 I/O
in al, dx ; get a byte
stosb ; save it
loop in_88
ret

in_186: ; Use 80[123]86 I/O
REP_INSB
ret

in_16bit: ; Use 16 bit I/O
inc cx
shr cx, 1 ; round up to nearest word count
REP_INSW
ret

ifdef MCA_STUFF
in_mem: ; Copy from shared memory
push ds
mov ds, shmem_seg
inc cx
shr cx, 1
rep movsw
pop ds
endif

ret


public block_output
;enter with AX = board address, CX = length, DS:SI -> buffer
;From ne1000.asm, modified for shared mem.
block_output:
assume ds:nothing

cld
ifdef MCA_STUFF
test sys_features, SYS_MCA
jnz out_mem
endif
push ax ; save buffer address
inc cx ; make even
and cx, 0fffeh
loadport
setport EN_CCMD
pause_
mov al, ENC_NODMA + ENC_START
out dx, al ; stop & clear the chip

;There's some funkiness to remote DMA writes under certain conditions,
;according to the National DP8390 Datasheet Addendum and comments in
;the hppclan driver. A description and solution to the problem, from
;Glenn Talbott's additions to hppclan.asm, are reproduced here. -KNG

;; To quote from the National DP8390 Datasheet Addendum, June 1990
;;
;; 11.0 Remote DMA Write
;;
;; Under certain conditions the NIC may issue /MWR and /PRD before
;; PRQ for the first DMA transfer. This causes an extraneous byte to be
;; written inot memory at the first Remote DMA Write location. [...]
;;
;; To prevent this condition, write a non-zero value into RBCR0 and
;; issued [sic] the Remote Read DMA command to the NIC (CR=0AH), but
;; do not give any Read Acknowledges (/RACK). (This causes PRQ to go high.)
;; Then write the desired byte count into RBCR0 and RBCR1 and give the
;; Remote Write DMA command (CR=12H). The Remote Write DMA will operate as
;; normal.
;;
;; My interpretation of the above is - gft - 910603

setport EN0_RCNTLO ; remote byte count 0
pause_
mov al,0ffh ; a non-zero value
out dx,al
setport EN_CCMD
pause_
mov al,ENC_RREAD+ENC_START ; read and start
out dx,al ; starts the read setting PRQ for the first
; DMA transfer, now reprogram everything
; and start a write instead.

;; BUT WHAT THE NATIONAL DOCUMENTATION DOESN'T TELL YOU ...
;;
;; When the read is started, the remote byte count register is decremented
;; (in this case from 0ffh to 0feh). This takes a finite amount of time.
;; IF you are TOO QUICK in re-programming the remote byte count 0 register
;; to the correct value, the NEW VALUE GETS DECREMENTED INSTEAD! Then when
;; you reach the last byte of the buffer and you output it to the IO port,
;; the NIC has already reached a count of zero and WON'T HANDSHAKE THE LAST
;; BYTE!. Result, computer HUNG, powercycle to recover. Therefore a stall is
;; required here, I use at least 1.5uS
;; - gft - 910603
;;
in al,61h ; read from NMI Status register for IO delay
in al,61h ; ~ 0.5uS on Microchannel and ~ 1.0 on ISA
in al,61h ; for a total of ~1.5uS or 3.0uS.

;Now the rest of block_output: -KNG 921208

setport EN0_RCNTLO ; remote byte count 0
pause_
mov al, cl
out dx, al
setport EN0_RCNTHI
pause_
mov al, ch
out dx, al

pop ax ; get our page back
setport EN0_RSARLO
pause_
out dx, al ; set as lo address
setport EN0_RSARHI
pause_
mov al, ah
out dx, al

setport EN_CCMD
pause_
mov al, ENC_RWRITE + ENC_START ; write and start
out dx, al
setport CT_DATAPORT
pause_

jmp [out_jmp] ; do the copy

out_88: ; Default: loop for 8088/8086
lodsb
out dx, al
loop out_88
jmp short block_out_1

out_186: ; Use 80[123]86 I/O
REP_OUTSB
jmp short block_out_1

out_16bit: ; Use 16 bit I/O
inc cx
shr cx, 1 ; convert to word count
REP_OUTSW
jmp short block_out_1

ifdef MCA_STUFF
out_mem: ; Copy to shared mem
push es
mov es, shmem_seg
inc cx
shr cx, 1
rep movsw
pop es
endif

block_out_1:
mov cx, 0
setport EN0_ISR
tx_check_rdc:
in al, dx
test al, ENISR_RDC ; dma done ?
jnz tx_start ; jump if so
loop tx_check_rdc ; otherwise loop
stc
ret
tx_start:
clc
ret


; The following 6 lines seem to be needed at the start of the recv
; routine in 8390.asm, for PS/2s. -KNG 930924
ifdef MCA_STUFF
xxxxxx Move to start of recv in 8390.asm: xxxxxx
test sys_features, SYS_MCA
jz check_isr
loadport
setport 23h
mov al, 4
out dx, al
endif

include 8390.asm


int_no_list db 3, 7, 9 ; IRQ list for MCA
out_jmp_list dw out_88, out_186, out_16bit
in_jmp_list dw in_88, in_186, in_16bit
slot_no db 0 ; BIOS slot number
tmp_pag db 0 ; used in do_test
testbyte db 0 ; used in test_mem

BUF_SIZ equ 100h
buf db BUF_SIZ dup(?) ; used for diags in test_mem

EOM equ CR, LF, '$'
public usage_msg
usage_msg db "Usage: ctrondni [options] ", EOM

public copyright_msg
copyright_msg db "Packet driver for Cabletron DNI cards, version "
db '0'+(majver / 10),'0'+(majver mod 10),".",'0'+version,".",'0'+dp8390_version,CR,LF
db "Portions Copyright 1992-1993, Kai Getrost", EOM

cant_find_msg db "** Can't find Ethernet controller **", EOM
mem_failed_msg db "** Board memory test failed **", EOM
mem_msg db "; mem size in kb is ", '$'
bus_msg db "Bus is ", '$'
bus_8_msg db "8 bit", '$'
bus_16_msg db "16 bit", '$'
ifdef MCA_STUFF
bus_MCA_msg db "microchannel", '$'
else
no_MCA_msg db "Microchannel bus unsupported", EOM
endif
int_no_msg db "Interrupt number ", '$'
ioaddr_msg db "I/O address ", '$'


extrn set_recv_isr: near
extrn get_number: near
extrn print_number: near
extrn decout: near

public parse_args
parse_args:
;Exit with cy if error, nc if OK. Reads IRQ, IO port numbers.

mov di, offset int_no
call get_number ;read IRQ number
jc parse_err ;jump if error
mov di, offset io_addr
call get_number ;read I/O address
jc parse_err
clc ;no error
ret
parse_err:
stc ;error
ret


public init_card
init_card:
;Returns with nc if ok; cy if error. Determines bus/mem size, tests mem,
;reads Ethernet address, etc.

test sys_features, SYS_MCA
jz init_1 ;jump if not MCA
ifdef MCA_STUFF
call do_MCA_stuff
jb init_err
jmp init_2
else
; Microchannel bus detected, but no MCA code:
mov dx, offset no_MCA_msg
stc
jmp init_err
endif

init_1:
call get_bus_size ;get bus size (if not MCA)
init_2:

init_3:
;Set block_input/output mode (8-bit loop, 8-bit 80186 I/O, 16-bit 80186)
;MCA is not checked since block_output/input checks it
xor bx, bx
cmp is_186, 0
jz init_cont
inc bx
cmp is_16bit, 0
jz init_cont
inc bx
init_cont:
shl bx, 1 ;offsets are words
mov ax, out_jmp_list[bx]
mov out_jmp, ax
mov ax, in_jmp_list[bx]
mov in_jmp, ax

call read_address ;get Ethernet address
ifdef MCA_STUFF
test sys_features, SYS_MCA
jnz init_5 ;jump if MCA; we know mem size
endif
call get_mem_size
init_5:
call test_mem ;test board memory
jb init_err

clc ;no error return
ret
init_err:
mov ah, 9
int 21h ;print error msg
stc ;error return
ret


public print_parameters
;Prints command line parameters, bus/mem info.
print_parameters:

mov ah, 9
mov dx, offset bus_msg
int 21h

;print bus size:
mov dx, offset bus_8_msg
ifdef MCA_STUFF
test sys_features, SYS_MCA
jz pr_not_MCA
mov dx, offset bus_MCA_msg
jmp pr_bus
endif
pr_not_MCA:
cmp is_16bit, 0
jz pr_bus
mov dx, offset bus_16_msg
pr_bus:
mov ah, 9
int 21h

mov al, cs:sm_rstop_ptr ;
add al, 3 ;
shr al, 1 ; calculate memory size in Kb =
shr al, 1 ; (sm_rstop_ptr + 3) / 4
xor ah, ah ;
mov word ptr buf, ax ;
mov dx, offset mem_msg
mov di, offset buf
call print_number ;print mem size

mov dx, offset int_no_msg
mov di, offset int_no
call print_number ;print int_no
mov dx, offset ioaddr_msg
mov di, offset io_addr
call print_number ; and IO port

ret


read_address:
;Gets board address into rom_address. From ne1000.asm init_card,
;modified. Board data is 16 bytes starting at remote dma address 0.
;Put it in a buffer called board_data.
assume ds:code

mov cx, 10h ; get 16 bytes,
push ds
pop es ; set es to ds
mov di, offset board_data
mov si, 0 ; from address 0
call get_block

push ds ; Copy to current address:
pop es
mov si, offset board_data ; address is at start of board_data
mov di, offset rom_address
mov cx, EADDR_LEN ; one address length
cld
rep movsb

ret ;Cabletron checks if address starts w/00:00:1D; we don't care


ifdef MCA_STUFF
do_MCA_stuff:
;Called only if microchannel card. Returns CY, DX = error msg if error.
;I don't really know what this does...

cli
mov dx, 100h
mov al, slot_no
or al, al
jz dm_check
dec al
or al, 8
out 96h, al ;select MCA channel ?
inc dx
pause_
in al, dx
mov ah, al
dec dx
pause_
in al, dx
cmp ah, 56h
je dm_cont
jmp dm_cantfind

dm_check:
mov cx, 8
mov bl, 8
dm_loop:
mov al, bl
out 96h, al
inc dx
pause_
in al, dx
mov ah, al
dec dx
pause_
in al, dx
cmp ah, 56h
je dm_cont
inc bl
loop dm_loop

dm_cantfind:
xor al, al
out 96h, al
sti
mov dx, offset cant_find_msg
stc ;error
ret

dm_cont:
mov sm_rstop_ptr, 0
test al, 1
jnz dm_1
mov sm_rstop_ptr, 40h ;16K board mem
dm_1:
mov dx, 102h
mov al, 81h
out dx, al
inc dx
in al, dx
mov bl, al
inc dx
in al, dx
mov bh, al
xor al, al
out 96h, al
sti

mov endcfg, ENDCFG_FT10 + ENDCFG_BMS + ENDCFG_WTS ;word transfer
mov ah, bl
and ah, 0f0h
mov cl, 2
shr ah, cl
or ax, 0c000h
mov shmem_seg, ax
mov ah, bl
and ah, 0eh
mov cl, 3
shl ax, cl
or ax, 300h
mov io_addr, ax ;set IO address

loadport
setport EN0_IMR
xor al, al
pause_
out dx, al
setport EN0_ISR
pause_
out dx, al
mov bl, bh
and bx, 3
mov al, int_no_list[bx]
mov int_no, al ;set IRQ

;PIC stuff was here

setport 20h
mov al, 12h
out dx, al
setport 23h
mov al, 7ch
out dx, al
setport 22h
mov al, 4
out dx, al
clc
ret
endif


get_bus_size:
;Determines bus size. Not called on MCA cards; they use shared mem.
;If 16 bit bus, sets endcfg to ENDCFG_WTS (word transfer mode), is_16bit to 1

loadport
setport EN0_RSARLO
mov ax, 100h
pause_
out dx, al
setport EN0_RSARHI
pause_
mov al, ah ;Cabletron bug: does AL -> DX, not AH
out dx, al

setport EN0_RCNTLO
mov ax, 40h
pause_
out dx, al
setport EN0_RCNTHI
mov al, ah
pause_
out dx, al

setport EN_CCMD
mov al, ENC_RWRITE + ENC_START
pause_
out dx, al

xor cx, cx
setport EN0_CRDALO
pause_
in al, dx
or al, al
jnz gbs_1

gbs_2:
loadport
setport CT_DATAPORT
pause_
out dx, ax ;should this be AL instead of AX?

gbs_1:
inc cx
loadport
setport EN0_CRDALO
pause_
in al, dx
cmp al, 40h
jne gbs_2

setport EN_CCMD
mov al, ENC_NODMA + ENC_START
pause_
out dx, al
setport EN0_ISR
mov al, 0ffh
out dx, al

cmp cx, 30h
jb gbs_ret ; jump if 8-bit bus
or endcfg, ENDCFG_WTS ; use word transfer
mov is_16bit, 1

gbs_ret:
ret


get_mem_size:
;Determines size of on-board memory.
;Call only if not MCA (do_MCA_stuff determines mem size on MCA).

;Write 0's to first word of all possible pages (1-255):
mov tmp_pag, 1
mov word ptr buf, 0
gms_2:
mov si, offset buf
mov ah, tmp_pag
xor al, al
mov cx, 2
call block_output
inc tmp_pag
jnz gms_2

;Write TEST_VAL to first word of page 1:
mov si, offset buf
mov [si], TEST_VAL
mov ax, 100h
mov cx, 2
call block_output

;Starting at page 11h, look for TEST_VAL every 10h pages (4kb). Page found
;(rounded to 4kb) is on-board mem size:
mov tmp_pag, 11h
gms_3:
mov ah, tmp_pag
xor al, al
mov si, ax
mov di, offset buf
mov cx, 2
call get_block
cmp word ptr buf, TEST_VAL
je gms_1
add tmp_pag, 10h
jnb gms_3

gms_1:
mov al, tmp_pag
and al, 0f0h ;trunc mem size to nearest 4Kb
mov sm_rstop_ptr, al

ret


test_mem:
;Returns CY, DX = msg if failed.
;Tests board memory by writing and reading bit patterns.

mov testbyte, 0ffh
call do_test

jb tm_err
mov testbyte, 0
call do_test
jb tm_err

clc
ret
tm_err:
mov dx, offset mem_failed_msg
stc
ret


do_test:
;Writes `testbyte' to board memory and reads it back.
;Returns CY if failure.

mov tmp_pag, SM_TSTART_PG ;? probably
dt_loop:
mov al, testbyte
mov di, offset buf
mov cx, BUF_SIZ
cld
rep stosb ;set buf = testbyte

mov si, offset buf
mov ah, tmp_pag
xor al, al
mov cx, BUF_SIZ
call block_output ;write pattern to page

mov ah, tmp_pag
xor al, al
mov si, ax
mov di, offset buf
mov cx, BUF_SIZ
call get_block ;read it back

mov al, testbyte
mov di, offset buf
mov cx, BUF_SIZ
cld
rep scasb ;check mem we read
jne dt_failed ;jump if != testbyte

inc tmp_pag ;go to next page
mov al, tmp_pag
cmp al, sm_rstop_ptr ;have we done all pages?
jne dt_loop ;jump if not

clc ;no error
ret
dt_failed:
stc ;error
ret


code ends
end