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

Assembly Source File | 1995-06-25 | 61KB | 2,952 lines

version        equ    5
DEBUG        equ    0
;History:31,1

;  Copyright 1991, 1992, 1993 Russell Nelson

;   This program is free software; you can redistribute it and/or modify
;   it under the terms of the GNU General Public License as published by
;   the Free Software Foundation, version 1.
;
;   This program is distributed in the hope that it will be useful,
;   but WITHOUT ANY WARRANTY; without even the implied warranty of
;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;   GNU General Public License for more details.
;
;   You should have received a copy of the GNU General Public License
;   along with this program; if not, write to the Free Software
;   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    include    defs.asm

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

;
;    Waits for SCB command unit to become idle
;
;    MUST NOT TRASH CX OR THE ISSUE_COMMAND PROCEDURE WILL FAIL
;cmd_clear exits with cy if the command didn't become idle in one millisecond.

cmd_clear    macro
    local    exit

    lea    dx, [bp].@SCB_CMD        ;BP -> I/O Base

    in    ax, dx                ;Read SCB command
    or    ax, ax                ;Wait for command accepted
    jz    exit

    call    cmd_wait
exit:
    endm

;
; Drives channel attention to the 586.  We don't care whats in AX, the write
; will cause the ASIC to drive CA to the 586.
;
    issue_ca    MACRO
    lea    dx, [bp].@CA_Ctrl
    out    dx, al
    endm


;
;
;  Enable and disable exp16s interrupts.
;
enable_board_ints    macro
    lea    dx, [bp].@Sel_IRQ
    mov    al, encoded_int_no
    or    al, 08h
    out    dx, al
    endm

disable_board_ints    macro
    lea    dx, [bp].@Sel_IRQ
    mov    al, encoded_int_no
    out    dx, al
    endm


RxBufferSize    equ    1518+14+18    ;Max Rx packet+MAC header+
                        ; 18 (alignment)
TxBufferSize    equ    1518+14+20    ;Max Tx packet+MAC header+
                        ; 20 (alignment)

    include    exp16.inc

_64K_not_32K    db    0    ;<>0 if we have 64K of memory.
_16_not_8_bit_slot    db    0    ;<>0 if we're in a 16-bit slot.

;possible values for connection_type:
CONN_BNC    equ    0
CONN_AUI    equ    1
CONN_TPE    equ    2
CONN_AUTO    equ    3
connection_type    db    ?

;Memory Sizes
mem_size_address    equ    00H
_32K        equ    00000h
_64K        equ    00001h

CONNECTION_ADDRESS    equ    00H
CONNECTION_FIELD    equ    0001000000000000B

AUTO_CON_ADDRESS    EQU    01H
AUTO_CON_MASK    EQU    10000000B

TPE_address    equ    05H
TPE_type_field    equ    0000000000000001B

int_num_address    equ    00H
int_num_field    equ    1110000000000000B
int_field_shift    equ    13

EE_ETHERNET_ADD_LOW    equ    2
EE_ETHERNET_ADD_MID    equ    3
EE_ETHERNET_ADD_HIGH    equ    4
EE_INT        equ    0
EE_SHIFT    equ    13

;    Slot Width
slot_width_mask    equ    04h
_16_bit_slot    equ    0000h
_8_bit_slot    equ    0001h

_16_bit_override_bit    equ    08h


;
;    EXP16 base port structure
;
@EXP16BasePorts    struc
@Data_Reg    dw    ?        ;Data Transfer Register.
@Write_Ptr    dw    ?        ;Write Address Pointer.
@Read_Ptr    dw    ?        ;Read Address Pointer.
@CA_Ctrl    db    ?        ;Channel Attention Control.
@Sel_IRQ    db    ?        ;IRQ Select.
@SMB_Ptr    dw    ?        ;Shadow Memory Bank Pointer.
    db    ?
@MEM_Ctrl    db    ?
@MEM_Page_Ctrl    db    ?
@Config        db    ?
@EEPROM_Ctrl    db    ?
@ID_Port    db    ?
@EXP16BasePorts    ends

ECR1        equ    300eh

@ISR_Ports    struc
    db    0C008h dup(?)
@SCB_STAT    dw    ?
@SCB_CMD    dw    ?
@SCB_CBL    dw    ?
@SCB_RFA    dw    ?
;        @SCB_CRCERRS    dw      ?
;        @SCB_ALNERRS    dw      ?
;        @SCB_RSCERRS    dw      ?
;        @SCB_OVRNERRS   dw      ?
@ISR_Ports    ends


    @memory_page_struc    STRUC
    DB    4000H DUP (?)
    @mem_loc_0    DW    ?
    @mem_loc_2    DW    ?
    @mem_loc_4    DW    ?
    @mem_loc_6    DW    ?
    @mem_loc_8    DW    ?
    @mem_loc_10    DW    ?
    @mem_loc_12    DW    ?
    @mem_loc_14    DW    ?
    DB    4000H - 16 DUP (?)
    @mem_loc_16    DW    ?
    @mem_loc_18    DW    ?
    @mem_loc_20    DW    ?
    @mem_loc_22    DW    ?
    @mem_loc_24    DW    ?
    @mem_loc_26    DW    ?
    @mem_loc_28    DW    ?
    @mem_loc_30    DW    ?
    @memory_page_struc    ENDS

;
;
;    TData Segment
;
;    This segment template represents the 64-KB segment that the 82586
;    can address.  Shared memory can be either 32K or 64K for the EXP16.
;    All structures must be quad-word aligned.
;
;    Offset    Type of Block    Block Size    Cnt
;    ------    -------------    ----------    ---
;    0000h    ISCP        8        1
;    0008h    SCB        16        1
;    0020h    CommandBlock    104        1
;    00E0h    SendBlock(s)    1568        variable
;    ????h    ReceiveBlock(s)    1568        variable
;    FFF6h    SCP        10        1
;

TData_64    segment at 0

    ISCP    ISysConfigPtr  <>
    SCB    SystemControlBlock <>

    ORG    20H

    CB    CommandBlock    <>

    Send_Blocks    DB    SIZE SendBlock * Number_of_Tx_Buffers dup (?)
    Receive_Blocks    LABEL    WORD


    ORG    (0FFFFh - SIZE SCPS + 1) AND 0FFE0H
    SCP    LABEL    BYTE

    ORG    0FFFFh - SIZE SCPS + 1
    THeapTop    LABEL    BYTE            ;Top of available memory

end_of_send_blocks    =    20h + SIZE CommandBlock + (Number_of_Tx_Buffers * SIZE SendBlock)
num_rx_buf_32k    =    (07FFFh - SIZE SCPS + 1 - end_of_send_blocks) / (SIZE ReceiveBlock)
num_rx_buf_64k    =    (0FFFFh - SIZE SCPS + 1 - end_of_send_blocks) / (SIZE ReceiveBlock)

    TData_64    ENDS


    public    int_no
int_no        db    3,0,0,0        ;must be four bytes long for get_number.
io_addr        dw    -1,-1        ; I/O address for card
encoded_int_no    db    ?        ;encoded for exp16.

    public    driver_class, driver_type, driver_name, driver_function, parameter_list
driver_class    db    BLUEBOOK, IEEE8023, 0        ;from the packet spec
driver_type    db    91        ;from the packet spec
driver_name    db    'EtherExpress16',0    ;name of the driver.
driver_function    db    26
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,
save_err    db    0        ;error bits on promiscuous recieve
pro0        db    0
pro1        db    0

    BART_Board_ID    EQU    0BABAH
    BUD_board_ID    EQU    0BABBH
    mca_hp_board_ID    EQU    0BABCH

board_id    dw    ?

    public    rcv_modes
rcv_modes    dw    7        ;number of receive modes in our table.
    dw    0            ;There is no mode zero
    dw    0
    dw    rcv_mode_2
    dw    rcv_mode_3
    dw    rcv_mode_4    ;haven't set up perfect filtering yet.
    dw    0
    dw    rcv_mode_6

;
;    82586 Configuration Parameters
;
    config_params    LABEL    WORD
    num_config_params    LABEL    BYTE    ;12 BYTEs
    DB    0CH

    fifo_limit    LABEL    BYTE
    DB    14

    srdy    LABEL    BYTE    ;srdy = 1
    save_bad_frame    LABEL    BYTE    ;do not save bad frame
    DB    40H

    address_length    LABEL    BYTE    ;6 BYTEs
    auto_insert_address    LABEL    BYTE    ;auto insert off (1)
    preamble_length    LABEL    BYTE    ;2 BYTEs
    internal_loopback    LABEL    BYTE    ;0 = OFF  1 = ON
    external_loopback    LABEL    BYTE    ;0 = OFF  1 = ON
    DB    2EH    ;26h in IPXWS

    linear_priority    LABEL    BYTE    ;default is 0
    accel_contention_resolution    LABEL    BYTE    ;default is 0
    exp_backoff_method    LABEL    BYTE    ;0 = 802.3  1 = Alternate
    DB    00H

    interframe_spacing    LABEL    BYTE    ;default is 60H (96 bits)
    DB    60H

    slot_time_low    LABEL    BYTE    ;0
    DB    00H

    slot_time_high    LABEL    BYTE    ;2
    retry_num    LABEL    BYTE    ;15
    DB    0F2H

    promiscuous_mode    LABEL    BYTE    ;0 = OFF  1 = ON
    broadcast_disable    LABEL    BYTE    ;0 = OFF  1 = ON
    encode_decode    LABEL    BYTE    ;0 = NRZ  1 = MANCHESTER
    transmit_on_no_carrier    LABEL    BYTE    ;0 = STOP 1 = CONTINUE
    no_crc_insertion    LABEL    BYTE    ;0 = OFF  1 = ON
    crc_type    LABEL    BYTE    ;0 = 32 bit autodin II
                        ;1 = 16 bit CCITT
    bit_stuffing    LABEL    BYTE    ;0 = 802.3  1 = HDLC
    padding    LABEL    BYTE    ;0 = OFF  1 = ON
    DB    00H

    carrier_sense_filter    LABEL    BYTE    ;0 = OFF  1 = 0N
    carrier_sense_source    LABEL    BYTE    ;0 = external  1 = internal
    collision_detect_filter    LABEL    BYTE    ;default = 0
    collision_detect_source    LABEL    BYTE    ;0 = external  1 = internal
    DB    00H

    min_frame_length    LABEL    BYTE    ;60 BYTEs
    DB    60
    DB    00H    ;undefined


