Columbia Kermit/kermit.zip/archives/packetdrivers.tar.gz/pd.tar/src/ctrondni.asm

Assembly Source File | 1995-06-25 | 17KB | 820 lines

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] <packet_int_no> <hardware_irq> <io_addr>", 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