RxBufferCount    dw    ?
TxBufferCount    dw    ?

    Receive_Head    DW    ?
    Receive_Tail    DW    ?

HEADER_LEN    equ    EADDR_LEN + EADDR_LEN + MAX_P_LEN
    even
our_type    db    HEADER_LEN dup(?)

    extrn    is_186: byte        ;=0 if 808[68], =1 if 80[123]86.
    extrn    sys_features: byte

    include    io16.asm

    public    bad_command_intercept
bad_command_intercept:
;called with ah=command, unknown to the skeleton.
;exit with nc if okay, cy, dh=error if not.
    cmp    ah,26
    jne    bad_command_intercept_1
    jmp    do_tdr
bad_command_intercept_1:
    mov    dh,BAD_COMMAND
    stc
    ret

    public    as_send_pkt
; The Asynchronous Transmit Packet routine.
; Enter with es:di -> i/o control block, ds:si -> packet, cx = packet length,
;   interrupts possibly enabled.
; Exit with nc if ok, or else cy if error, dh set to error number.
;   es:di and interrupt enable flag preserved on exit.
as_send_pkt:
    ret

    public    drop_pkt
; Drop a packet from the queue.
; Enter with es:di -> iocb.
drop_pkt:
    assume    ds:nothing
    ret

    public    xmit
; Process a transmit interrupt with the least possible latency to achieve
;   back-to-back packet transmissions.
; May only use ax and dx.
xmit:
    assume    ds:nothing
    ret


    public    send_pkt
send_pkt:
;enter with es:di->upcall routine, (0:0) if no upcall is desired.
;  (only if the high-performance bit is set in driver_function)
;enter with ds:si -> packet, cx = packet length.
;if we're a high-performance driver, es:di -> upcall.
;exit with nc if ok, or else cy if error, dh set to error number.
    assume    ds:nothing
    cmp    pro1,1
    je    no_size_check1

    cmp    cx,GIANT        ; Is this packet too large?
    jna    no_size_check1
    jmp    send_pkt_toobig

no_size_check1:

    push    bp
    mov    bp,io_addr

    disable_board_ints
    cmd_clear    ; wait for command processor to clear

    cmp    pro1,1            ; on pro drive do not ajust size
    je    oklen

    cmp    cx,RUNT        ; minimum length for Ether
    jae    oklen
    mov    cx,RUNT        ; make sure size at least RUNT
oklen:
;
; Set SMB pointer to the transmit buffer.
;
    lea    dx,[BP].@SMB_Ptr
    mov    ax,offset send_blocks
    out    dx,ax
;
; Write evenized, padded packet length (>= RUNT bytes) to 586 TBD byte
; count field.  OR on the End of Frame bit.
;
    lea    dx,[BP].@TBD_ByteCount
    mov    ax,cx
    or    ah,byte_BIT_EOF
    out    dx,ax
;
; Set the TxCB command field for transmit.  Also set the EL bit (End of List).
;
    lea    dx, [BP].@TxCB_Command
    mov    ax, BIT_EL+GA_Transmit
    out    dx, ax
;
; Set write pointer to the data buffer for current send block.  Also
; set DX to the data register.
;
    lea    dx, [BP].@Write_Ptr
    mov    ax, offset send_blocks
    add    ax, offset TB_Data
    out    dx, ax
    mov    dx, bp            ;@Data_Reg

    inc    cx        ;round size up to next even number.
    and    cx,not 1
    call    repoutsw

send_continue:
;
; Set the SCBs command block pointer to this send packet.
;
    lea    dx, [BP].@SCB_CBL
    mov    ax, offset send_blocks
    out    dx, ax

;
; Set the SCB command to start the command unit.
;
    lea    dx, [BP].@SCB_CMD
    mov    ax, CUC_START
    out    dx, ax
    issue_ca

    cmd_clear    ; wait for frame transmit to start
    lea    dx,[BP].@SMB_Ptr
    mov    ax,offset send_blocks
    out    dx,ax

    lea    dx,[BP].@TxCB_status
transmiting:
    in    ax,dx

    test    ax,BIT_C        ; check status of transmit
    jz    transmiting

    test    ax,BIT_OK        ; how was the x-mit
    jnz    tx_ok

    enable_board_ints
    pop    bp
    mov    dh,CANT_SEND
    jmp    tx_bad

tx_ok:
    enable_board_ints

    pop    bp

    clc
    ret

send_pkt_toobig:
    mov    dh,NO_SPACE
tx_bad:
    stc
    ret


;    ReadTickCounter
;
;    Read the 16 bit timer tick count register (system board timer 0).
;    The count register decrements by 2 (even numbers) every 838ns.
;
;    Assumes:    Interrupts disabled
;
;    Returns:    AX with the current count
;            Interrupts disabled

ReadTickCounter:

    push    dx

    mov    dx, 43h                ;Command 8254 timer to latch
    xor    al, al                ; T0's current count
    out    dx, al

    mov    dx, 40h                ;read the latched count
    in    al, dx                ; LSB first
    mov    ah, al
    in    al, dx                ; MSB next
    xchg    al, ah                ;put count in proper order

    pop    dx
    ret


    public    set_address
set_address:
;enter with ds:si -> Ethernet address, CX = length of address.
;exit with nc if okay, or cy, dh=error if any errors.
    assume    ds:code
    push    bp
    push    si
;
; Set up individual address command block.
;
    mov    bp,ds:io_addr
    cmd_clear
    mov    bx, BIT_EL+GA_IA_Setup
    call    setup_command_block
    pop    si

;
; Copy individual address command parameters to individual address
; command block.
;
    mov    cx, EADDR_LEN/2
move_node_address:
    lodsw
    out    dx, ax
    loop    move_node_address

;
; Signal 586 to execute individual address command.
;
    mov    ax, CUC_Start
    mov    bx, BIT_CNA
    call    issue_command

    lea    dx, [bp].@SMB_Ptr        ;Move IO frame to the command
    mov    ax, offset cb            ; command block.
    out    dx, ax

    lea    dx,[BP].@CB_Status
working1:
    in    ax,dx

    test    ax,BIT_C        ; check status of set_ia
    jz    working1

    test    ax,BIT_OK
    jnz    set_ok
    stc
    jmp    set_address_done

set_ok:
    mov    cx,5000h        ; on 486's if we do not delay this command does not work
set1:
    mov    bx,cx
    mov    ax,[bx]
    loop    set1            ; just for delay

    mov    cx,EADDR_LEN        ;return their address length.
    clc
set_address_done:
    pop    bp
    ret


rcv_mode_2:
    and    promiscuous_mode,not 3
    or    promiscuous_mode,2    ;disable broadcasts.
    mov    min_frame_length,60
    and    save_bad_frame,not 80h
    mov    pro0,0
;;;    mov     pro1,0            ;not present in NSA version
    jmp    short configure_command
rcv_mode_4:
rcv_mode_3:
    and    promiscuous_mode,not 3    ;clear promiscuous mode.
    mov    min_frame_length,60
    and    save_bad_frame,not 80h
    mov    pro0,0
;;;    mov     pro1,0            ;not present in NSA version
    jmp    short configure_command
rcv_mode_6:
    and    promiscuous_mode,not 3
    or    promiscuous_mode,1    ;set promiscuous mode.
    mov    min_frame_length,60    ;allow runt. but let it come in as a bad frame
    or    save_bad_frame,80h    ; yes we want bad frames here
    mov    pro0,1
    mov    pro1,1
;
configure_command:
    mov    bp,io_addr
;
; Set up configure command block.
;
    mov    bx, bit_el + GA_Configure    ;Set command block for a
    call    setup_command_block        ; configure command. BIT_EL
                        ; means last command.
;
; Copy configure command parameters to configure command block.
;
    mov    si,offset config_params        ;Set DS:SI to parameters and
    mov    cx, 6                ; copy them to the command

move_config_params:

    lodsw
    out    dx, ax
    loop    move_config_params
;
; Signal 586 to execute configure command.
;
    mov    ax, CUC_Start
    mov    bx, BIT_CNA
    call    issue_command
    ret


;*****************************************************************
; TDR cable tester
; enter with es:di pointing to time int
;*****************************************************************

    public    do_tdr
do_tdr:
    push    bp
    push    es
    push    di
    mov    bp,io_addr
;
; Set up configure command block.
;
    mov    bx, bit_el + GA_TDR    ;Set command block for a
    call    setup_command_block        ; TDR command. BIT_EL
                        ; means last command.
; Signal 586 to execute configure command.
;
    mov    ax, CUC_Start
    mov    bx, BIT_CNA
    call    issue_command

    lea    dx, [bp].@SMB_Ptr        ;Move IO frame to the command
    mov    ax, offset cb            ; command block.
    out    dx, ax

    lea    dx,[BP].@CB_Status
working:
    in    ax,dx

    test    ax,BIT_C        ; check status of transmit
    jz    working

    lea    dx,[bp].@CB_Parm0
    in    ax,dx

    pop    di
    pop    es
    pop    bp

    test    ax,LNK_OK
    jz    tdr_bad_cable
    clc
    ret

tdr_bad_cable:

    push    ax
    and    ax,TDR_TIME
    stosw    ; store time
    pop    ax

    mov    cl,12
    shr    ax,cl
    and    ax,7
    mov    dh,al

    stc
    ret


;
;    BX = 586 command word
;
setup_command_block:

;
; Setup command block's command, status, and link fields.
;
    lea    dx, [bp].@SMB_Ptr        ;Move IO frame to the command
    mov    ax, offset cb            ; command block.
    out    dx, ax

    lea    dx, [bp].@CB_link        ;Set command block's link to
    out    dx, ax                ; itself.

    lea    dx, [bp].@SCB_CBL        ;Point SCB command list
    out    dx, ax                ; pointer to command block.

    lea    dx, [bp].@CB_command        ;Set command block's command
    mov    ax, bx                ; word to value passed in
    out    dx, ax                ; BX.

;
; Return with the write pointer set to the command block parameter
; offset.
;
    lea    dx, [bp].@Write_Ptr        ;Set write pointer to command
    lea    ax, CB.CB_Param0        ; parameter field.
    out    dx, ax

    mov    dx, bp            ;@Data_Reg
    ret


;
; Wait for 586 command register to be clear (  1 millisecond max)
; Issue command
; Wait for command to complete              (500 milliseconds max)
; Acknowledge command complete
;
;
issue_command:

;
; Make sure 586 command in SCB is clear.
;
    mov    cx, ax
    cmd_clear
    jc    issue_command_error_exit
    mov    ax, cx
;
; Put command code in AX into SCB command register and signal the
; 586 to look at it.  The cmd_clear macro leaves DX pointing to
; the SCB command register.
;
    out    dx, ax
    issue_ca

wait_for_commad_status_outer_loop:
;
; Wait here for 586 to complete the command.  586 should never take
; more than 500 Milliseconds to complete a command.
;
    call    readtickcounter
    mov    cx, ax
    lea    dx, [bp].@SCB_STAT

wait_for_commad_status:

    in    ax, dx
    cmp    ax, bx
    je    acknowledge_command_complete

    call    readtickcounter
    neg    ax
    add    ax, cx
    cmp    ax, ten_mils
    jb    wait_for_commad_status

_586_command_error:
;
; Signal error by pointing AX to error message, and setting
; condition codes.
;
    mov    dx,offset _586_not_responding_msg
    stc
issue_command_error_exit:
    ret

acknowledge_command_complete:
;
; Tell the 586 that we know its done by copying the status back to
; the command register's acknowledge fields.  BX has status.
;
    lea    dx, [bp].@SCB_CMD
    out    dx, ax
    issue_ca
;
; Signal no error.
;
    xor    ax, ax
    ret


    public    set_multicast_list
set_multicast_list:
;enter with ds:si ->list of multicast addresses, ax = number of addresses,
;  cx = number of bytes.
;return nc if we set all of them, or cy,dh=error hf we didn't.
    mov    dh,NO_MULTICAST
    stc
    ret


    public    terminate
terminate:
    push    bp
    mov    bp,io_addr

    cmd_clear    ; wait until last command is done processing

    disable_board_ints    ; shut off board ints

    lea    dx,[bp].@SCB_CMD
    mov    ax, RUC_SUSPEND        ; suspend recieve unit
    out    dx, ax
    issue_ca

    pop    bp            ; now ok to un-hook interrupts and release
    ret    ; driver

    public    reset_interface
reset_interface:
;reset the interface.
    assume    ds:code
    ret


;called when we want to determine what to do with a received packet.
;enter with cx = packet length, es:di -> packet type, dl = packet class.
    extrn    recv_find: near

;called after we have copied the packet into the buffer.
;enter with ds:si ->the packet, cx = length of the packet.
    extrn    recv_copy: near

;call this routine to schedule a subroutine that gets run after the
;recv_isr.  This is done by stuffing routine's address in place
;of the recv_isr iret's address.  This routine should push the flags when it
;is entered, and should jump to recv_exiting_exit to leave.
;enter with ax = address of routine to run.
    extrn    schedule_exiting: near

;recv_exiting jumps here to exit, after pushing the flags.
    extrn    recv_exiting_exit: near

    extrn    count_in_err: near
    extrn    count_out_err: near
;    extrn    resource_err_in:word

    public    recv
recv:
;called from the recv isr.  All registers have been saved, and ds=cs.
;Upon exit, the interrupt will be acknowledged.
    assume    ds:code
;
; Set BP to the base IO address of exp16.  Also disable exp16s ability
; to generate interrupts.
;
    mov    bp,io_addr
    disable_board_ints
;
; Make sure that command unit is clear before reading the status.
;
    cmd_clear
;
; Get the SCB status to see why exp16 interrupted us.  Also need to
; copy the status back to the command word to acknowledge the 586
; interrupt.  Issue channel attention to get the 586 to realize the
; interrupt aknowledge.
;
;    lea    dx, [bp].@SCB_RSCERRS
;    in    ax,dx
;    mov    word ptr resource_err_in,ax
;    lea    dx, [bp].@SCB_OVRNERRS
;    in    ax,dx
;    add    word ptr resource_err_in,ax

    lea    dx, [bp].@SCB_STAT
    in    ax, dx
    and    ax, ACK_INT_MASK

    lea    dx, [bp].@SCB_CMD
    out    dx, ax
    issue_ca    ; AX is not changed.
;
; Check for frame receive status.  Jump if no frames received,
; otherwise processes the receive.
;
    test    AX, BIT_FR OR BIT_RNR
    jz    ExitDriverISR
    call    ProcessRx
ExitDriverISR:
;
; Here if there was a bad receive status.  Make sure the receive unit
; of the 586 is running.  Read in the SCB status and jump if we need
; to restart the receive unit.  We choose to have the jump to restart
; the RU since most of the time we will not need to do this.  This
; saves cycle times when exiting without a restart.
;
    lea    dx, [bp].@SCB_STAT
    in    ax, dx
    test    ax, READY
    jz    restart_RU

drvisr_continue:
    enable_board_ints
    ret


restart_RU:
;
; Need to restart the receive unit of the 586.  Set the SCB pointer to
; the receive frame area.
;
    lea    dx, [bp].@SCB_RFA
    mov    ax, Receive_Head
    out    dx, ax
;
; Make sure 586 is in a state to accept a command.
;
    cmd_clear
;
; Put the receive unit start command into the SCB command word and
; issue the channel attention.
;
; NOTE: cmd_clear macro leaves DX pointing to the SCB command word.
;
;    lea    dx, [bp].@SCB_CMD
    mov    ax, RUC_START
    out    dx, ax
    issue_ca
    jmp    drvisr_continue


ProcessRx:

;
; Prime the pump that services receives by setting AX to the receive
; head.  There could be over 30 packets received.
;
    mov    ax,Receive_Head

CheckNextReceiveStatus:

;
; Save receive head pointer in BX.  BX should not be altered during
; this loop.
;
    mov    bx, ax
;
; Set SMB pointer to the top of the receive frame.
;
    lea    dx, [bp].@SMB_Ptr
    out    dx, ax
;
; Get the status for this receive frame.  Check to make sure that
; it completed with no errors.  If not, then jump to check the
; 586 receive unit.
;
    lea    dx, [bp].@FD_Status
    in    ax, dx

    mov    save_err,1        ; be sure we done accdently report an error

    test    ax, BIT_C        ; command compleat
    jz    PRx_no
    test    ax,BIT_OK        ; good frame
    jnz    ProcessRx_1

    call    count_in_err
    mov    save_err,0
    cmp    pro0,1
    je    PRx_bad            ; if not in pro-mode lose bad frames and inc error
;    call    count_in_err
    jmp    recv_isr_9
PRx_no:
    ret

PRx_bad:
    mov    dh,0            ;build save_err.
    test    ax,BIT_S7
    jz    PR_no_frag
    or    dh,2
PR_no_frag:
    test    ax,BIT_S11
    jz    PR_no_crc
    or    dh,4
PR_no_crc:
    test    ax,BIT_S10
    jz    PR_no_align
    or    dh,8
PR_no_align:
    test    ax,BIT_S8
    jz    PR_no_dma
    or    dh,16
PR_no_dma:
    test    ax,BIT_S9
    jz    PR_no_ru
    or    dh,32
PR_no_ru:
    mov    save_err,dh

ProcessRx_1:
;
; Set the read pointer to access the LengthTypeField.
;
; NOTE: BX was set to receive head at the beginning of this
;       procedure.
;
    lea    dx, [bp].@Read_Ptr
    lea    ax, [BX].IPX_DestAddr_HIGH
    out    dx, ax
    mov    dx, bp            ;@Data_Reg

    mov    ax,cs
    mov    es,ax
    mov    di,offset our_type
    mov    cx,HEADER_LEN
    call    repinsw

;
; Get the packet size from the 586 data structure.
;
    lea    dx, [bp].@RBD_ByteCount
    in    ax, dx
    and    ah, 3fh
    mov    cx, ax

    mov    di,offset our_type+EADDR_LEN+EADDR_LEN

    mov    dl, BLUEBOOK        ;assume bluebook Ethernet.
    mov    ax, es:[di]
    xchg    ah, al
    cmp    ax, 1518
    ja    BlueBookPacket
    inc    di            ;set di to 802.2 header
    inc    di
    mov    dl, IEEE8023
BlueBookPacket:
    push    bx
    push    cx            ; for some reison recv_find trashes cx
    mov    dh,save_err
    call    recv_find
    mov    bp,cs:io_addr        ; just in case
    pop    cx
    pop    bx

    mov    ax,es            ;is this pointer null?
    or    ax,di
    je    recv_isr_9        ;yes - just free the frame.
    push    es            ;remember where the buffer pointer is.
    push    di
    push    cx
  if 0
;
; Copy the packet's header into their buffer.
;
    push    cx
    mov    si,offset our_type
    mov    cx,HEADER_LEN/2
    rep    movsw
    pop    cx
    sub    cx,HEADER_LEN
  endif
;
; Set the read pointer to access the packet.
;
; NOTE: BX was set to receive head at the beginning of this
;       procedure.
;
    lea    dx, [bp].@Read_Ptr
  if 0
    lea    ax, [BX].IPX_DestAddr_HIGH + HEADER_LEN
  else
    lea    ax, [BX].IPX_DestAddr_HIGH
  endif
    out    dx, ax
    mov    dx, bp            ;@Data_Reg
;
; Now read the packet into es:di
;
    call    repinsw

    pop    cx
    pop    si
    pop    ds
    assume    ds:nothing
    call    recv_copy        ;tell them that we copied it.
    mov    ax,cs            ;restore our ds.
    mov    ds,ax
    assume    ds:code

recv_isr_9:
;
; Restore SMB pointer to the top of the receive frame.
;
    mov    bp,io_addr        ; just in case
    mov    ax,bx
    lea    dx, [bp].@SMB_Ptr
    out    dx, ax

;
; Clear the current receive frames status.
;
    lea    dx, [bp].@FD_Status
    xor    ax, ax
    out    dx, ax
;
; Set the end of list bit for the current receive frame.
;
    lea    dx, [bp].@FD_command
    mov    ax, BIT_EL
    out    dx, ax
;
; Read in the pointer to the next receive frame.
;
    lea    dx, [bp].@FD_Link
    in    ax, dx
;
; Update our local pointer to the receive resources:
;
; Receive_tail <-- Receive head
; Receive_head <-- next receive frame.
;
    mov    BX, Receive_Head
    mov    Receive_Tail, BX
    mov    Receive_Head, AX
    mov    cx, ax
;
; Clear previous receive frame descriptors end of list bit to free up
; a receive resource.  We do this by moving the write pointer to the
; the command word in the previous receive frame and then writing a
; zero to it.
;
    lea    dx, [bp].@Write_Ptr
    lea    ax, [bx].FD_command
    out    dx, ax

    mov    dx, bp            ;@Data_Reg
    xor    ax, ax
    out    dx, ax
;
; Check for another receive frame.
;
    mov    ax, cx
    jmp    CheckNextReceiveStatus



; This procedure is called from the cmd_clear macro after the macro determines
; that we must wait for a command to clear.
;
;     MUST NOT TRASH CX OR THE ISSUE_COMMAND PROCEDURE WILL FAIL.
;
cmd_wait:
;enter with dx -> SCB_CMD
;exit with nc if it cleared in one millisecond, cy if not.

    call    readtickcounter            ;Reference clock.  die after
    mov    bx, ax                ; 1 ms.

wait_cmd_clear:

    in    ax, dx                ;Read SCB command
    or    ax, ax                ;Wait for command accepted
    jz    exit

    call    readtickcounter
    neg    ax
    add    ax, bx

    cmp    ax, one_mil
    jb    wait_cmd_clear

    stc
exit:
    ret


    public    timer_isr
timer_isr:
;if the first instruction is an iret, then the timer is not hooked
    iret

;any code after this will not be kept after initialization. Buffers
;used by the program, if any, are allocated from the memory between
;end_resident and end_free_mem.
    public    end_resident,end_free_mem
end_resident    label    byte
end_free_mem    label    byte


    public    usage_msg
usage_msg    db    "usage: exp16 [options] <packet_int_no> <io_addr>",CR,LF,'$'

    public    copyright_msg
copyright_msg    db    "Packet driver for the Intel EtherExpress 16, version ",'0'+(majver / 10),'0'+(majver mod 10),".",'0'+version,CR,LF
    db    "Copyright 1991 Intel Corp",CR,LF
    db    "Portions Copyright 1993 Crynwr Software",CR,LF,'$'

int_no_name    db    "Interrupt number ",'$'
io_addr_name    db    "I/O port ",'$'

    extrn    set_recv_isr: near

;enter with si -> argument string, di -> dword to store.
;if there is no number, don't change the number.
    extrn    get_number: near

;enter with dx -> argument string, di -> dword to print.
    extrn    print_number: near


;-> the assigned Ethernet address of the card.
    extrn    rom_address: byte

chan_sel    db    0    ;Channel select for SYS_MCA machines

    public    etopen
etopen:
;initialize the driver.
    assume    ds:code
;
; Get board information (Node address, etc.).  Returns with BP
; set to the board IO base address (if not errors).
;
    call    get_system_info
    jc    driver_init_error_exit

    disable_board_ints
;
; If they're in an 8-bit slot, make sure that they aren't using the slave PIC.
;
    cmp    _16_not_8_bit_slot,0    ;are they using a 16-bit slot?
    jne    check_config_exit    ;yes -- cool.

    mov    dx,offset irq_config_error
    cmp    int_no, 9        ;no - don't let them use the upper IRQs.
    jb    check_config_exit
driver_init_error_exit:
    stc
    ret
check_config_exit:

;
; Initialize the 586 and the 586 data structures.
;
    call    init_586
    jc    driver_init_error_exit

; test iochrdy
    test    sys_features,SYS_MCA
    jnz    skip_iochrdy_test
    call    iochrdy_test
skip_iochrdy_test:

    cmp    connection_type,CONN_AUTO
    jne    no_auto_con
    call    auto_connector
    jnc    did_auto_con
    mov    dx,offset no_wire_msg
    mov    ah,9
    int    21h
    jmp    short    did_auto_con
no_auto_con:
    call    write_connector_setting_to_hardware
did_auto_con:

;
; Set up Interrupt line, start the receive unit, and Enable exp16s interrupt.
;
    call    set_recv_isr
    call    ru_start
    enable_board_ints    ;;; only one left in broken version.

    mov    al, int_no        ; Get board's interrupt vector
    add    al, 8
    cmp    al, 8+8            ; Is it a slave 8259 interrupt?
    jb    set_int_num        ; No.
    add    al, 70h - 8 - 8        ; Map it to the real interrupt.
set_int_num:
    xor    ah, ah            ; Clear high byte
    mov    int_num, ax        ; Set parameter_list int num.

    clc
    ret

write_connector_setting_to_hardware:
    assume    ds:code
    test    sys_features,SYS_MCA
    je    isa_connector_bart

    mov    bl,80h
    cmp    connection_type,CONN_TPE    ;did they ask for TPE?
    je    mca_tpe_connector
    mov    bl,0
mca_tpe_connector:

    call    enable_slot
    mov    dx,102h            ;stuff the AUI/Other bit in.
    in    al,dx
    and    al,not 04h
    cmp    connection_type,CONN_AUI
    je    mca_tpe_connector_1
    or    al,04h
mca_tpe_connector_1:
    out    dx,al

    mov    dx,103h            ;stuff the BNC/TPE bit in.
    in    al,dx
    and    al,not 80h
    cmp    connection_type,CONN_BNC
    je    mca_tpe_connector_2
    or    al,80h            ;<>0 means TPE
mca_tpe_connector_2:
    out    dx,al
    call    disable_slot

    jmp    no_connector_bart
isa_connector_bart:
    cmp    board_id,BART_Board_ID    ;a real BART?
    je    no_connector_bart    ;yes, it doesn't *have* an ECR1.
    mov    bp,io_addr
    lea    dx,ECR1[bp]
    in    al,dx
    and    al,not 82h        ;turn off Other/not_AUI (read as
                    ;   MCA/ISA), and TPE/not_BNC
    cmp    connection_type,CONN_AUI
    je    set_connector_bart
    or    al,80h            ;set Other/not_AUI
    cmp    connection_type,CONN_BNC
    je    set_connector_bart
    or    al,02h            ;set TPE/not_BNC
set_connector_bart:
    out    dx,al
no_connector_bart:

    mov    cx,10            ;10*10 milliseconds = 100 millis
    cmp    connection_type,CONN_AUI
    jne    set_connector_delay
    mov    cx,50            ;50*10 milliseconds = 500 millis
set_connector_delay:
; Our delay procedure can not accept a value over 27 milliseconds,
; so we use a loop to delay the 100 milliseconds.
set_connector_delay_1:
    push    cx
    mov    di, ten_mils
    call    eeprom_delay
    pop    cx
    loop    set_connector_delay_1
    ret


; int number to IRQ translate table.
IRQ_xlat_table    LABEL    BYTE
    db     12, 2, 3, 4, 5, 10, 11, 15

io_addresses    label word
    dw    300h,310h,320h,330h,340h,350h,360h,370h
    dw    200h,210h,220h,230h,240h,250h,260h,270h
    dw    0

enable_slot:
    mov    al,chan_sel
    out    96h, al            ; select channel
    mov    al, 0ffh
    out    94h, al            ; protect system board
    ret

disable_slot:
    xor    al,al            ;disable pos
    out    96h,al
    ret

    public    parse_args
parse_args:
;exit with nc if all went well, cy otherwise.
    test    sys_features,SYS_MCA
    jne    parse_args_mc
    jmp    parse_args_1

parse_args_mc:
;The following code to read the POS registers is courtesy of Racal-Interlan.

; channel selector resides at io 96h
; POS register base is at io 100h
; EXP16/MC ID is 0628bh

; search thro' the slots for a EXP16/MC card
    mov    cx, 8            ; for all channels(slots)

; channel select value for slots 0,1,2.. is 8,9,A etc
; start with slot 0, and then 7,6,5,4,3,2,1
get_05:
    mov    ax, cx            ; channel number
    or    ax, 08h            ; reg. select value
    mov    chan_sel,al        ; save each one, the LAST will right

; read adapter id
    call    enable_slot
    mov    dx, 101h
    in    al, dx            ; adapter id - ms byte
    mov    ah, al
    dec    dx
    in    al, dx            ; adapter id - ls byte

; Check if EXP16/MC
    cmp    ax, 0628bh
    je    get_10
    loop    get_05

    call    disable_slot

    mov    dx,offset Board_Not_Installed
    stc
    ret

get_10:
; found our Adapter
    call    write_pos_to_eeprom

    clc
    ret

parse_args_1:
    mov    di,offset io_addr
    call    get_number
    clc
    ret

    include    exp16mca.asm

;-----------------------------------------------------------------------------
; It is safe to assume that the command unit is up and running ready
; for the first send.  And that there are at least two send buffers
; available.
;
; This procedure works by sending a 64 byte packet to itself.  We do not turn
; on loopback, so we do not expect to see a receive.  Instead, we
; expect to see that the send completed OK.  If the send does not complete OK,
; then this routine switches to other connectors and the test is repeated.
;-----------------------------------------------------------------------------
auto_connector:

; Let's start doing the test send with AUI option first.  If we tried BNC
; first, and they were using AUI, it would seem like the BNC worked.  So
; we switch to AUI, which turns off the BNC power supply.
    MOV    connection_type, CONN_AUI
    CALL    write_connector_setting_to_hardware

; Test connection to see if it works.  Jump if it does.
    call    test_send
    clc
    je    auto_connector_exit

; Toggle AUI/Other setting and try to send a packet.  Jump if send
; works.  Now try sending on BNC.
    MOV    connection_type, CONN_BNC
    CALL    write_connector_setting_to_hardware
    call    test_send
    clc
    je    auto_connector_exit

; Here if we just tried a send the BNC.  If this is
; a three connector card, then we toggle the BNC/TPE setting.
; Jump if connection is found.
    MOV    connection_type, CONN_TPE
    CALL    write_connector_setting_to_hardware
    call    test_send
    clc
    je    auto_connector_exit
    stc
auto_connector_exit:
    ret


test_packet    label    byte
    db    EADDR_LEN dup(?)
    db    EADDR_LEN dup(?)
    db    00h,2eh            ;A 46 in network order
    db    0,0            ;DSAP=0 & SSAP=0 fields
    db    0f3h,0            ;Control (Test Req + P bit set)

; This procedure sends a packet on the wire and wait for the send to
; complete.  It the checks to see if the send completed OK and returns
; the results.
test_send:

    mov    si,offset rom_address    ;set the destination address.
    movseg    es,cs
    mov    di,offset test_packet
    repmov    EADDR_LEN
    mov    si,offset rom_address    ;set the source address.
    repmov    EADDR_LEN

    mov    cx,60
    mov    si,offset test_packet
    call    send_pkt

    call    ReadTickCounter
    mov    cx, ax

    mov    bp,io_addr
    lea    dx, [bp].@TxCB_Status
send_test_wait:
    in    ax,dx
    test    ax,8000h        ;did it finish?
    jne    send_test_done

; See if we have been here for a millisecond.  Jump if not.
    call    ReadTickCounter
    neg    ax
    add    ax, cx
    cmp    ax, one_mil
    jb    send_test_wait

    in    ax,dx            ;get the transmit status back again.

send_test_done:

    mov    cx, ax            ; Save status in CX.

    xor    ax, ax            ; Clear the transmit command block status.
    out    dx, ax

; Send is complete.  Get the status and compare to OK send and return.
; Save flags for return.

    and    cx, 0f000h
    cmp    cx, 0a000h
    ret

no_wire_msg        db    "***Unable to detect a cable on any connector***",CR,LF,'$'
bnc_connector_msg    db    "Using the BNC connector",CR,LF,'$'
aui_connector_msg    db    "Using the AUI connector",CR,LF,'$'
tpe_connector_msg    db    "Using the twisted-pair connector",CR,LF,'$'

_8_bit_slot_msg    db    "The board is in an 8-bit slot",CR,LF,'$'
_16_bit_slot_msg    db    "The board is in a 16-bit slot",CR,LF,'$'

badset_msg    db    "Set Address Command Failed",CR,LF,'$'


    public    print_parameters
print_parameters:
    mov    di,offset int_no
    mov    dx,offset int_no_name
    call    print_number
    mov    io_addr.segm,0
    mov    di,offset io_addr
    mov    dx,offset io_addr_name
    call    print_number

    mov    dx,offset bnc_connector_msg    ;print the connection type.
    cmp    connection_type,CONN_BNC
    je    print_parameters_1
    mov    dx,offset aui_connector_msg
    cmp    connection_type,CONN_AUI
    je    print_parameters_1
    mov    dx,offset tpe_connector_msg
print_parameters_1:
    mov    ah,9
    int    21h

    mov    dx,offset _16_bit_slot_msg    ;print the slot size.
    cmp    _16_not_8_bit_slot,0
    jne    print_parameters_2
    mov    dx,offset _8_bit_slot_msg
print_parameters_2:
    mov    ah,9
    int    21h

    ret


init_586:
;enter with bp=io_addr, 586 reset.

;
; Set the number of transmit and receive buffers according to the
; amount of RAM on the adapter.
;
    MOV    AX, Number_of_Tx_Buffers
    MOV    BX, num_rx_buf_32k

    cmp    _64K_not_32K,0
    je    save_number_of_buffers

    MOV    BX, num_rx_buf_64k

save_number_of_buffers:

    MOV    TxBufferCount, AX
    MOV    RxBufferCount, BX
;
; initialize SCP.  Move IO frame to top of SCP.
;
    LEA    DX, [bp].@SMB_Ptr
    MOV    AX, OFFSET scp
    OUT    DX, AX
;
; Write initial SCP values:
;    bus width    0 = 16 bit   1 = 8 bit.
;    ISCP address    always found at address 000000.
;
    LEA    DX, [BP].@SCP_SystemBus
    MOV    AL, bus_width
    OUT    DX, AX

    LEA    DX, [BP].@SCP_ISCP_Ptr_low
    XOR    AX, AX
    OUT    DX, AX
    LEA    DX, [BP].@SCP_ISCP_Ptr_high
    OUT    DX, AX

;
; Initialize ISCP.  Move IO frame to top of ISCP.  NOTE: AX falls
; through as zero.
;
    LEA    DX, [bp].@SMB_Ptr
    OUT    DX, AX
;
; Write initial ISCP values:
;    ISCP BUSY    1 = Indicates 586 is in initialization
;            process.  586 sets this byte to 0 when
;            initialization is complete.
;
;    SCB address     Always 000008
;
    LEA    DX, [BP].@iscp_busy
    MOV    AX, initialize_586
    OUT    DX, AX

    LEA    DX, [BP].@ISCP_SCB_Ptr_low
    XOR    AX, AX
    OUT    DX, AX
    LEA    DX, [BP].@ISCP_SCB_Ptr_high
    OUT    DX, AX
    LEA    DX, [BP].@iscp_scb_offset
    MOV    AX, OFFSET scb
    OUT    DX, AX

;
; Initialize SCB.  Move Write Ptr to top of SCB.  NOTE: AX falls
; through as offset to SCB.
;
    XOR    AX, AX
    LEA    DX, [BP].@SCB_Status
    OUT    DX, AX
    LEA    DX, [BP].@SCB_Command
    OUT    DX, AX
    LEA    DX, [BP].@SCB_CommandList
    OUT    DX, AX
    LEA    DX, [BP].@SCB_RecBlockList
    OUT    DX, AX
    LEA    DX, [BP].@SCB_CRC_Errors
    OUT    DX, AX
    LEA    DX, [BP].@SCB_ALN_Errors
    OUT    DX, AX
    LEA    DX, [BP].@SCB_RSC_Errors
    OUT    DX, AX
    LEA    DX, [BP].@SCB_OVR_Errors
    OUT    DX, AX

;
; Initialize Receive Block(s).  First set head pointer and link from
; SCB to first frame descriptor.  NOTE: IO frame points to ISCB.
; The SCB link field can be addresses becasue the SCB is physically
; contiguous to the ISCB.
;
    mov    ax,offset Receive_Blocks
    lea    dx, [bp].@SCB_RecBlockList    ;IO address of SCB RF link
    out    dx, ax

;
; Initialize the frame descriptor structures.  Move the Write ptr
; the top of the current frame descriptor.  AX falls through with the
; offset to the first frame descriptor.  DI is used to keep track of
; the address of the current frame descriptor.  The frame descriptor,
; receive buffer descriptor, and receive buffer are all contiguous in
; memory, and make up the frame descriptor structure.
;
    MOV    DI, AX                ;DI is current frame descriptor
    MOV    RECEIVE_HEAD, DI
    MOV    CX, RxBufferCount        ;CX is number of frame
                        ; descriptors to initialize.
init_receive_frames:

    LEA    DX, [bp].@SMB_Ptr
    MOV    AX, DI                ; descriptor.
    OUT    DX, AX

;
; Init Frame Descriptor (FD).
;
    XOR    AX, AX                ;Init frame descriptor status
    LEA    DX, [BP+4000H]
    OUT    DX, AX                ; and command to zero.
    LEA    DX, [BP+4002H]
    OUT    DX, AX

    MOV    AX, RECEIVE_HEAD        ;Init frame descriptors link
    CMP    CX, 1                ; to next frame descriptor.
    JE    next_receive_link        ; If this is the last receive
                        ; block, then set its link to
    LEA    AX, [DI+SIZE ReceiveBlock]    ; the first receive block.

next_receive_link:

    LEA    DX, [BP+4004H]
    OUT    DX, AX

    LEA    AX, [DI+OFFSET RBD_ByteCount] ;Init frame descriptors
    LEA    DX, [BP+4006H]
    OUT    DX, AX            ; link to its receive buffer descriptor.
;
; Init Receive Buffer Descriptor (RBD).
;
    LEA    DX, [BP+4008H]
    OUT    DX, AX            ;Init the RBD Actual count to zero.

    MOV    AX, -1            ;Init the RBD link to next RBD
    LEA    DX, [BP+400AH]
    OUT    DX, AX            ; to minus 1 (unused link).

    LEA    AX, [DI+RB_Data]    ;Init the RDB link to the data
    LEA    DX, [BP+400CH]
    OUT    DX, AX            ; buffer.
    XOR    AX, AX
    LEA    DX, [BP+400EH]
    OUT    DX, AX

    MOV    AX, RxBufferSize OR BIT_EL    ;Init the RBD count and status
    LEA    DX, [BP+8000H]
    OUT    DX, AX

    MOV    RECEIVE_TAIL, DI    ;Set receive tail pointer.
    ADD    DI, SIZE ReceiveBlock    ;Point DI to next frame
    LOOP    init_receive_frames    ; descriptor.
;
; Initialize the send block structures.  Move the Write pointer the
; top of the current send block.  AX falls through with address of
; first send block.  DI is used to keep track of the address of the
; current send block.  The Transmit command block, transmit buffer
; descriptor, and transmit buffer are all contiguous in memory, and
; make up the send block structure.
;
    MOV    DI, OFFSET send_blocks
    MOV    CX, TxBufferCount

    LEA    DX, [BP].@SMB_Ptr
    XOR    AX, AX
    OUT    DX, AX

    MOV    AX, DI
    LEA    DX, [BP].@SCB_CommandList
    OUT    DX, AX

init_send_blocks:

    LEA    DX, [BP].@SMB_Ptr        ;Set write pointer to send
    MOV    AX, DI                ; block.
    OUT    DX, AX
;
; Init Transmit Control Block (TCB).
;
    XOR    AX, AX            ;Init transmit control block
    LEA    DX, [BP+4000H]
    OUT    DX, AX            ; status to zero.

    LEA    DX, [BP+4002H]
    OUT    DX, AX            ;Init transmit control block
                    ; command to anything.  The
    MOV    AX, offset send_blocks    ; Init transmit control block
    CMP    CX, 1            ; link to next send block.
    JE    next_send_link        ; If this is the last send
                    ; block, then point it to
    LEA    AX, [DI+SIZE SendBlock]    ; the first block.

next_send_link:

    LEA    DX, [BP+4004H]
    OUT    DX, AX

    LEA    AX, [DI+OFFSET TBD_ByteCount]    ;Init transmit control block
    LEA    DX, [BP+4006H]
    OUT    DX, AX                ; link to Transmit Buffer
                        ; descriptor.
;
; Init Transmit Buffer Descriptor (TBD).
;
    LEA    DX, [BP+4008H]
    OUT    DX, AX            ;Init Transmit Buffer Descriptor
                    ;  byte count to anything
    MOV    AX, -1            ;Init Transmit Buffer Descriptor
    LEA    DX, [BP+400AH]
    OUT    DX, AX            ;  link to next TBD.

    LEA    AX, [DI+OFFSET TB_Data]    ;Init Transmit Buffer Descriptor
    LEA    DX, [BP+400CH]
    OUT    DX, AX            ; link to transmit
    XOR    AX, AX            ; buffer.  Low part of pointer
    LEA    DX, [BP+400EH]
    OUT    DX, AX            ; is done first.

    ADD    DI, SIZE SendBlock        ;Point DI to next send block
    LOOP    init_send_blocks        ; and loop to initialize it.

;
; Enable loopback to insure nothing acidently hits the cable while
; the 586 gets initialized.
;
    LEA    DX, [BP].@Config
    IN    AX, DX
    OR    AL, loopback_enable
    OUT    DX, AL
;
; Free the 586 from reset.
;
    CALL    free_586_reset
;
; Initialize and configure the 586.  Carry flag set means error and
; dx will point to error message.
;
    CALL    init_cmd
    mov    dx,offset bad_init_msg
    jc    init_exp16_ram_exit

    CALL    configure_command
    mov    dx,offset bad_config_msg
    jc    init_exp16_ram_exit

    CALL    diagnose_command
    jc    init_exp16_ram_exit

    movseg    es,cs
    mov    si,offset rom_address
    mov    cx,EADDR_LEN
    call    set_address
    jnc    sa_ok

    mov    dx,offset badset_msg
    mov    ah,9
    int    21h
sa_ok:
;
; Disable loopback.
;
    LEA    DX, [BP].@Config
    IN    AX, DX
    AND    AL, NOT loopback_enable
    OUT    DX, AL

    clc
    ret

init_exp16_ram_exit:
    stc
    RET


; This procedure must wait until the ASIC finishes reset.  This will take
; around 240 uSec.  This loop will time out after 500 uSec.
;
    five_hundred_micros    EQU    1194
;
reset_board:
;enter with bp=io_addr

    LEA    DX, [BP].@EEPROM_Ctrl
    MOV    AL, ASIC_Reset
    OUT    DX, AL

    XOR    AL, AL
    OUT    DX, AL

;
; Get current tick count.  This loop will wait for 500 uSec to pass
; before failing.
;
    CALL    ReadTickCounter
    MOV    BX, AX

reset_delay:

    PUSH    BX
    LEA    DX, [BP].@ID_Port    ; Set DX to the auto-id port.
    CALL    check_for_exp16_hardware
    POP    BX

    CMP    AX, BART_Board_ID
    JE    reset_board_exit

    CALL    ReadTickCounter
    NEG    AX
    ADD    AX, BX
    CMP    AX, five_hundred_micros
    JB    reset_delay

    mov    dx, offset reset_error
    stc
    RET

reset_board_exit:

    MOV    BX, AX
    clc
    RET


reset_586:
;enter with bp = io_addr
    lea    dx, [bp].@EEPROM_Ctrl
    mov    al, _586_Reset
    out    dx, al
    ret


free_586_reset:
;enter with bp = io_addr
    lea    dx, [bp].@EEPROM_Ctrl
    xor    al, al
    out    dx, al
    ret

check_for_exp16_hardware:
;enter with dx = ID port (or maybe shadow ID port).
;
; BX will have board ID when the loop is done.  CX is the loop count.
;
    XOR    BX, BX
    MOV    CX, 4

get_board_id_loop:
;
; Init registers for loop.  CX needs to be used in the loop, and AH
; could be set from the last loop.
;
    PUSH    CX
    XOR    AH, AH
;
; Read ID port.  See description above.
;
    IN    AL, DX
;
; Make nibble ID a shift count in CL.
;
    MOV    CL, AL
    AND    CL, 00000011B
    SHL    CL, 1
    SHL    CL, 1
;
; Move ID nibble to low order bits of AX, then shift then into place.  Put
; the board ID nibble into BX.  After four passes, BX will have board ID.
;
    SHR    AL, 1
    SHR    AL, 1
    SHR    AL, 1
    SHR    AL, 1
    SHL    AX, CL
    OR    BX, AX
;
; Recover loop count, and loop.
;
    POP    CX
    LOOP    get_board_id_loop
;
; Return board ID in AX.
;
    MOV    AX, BX
    RET


;
; Command #1:  Initialize
;
init_cmd:
    XOR    AX, AX                ; Init command
    MOV    BX, BIT_CX + BIT_CNA        ; status
    CALL    issue_command
    RET

diagnose_command:
;return nc if no problem, else cy,dx->error message.
;
; Set up individual address command block.
;
    MOV    BX, BIT_EL+GA_diagnose
    CALL    setup_command_block
;
; Execute the diagnose command.
;
    MOV    AX, CUC_Start
    MOV    BX, BIT_CNA
    CALL    issue_command
;
; Check diagnostics results.
;
    LEA    DX, [BP].@SMB_Ptr        ;Move IO frame to the command
    MOV    AX, OFFSET cb            ; command block.
    OUT    DX, AX

    LEA    DX, [BP].@mem_loc_0        ;Read in the diagnose status
    IN    AX, DX                ; word.
;
; Assume 586 failed the test.  Set AX to an error message and exit
; with the zero bit cleared.
;
    test    ax, 0800H            ;Test failure bit.  If set,
    jnz    diagnose_error            ; then error exit.
    clc
    ret
diagnose_error:
    mov    dx,offset _586_diagnostic_failure
    stc
    ret


;
; Command #4:  RU_START
;
ru_start:
;
; Set SCBs pointer to receive blocks at head of list.
;
    lea    dx, [bp].@SCB_RFA        ;Set pointer to receive blocks
    mov    ax, receive_head        ; to the head of the receive
    out    dx, ax                ; block list.
;
; Signal 586 to start the receive unit.  cmd_clear leaves DX pointing
; to SCB command register.
;
    cmd_clear
    mov    ax, ruc_start
    out    dx, ax
    issue_CA
    ret


find_a_board:
    mov    bx,offset io_addresses
no_exp16_here:
    mov    bp,[bx]
    cmp    bp,0
    je    no_exp16s
    inc    bx
    inc    bx
    push    bx
    call    reset_board
    pop    bx
    jc    no_exp16_here

    clc
    ret

no_exp16s:
    stc
    ret

get_system_info:
;exit with zr if okay, or nz, dx -> error message if not okay.
    cmp    io_addr,-1
    jne    addr_override
    call    find_a_board
    jnc    board_id_ok
    jmp    bad_or_no_board

addr_override:

    MOV    bp, io_addr

;
; Next, get the exp16 board ID.  If the ID is not what we expect, then
; exit with error code in AX.
;
    call    reset_board
    jnc    board_id_ok
;
; Could search for exp16 board, but we error exit instead.
;
bad_or_no_board:

    mov    dx, offset board_not_installed
    stc
    JMP    SHORT get_system_info_exit

board_id_ok:
    mov    io_addr,bp

    LEA    DX, [BP].@ID_Port    ; Set DX to the auto-id port.
    or    DX,3000h        ;use the shadow port
    CALL    check_for_exp16_hardware
    mov    board_id,ax

;
; Since the software will be reading the EEPROM during the
; initialization, the 586 needs to be inactive.  This is because the
; control lines to the EEPROM are shared between the 586 and this
; software.  To keep from getting fouled up, the 586 reset line is
; asserted here (now that we have a base IO address, and we know that
; the hardware is present).  The 586 is not released from reset until
; after its data structures are intialized.
;
    CALL    reset_586
;
; Validate the EEPROM by doing a checksum.
;
    mov    cx, 40h
    CALL    check_eeprom
    JC    get_system_info_exit
;
; Get the amount of memory on the adapter.
;
    CALL    test_buffer_memory
    JC    get_system_info_exit

;
; Get the connection type.  If carry clear, then AL has connection
; type.  Otherwise AX has error code.
;
    CALL    get_connection_type
    JC    get_system_info_exit
    MOV    connection_type, AL
;
; Read the Ethernet address out of the EEPROM.
;
    MOV    AX, EE_ETHERNET_ADD_HIGH
    CALL    read_eeprom
    xchg    ah,al
    MOV    word ptr rom_address[0], AX

    MOV    AX, EE_ETHERNET_ADD_MID
    CALL    read_eeprom
    xchg    ah,al
    MOV    word ptr rom_address[2], AX

    MOV    AX, EE_ETHERNET_ADD_LOW
    CALL    read_eeprom
    xchg    ah,al
    MOV    word ptr rom_address[4], AX

    mov    ax,EE_INT
    call    read_eeprom
    mov    cl,EE_SHIFT
    shr    ax,cl
    mov    encoded_int_no,al
    mov    bx,offset irq_xlat_table
    xlat
    mov    int_no,al

;
; Get the Slot width.  If carry clear, then AL has the slot width.
; Otherwise AX has error code.
;
    LEA    DX, [BP].@Config
    IN    AL, DX
;
; Slot width is found in the adapters configuration register.
;
    and    al, slot_width_mask
    mov    _16_not_8_bit_slot, al

    clc
    ret

get_system_info_exit:
;we only ever get here with cy set.
    RET

;
;
; Return connection type in AL with carry clear.
;
;
get_connection_type:

    cmp    board_id,BART_Board_ID    ;a real BART?
    je    get_auto_cnt_exit    ;yes, it doesn't *have* an ECR1.

    MOV    AX, AUTO_CON_ADDRESS    ;get the auto-connection bit.
    CALL    read_eeprom
    TEST    AX, AUTO_CON_MASK    ;set?
    Je    get_auto_cnt_exit    ;no, okay.
    mov    bl,CONN_AUTO        ;yes, we should autosense the connector.
    jmp    short get_connection_type_ret
get_auto_cnt_exit:

;
; Read the connection address from the EEPROM.
;
    MOV    AX, connection_address
    CALL    read_eeprom        ;Read_eeprom does not trash DI

;
; Assume AUI type connection.  Check connection fields to see if this
; is a BNC connection.  Jump if it is BNC.
;
    MOV    BL, CONN_AUI
    TEST    AX, CONNECTION_FIELD
    JZ    get_connection_type_ret

;
; Here if NOT BNC.  Must read another EEPROM word to tell if AUI or
; TPE.  Assume AUI and then check for TPE.
;
    MOV    AX, tpe_address
    CALL    read_eeprom        ;Read_eeprom does not trash DI

;
; Check for AUI connection.
;
    mov    bl,CONN_BNC
    TEST    AX, TPE_type_field
    JZ    get_connection_type_ret

;
; Here if TPE type connection.
;
    MOV    BL, CONN_TPE

get_connection_type_ret:

    MOV    AL, BL

    CLC
    RET


;
;
; Do a checksum on the EEPROM.
;
; The checksum is the same as the board ID.
;
check_eeprom:
;enter with bp=io_addr, cx = count of bytes to sum starting at 0.
;exit with nc if okay, cy, dx -> error message if not.

    xor    bx, bx

checksum_loop:

    mov    ax, cx
    dec    ax
    call    read_eeprom

    add    bx, ax
    loop    checksum_loop

    cmp    bx, BART_Board_ID
    jne    checksum_error

    clc
    ret

checksum_error:
    mov    dx,offset eeprom_checksum_error
    stc
    ret


test_buffer_memory:
;enter with bp=io_addr
;exit with nc and al=_64k_not_32k if no error, or cy and di -> address in error.

; Set up SI with the maximum number of words to test.  If there is an
; error testing the high 32K of memory, then we will restart the
; test at 32K.  When the tests pass, the memory size is passed back
; in AX.
;
    mov    si, 64 * (1024/2)
;
; Warm up the buffer memory with 16 word writes.
;
    mov    cx, 16
    call    write_zeros

    cmp    cs:is_186,0
    jne    start_memory_tests

restart_memory_tests:
;
; Here if error testing memory and SI is set to 64K buffer size.
; We restart the tests for 32K buffer only.  If an error occurs
; with SI set to 32K, then a memory error is reported.
;
    mov    si, 32 * (1024/2)

start_memory_tests:
;
; Zero RAM.  Set write pointer to the base address and then fill the
; bufffer memory with zeros.
;
    mov    cx, si
    call    write_zeros

    call    word_memory_test_pattern
    jc    buffer_mem_error_exit

    cmp    cs:is_186,0
    je    _8088_quick_exit

    mov    cx, si
    call    write_zeros

    call    byte_memory_test_pattern
    jc    buffer_mem_error_exit

_8088_quick_exit:
;
; Zero RAM.  Set write pointer to the base address and then fill the
; bufffer memory with zeros.
;
    mov    cx, si
    call    write_zeros

;
; Set _64K_not_32K to the size of the memory that passed diagnostics.
;
    cmp    si, 32 * (1024/2)    ;did we quit at 32K
    je    buffer_mem_exit        ;yes, we only have 32K.

    mov    _64K_not_32K,1        ;no, we must have 64K.

buffer_mem_exit:
    clc
    ret

buffer_mem_error_exit:
;
; If error occured, and SI is not set for 32K, then retry tests with
; SI set for 32K.  If the error occurs and the size is 32K, then the
; Exp16 board memory is bad.
;
    CMP    SI, 32 * (1024/2)
    JNE    restart_memory_tests

    MOV    DX, OFFSET buffer_memory_error
    STC    ;Set carry to indicate error.
    RET


write_zeros:
;enter with bp=io_addr, cx=number of zero words to write.
;
; Move write pointer to the beginning of the buffer memory.
;
    LEA    DX, [BP].@Write_Ptr
    XOR    AX, AX
    OUT    DX, AX
;
; Set DX to the data register and write out zeros CX times.
;
    mov    dx, bp            ;@Data_Reg
warm_up:
    out    dx, ax
    loop    warm_up
    ret


word_memory_test_pattern:
;enter with si = number of words to test.

;
; Set CX to number of words to test.  Set BX to beginning og pattern.
;
    MOV    CX, SI
    MOV    BX, 1

;
; Set DI to beginning of the buffer.
;
    XOR    DI, DI

word_inc_pattern:

    CALL    loop_set_up
    IN    AX, DX
    OR    AX, AX
    JNE    word_memory_test_pattern_error

;
; Write Test Pattern.
;
    MOV    AX, BX
    OUT    DX, AX

;
; Increment BX to next test pattern value.
;
    ADD    BX, 3

;
; Increment DI to next test memory location.
;
    ADD    DI, 2
    LOOP    word_inc_pattern

;
; Set Read pointer to beginning of buffer.
;
    LEA    DX, [BP].@read_ptr
    XOR    AX, AX
    OUT    DX, AX
    MOV    DX, BP            ;@Data_Reg

;
; Set CX to number of words to test.  Set BX to beginning og pattern.
;
    MOV    CX, SI
    MOV    BX, 1

word_check_pattern:

    IN    AX, DX
    CMP    AX, BX
    JNE    word_memory_test_pattern_error

;
; Increment BX to next test pattern value.
;
    ADD    BX, 3

    LOOP    word_check_pattern

    CLC
    RET

word_memory_test_pattern_error:

    STC
    RET


byte_memory_test_pattern:
;enter with si = number of bytes to test.

;
; Set CX to number of bytes to test.  Set BX to beginning of pattern.
;
    MOV    CX, SI
    SHL    CX, 1
    MOV    BL, 1

;
; Set DI to beginning of the buffer.
;
    XOR    DI, DI

byte_inc_pattern:

    CALL    loop_set_up
    IN    AL, DX
    OR    AL, AL
    JNE    byte_memory_test_pattern_error

;
; Write Test Pattern.
;
    MOV    AL, BL
    OUT    DX, AL

;
; Increment BX to next test pattern value.
;
    ADD    BL, 3

;
; Increment DI to next test memory location.
;
    INC    DI

    LOOP    byte_inc_pattern

;
; Set Read pointer to beginning of buffer.
;
    LEA    DX, [BP].@read_ptr
    XOR    AX, AX
    OUT    DX, AX
    MOV    DX, BP            ;@Data_Reg

;
; Set CX to number of bytes to test.  Set BX to beginning of pattern.
;
    MOV    CX, SI
    SHL    CX, 1
    MOV    BL, 1

byte_check_pattern:

    IN    AL, DX
    CMP    AL, BL
    JNE    byte_memory_test_pattern_error

;
; Increment BX to next test pattern value.
;
    add    bl, 3

    loop    byte_check_pattern

    clc
    ret

byte_memory_test_pattern_error:

    stc
    ret

loop_set_up:
;enter with bp=io_addr, di=buffer address.
;exit with ax=value at di, dx=I/O address to access buffer memory at DI

    PUSH    DI

    MOV    AX, DI            ;SMB_Ptr must be on 16 byte
    AND    AX, 0FFE0H
    AND    DI, 0001FH

    LEA    DX, [BP].@SMB_Ptr        ;Set IO page frame to the
    OUT    DX, AX


    TEST    DI, 0010H
    JZ    loop_set_up_1

    ADD    DI, @MEM_LOC_0

loop_set_up_1:
    AND    DI, 0FFEFH
    LEA    DX, [BP+DI].@MEM_LOC_0        ;Set DX for IO from buffer and

    POP    DI

    RET


read_eeprom:
;enter with bp=io_addr, ax = EEPROM location.
;exit with ax = EEPROM contents.
;preserves di.
    push    di
    push    bx
    push    cx

;  Point to EEPROM control port.

    lea    dx, [bp].@eeprom_ctrl
    mov    bx, ax

; Select the EEPROM.  Mask off the ASIC and 586 reset bits and set
; the ee_cs bit in the EEPROM control register.

    in    al, dx
    and    al, 10110010b
    or    al, ee_cs
    out    dx, al

; Write out read opcode and EEPROM location.

    mov    ax, eeprom_read_opcode        ;Set AX to READ opcode and
    mov    cx, 3                ;Send it to the EEPROM circuit
    call    shift_bits_out

    mov    ax, bx                ;Tell EEPROM which register is
    mov    cx, 6                ; to be read.  6 bit address.
    call    shift_bits_out

    call    shift_bits_in            ;AX gets EEPROM register

    call    eeprom_clean_up            ;Leave EEPROM in known state.

    pop    cx
    pop    bx
    pop    di
    ret


;-----------------------------------------------------------------------------
;  Writes the specified value to the specified EEPROM register at the
;  specified base I/O address.
;
;  Entry  - BP  Base IO.
;           AX  EEPROM location to write.
;        BX  Value to write
;
;  Return - AX = 0 if no error
;        AX = Pointer to Error message
;
;-----------------------------------------------------------------------------
write_eeprom:
;enter with bp=io_addr, ax = EEPROM location, bx = new contents.
;exit with ax = 0 if no error, ax -> error if error.
;preserves di.

    push    bx
    mov    bx, ax

    lea    dx, [bp].@EEPROM_Ctrl    ;Point to EEPROM port.

    in    al, dx                  ;Select EEPROM
    and    al, 10110000b
    or    al, ee_cs
    out    dx, al

; Send Erase/write enable opcode to the EEPROM.
    mov    ax, EEPROM_EWEN_opcode    ;Send erase/write enable
    mov    cx, 5            ; command to the EEPROM.
    call    shift_bits_out

    mov    cx, 4            ;Send 4 don't cares as
    call    shift_bits_out        ; required by the eeprom

    call    stand_by

; Send the erase opcode to the EEPROM and wait for the command to
; complete.
    mov    ax, EEPROM_erase_opcode    ;Send Erase command to the
    mov    cx, 3            ; EEPROM.
    call    shift_bits_out

    mov    ax, bx            ;Send EEPROM location the the
    mov    cx, 6            ; EEPROM.  6 bit address.
    call    shift_bits_out

    call    wait_eeprom_cmd_done    ;wait for end-of-operation
    jc    write_fault_pop        ; go if error

    call    stand_by

; Send the write opcode, location to write, and data to write to the
; EEPROM.  Wait for the write to complete.
    mov    ax, EEPROM_write_opcode    ;Send write command to the
    mov    cx, 3            ; EEPROM.
    call    shift_bits_out

    mov    ax, bx            ;Send the EEPROM location to
    mov    cx, 6            ; the EEPROM.  5 bit address.
    call    shift_bits_out

    pop    ax            ;Send data to write to the
    mov    cx, 16            ; EEPROM.  16 bits.
    call    shift_bits_out

    call    wait_eeprom_cmd_done    ;Await end-of-command
    jc    write_fault        ;go if error

    call    stand_by

; Send the erase write disable command to the EEPROM.
    mov    ax, EEPROM_EWDS_opcode        ;Disable the Erase/write
    mov    cx, 5                ; command previously sent to
    call    shift_bits_out            ; EEPROM.

    mov    cx, 4                      ;Send 4 don't cares as
    call    shift_bits_out            ; required by the eeprom

    call    eeprom_clean_up

    clc
    ret

write_fault_pop:
    add    sp, 2                ;Get rid of data on stack
write_fault:
;;;    lea    ax, eeprom_write_error
    stc
    ret


shift_bits_out:
;enter with ax=data to be shifted, cx=# of bits to be shifted.

    push    bx

; Data bits are right justified in the AX register.  Move the data
; into BX and left justify it.  This will cause addresses to to
; be sent to the EEPROM high order bit first.

    mov    bx, ax
    mov    ch, 16
    sub    ch, cl
    xchg    cl, ch
    shl    bx, cl
    xchg    cl, ch
    xor    ch, ch

; Get the EEPROM control register into AL.  Mask of the ASIC asn 586
; reset bits.

    in    al, dx
    and    al, 10111111b

; Set or clear DI bit in EEPROM control register based on value of
; data in BX.

out_shift_loop:
    and    al, not ee_di            ;Assume data bit will be zero

    rcl    bx, 1                ;Is the data bit a one?
    jnc    out_with_it            ;No
    or    al, ee_di            ;Yes
out_with_it:
    out    dx, al                ;Output a 0 or 1 on data pin

; Set up time for data is .4 Microseconds.  So to be safe (incase of
; this software is run on a cray), call delay.
    mov    di, 1
    call    eeprom_delay

    call    raise_eeprom_clock    ; Clock the data into the EEPROM.
    call    lower_eeprom_clock
    loop    out_shift_loop        ;Send next bit

    and    al, not ee_di        ;Force data bit to zero
    out    dx, al            ;Output a 0 on data pin

    pop    bx

    ret

shift_bits_in:
;exit with ax = register contents.
    push    bx
    push    cx

; BX will receive the 16 bits read from the EEPROM.  Data is valid in
; data out bit (DO) when clock is high.  There for, this procedure
; raises clock and waits a minimum amount of time.  DO is read, and
; clock is lowered.

    in    al, dx                ;Init AL to eeprom control
    and    al, 10111111b            ; register.

    xor    bx, bx                ;Init holding register
    mov    cx, 16                ;We'll shift in 16 bits

in_shift_loop:
    shl    bx, 1            ;Adjust holding register for
                    ; next bit
    call    raise_eeprom_clock

    in    al, dx
    and    al, 10111111b

    test    al, ee_do        ;Was the data bit a one?
    jz    in_eeprom_delay        ;No

    or    bx, 1            ;Yes, reflect data bit state
                    ; in holding register.

in_eeprom_delay:
    call    lower_eeprom_clock
    loop    in_shift_loop        ;CONTINUE

    mov    ax, bx            ;AX = data

    pop    cx
    pop    bx
    ret

raise_eeprom_clock:
    or    al, ee_sk        ;Clock the bit out by raising
    jmp    short eeprom_clock_common
lower_eeprom_clock:
    and    al, not ee_sk            ;Lower ee_sk
eeprom_clock_common:
    out    dx, al
    mov    di, ee_tick
    call    eeprom_delay            ;Waste time
    ret


wait_eeprom_cmd_done:
;Wait for ee_do to go high, indicating end-of-write or end-of-erase
;operation.  Wait at most 20 ms (EEPROM needs at most 10).
;exit with nc if no error.

    push    bx
    push    cx

    call    stand_by

    call    readtickcounter
    mov    di, ax

ee_do_wait_loop:

    call    readtickcounter
    neg    ax
    add    ax, di

    cmp    ax, 28640        ;12 Millisecond wait
    jb    ee_do_wait_loop

    in    al, dx            ;Get EEPROM control register

    test    al, EE_DO        ;ee_do high?
    jnz    ee_do_found

    stc
    jmp    short wait_eeprom_cmd_done_exit

ee_do_found:

    clc                ;"clean" status (no timeout)

wait_eeprom_cmd_done_exit:

    pop    cx
    pop    bx
    ret


stand_by:
; lower chip select for 1 microsecond.
    in    al, dx                  ;de-select EEPROM
    and    al, (10111110b) and (not ee_cs)
    out    dx, al

    mov    di, 2
    call    eeprom_delay

    or    al, ee_cs
    out    dx, al

    ret

; Lower EEPROM chip select and DI.
; Clock EEPROM twice and leave clock low.

eeprom_clean_up:

    push    ax

    in    al, dx
    and    al, 10111111b
    and    al, not (ee_cs or ee_di)
    out    dx, al

    call    raise_eeprom_clock
    call    lower_eeprom_clock

    pop    ax
    ret

; DI has number of 838 Nanoseconds clock counts
eeprom_delay:

    push    ax
    push    bx
    push    dx

    call    readtickcounter
    mov    bx, ax

eeprom_delay_loop:

    call    readtickcounter
    neg    ax
    add    ax, bx
    cmp    ax, di
    jb    eeprom_delay_loop

    pop    dx
    pop    bx
    pop    ax
    ret

iochrdy_test:
; First test to see if the driver is supposed to run this test.
    MOV    AX, lock_bit_address
    CALL    read_eeprom

    TEST    AX, lock_bit_mask
    JNZ    iochrdy_test_exit
; Get the configuration register.

    LEA    DX, [BP].@config
    IN    AL, DX

; Set the iochrdy test bit with and set iochrdy to late.
    OR    AL, iochrdy_test_mask+iochrdy_late
    CLI
    OUT    DX, AL

; Test IOCHRDY with IO.
    LEA    DX, [BP].@mem_loc_0
    IN    AX, DX

; Read in the results of the test.  Save results in BL.
    LEA    DX, [BP].@config
    IN    AL, DX
    MOV    BL, AL

; Turn iochrdy test off.
    AND    AL, NOT iochrdy_test_mask
    OUT    DX, AL
    STI

; Test results.  Exit if IOCHRDY_LATE bit is set correctly.
    TEST    BL, iochrdy_test_result
    JZ    iochrdy_test_exit

; Here if test failed.  Clear the 16 bit override bit (force 8 bit
; transfers) and print a warning message.
    AND    AL, NOT _16_bit_override_bit
    OUT    DX, AL

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


iochrdy_test_exit:

    RET



iochrdy_problem    db    "IOCHRDY Problem.  EtherExpress forced into 8 Bit Mode.",CR,LF,'$'
buffer_memory_error    db    "Memory error on the EtherExpress board",CR,LF,'$'

reset_error    db    "ASIC reset failure on EtherExpress board",CR,LF,'$'

_586_diagnostic_failure    db    "82586 diagnostic failure on the "
    db    "EtherExpress board",CR,LF,'$'

_586_not_responding_msg    db    "82586 did not respond to command "
    db    "on the EtherExpress board",CR,LF,'$'

command_unit_not_idle    db    "82586 command unit is not "
    db    "responding on the EtherExpress board",CR,LF,'$'

invalid_int_number    db    "EtherExpress board IRQ/Interrupt number "
    db    "not specified correctly",CR,LF,'$'

eeprom_checksum_error    db    "EEPROM failed checksum",CR,LF,'$'

Board_Not_Installed    db    "EtherExpress Board not found",CR,LF,'$'

irq_config_error    db    "IRQ selection is for 16 bit slot only.",CR,LF,'$'

bad_config_msg    db    "Could not configure the 82586",CR,LF,'$'

bad_init_msg    db    "Could not initialize the 82586",CR,LF,'$'

code    ends

    end