;*****************************************************************************;
;*                                                                           *;
;*     File:   IBMTOKEN.ASM                                                  *;
;*     Auth:   Brian Fisher                                                  *;
;*             Queens University                                             *;
;*             Computing and Communications Services                         *;
;*             Rm 2-50 Dupuis Hall                                           *;
;*             Kingston Ontario                                              *;
;*                                                                           *;
;*     Date:   September 3 1989                                              *;
;*                                                                           *;
;*     Purp:   Ethernet (3C501) packet driver for IBM Token Ring.  This      *;
;*             driver requires the IBM LAN support program.  The current     *;
;*             implementation supports IP and ARP.                           *;
;*                                                                           *;
;*             This driver was derived from GENERIC.ASM, the driver          *;
;*             skeleton program distributed with the FTP Software            *;
;*             Ethernet drivers.                                             *;
;*                                                                           *;
;*===========================================================================*;
;*     Program Logic:                                                        *;
;*                                                                           *;
;*     This driver supports IP and ARP transmissions on Token Ring.  RARP    *;
;*     and BOOTP have not been tested, and probably don't work.              *;
;*                                                                           *;
;*     The application interface uses Ethernet Blue Book encapsulation.      *;
;*     This program translates that to IEEE 802.2 LLC for transmission on    *;
;*     Token Ring.  Received packets are translated back and passed up to    *;
;*     the application using a couple of call back routines.                 *;
;*                                                                           *;
;*     Ethernet and Token Ring hardware addresses are the same size.  No     *;
;*     translation is performed.                                             *;
;*                                                                           *;
;*     Token Ring uses source routing.  When a packet is received the source *;
;*     address is checked for RIF information.  If present it is stored in   *;
;*     a table local to the driver.  SEND_PKT checks the SA bit of the       *;
;*     Ethernet destination address.  If set, the RIF is pulled from the     *;
;*     table and used to build the LLC header.  The MSB of the destination   *;
;*     address is cleared.  The SA bit of the source address is set          *;
;*     to indicate the presence of RIF.  The RIF direction bit is toggled.   *;
;*                                                                           *;
;*     The minimum size of an Ethernet packet is 60.  The maximum size is    *;
;*     1514 bytes.  When a Token Ring packet is received, it can be smaller  *;
;*     than 60.  Packet sizes are rounded up to 60 so the upper level will   *;
;*     accept them.                                                          *;
;*                                                                           *;
;*     IP packets can be transmitted without modification.                   *;
;*                                                                           *;
;*     ARP packets must be modified.  On transmit, the hardware address      *;
;*     space field must be changed from 0001h to 0006h.  The process is      *;
;*     reversed on receive.  Also, the size of an ARP packet is 28, but      *;
;*     the Ethernet call uses 60.  I drop the size to 28 on transmit, then   *;
;*     bump it back up to 60 on receive.  I imagine something similar will   *;
;*     be required for BOOTP and RARP.                                       *;
;*                                                                           *;
;*===========================================================================*;
;*                                                                           *;
;*      Revs:  Sep 29 1989     Successful tests with TN3270, FTP, and FTPBIN.*;
;*             B. Fisher       Some fine tuning required.                    *;
;*                                                                           *;
;*             Oct 1  1989     Cleaning up code.  Found bug that prevented   *;
;*                             buffer1/buffer2..n copies from working.       *;
;*                                                                           *;
;*             Oct 15 1989     Rearranged buffer sizes to accomodate Adapt I *;
;*                                                                           *;
;*             Nov 15 1989     Added missing popf at end of recv_complt      *;
;*                             Fixed missing popf at end of recv_complt      *;
;*                                                                           *;
;*             Nov 19 1989     Added marker to show interrupt activity       *;
;*                             for debugging.                                *;
;*                                                                           *;
;*             Nov 20 1989     Add changes for Release 5 compatibility       *;
;*                                                                           *;
;*             Nov 21 1989     Fix es/bx reversal at get_size                *;
;*                                                                           *;
;*             Nov 22 1989     RIF not working because of confusion with     *;
;*                             SA bit acquired via ARP and SA bit acquired   *;
;*                             through Token Receive.  Send_Pkt now looks    *;
;*                             up all dest addresses in RIF table.           *;
;*                                                                           *;
;*             Nov 23 1989     Have DEBUG mode report RIF table address when *;
;*                             get_multicast_ call made.                     *;
;*                                                                           *;
;*             Nov 28 1989     Add phony RIF to 'local' addresses so the     *;
;*                             bridge will pass them on.  ARP acquired HW    *;
;*                             addresses need RIF to cross bridge.  This is  *;
;*                             done in send_pkt.                             *;
;*                                                                           *;
;*             Nov 29 1989     Fixed REPT macro in SA_blk so size of SA info *;
;*                             is correct.  Didn't hurt function, however.   *;
;*                                                                           *;
;*             Nov 29 1989     Clear broadcast bit in RIF before entry in    *;
;*                             table.  This prevents bridges from altering   *;
;*                             existing route.  FF,FF,FF,FF,FF,FF address    *;
;*                             uses broadcast bit so ARP will work.          *;
;*                                                                           *;
;*             Nov 29 1989     Predefined broadcast RIF entry direction bit  *;
;*                             polarity reversal prevented broadcast from    *;
;*                             going over the bridge.                        *;
;*                                                                           *;
;*****************************************************************************;

version        equ     9

       include defs.asm

debug          = 0                             ; set to 1 for IRQ markers on 25

toke_vect      = 5Ch                           ; LAN Support Pgm Vector
toke_wait      = 0FFh                          ; completion code wait status
pool_size      = 512                           ; 8K space for buffer pool area

num_rcv_buff   = 2                             ; <2 defaults to 8
recv_size      = 1536                          ; max size of card recieve buffer
tran_size      = 1536                          ; max size of transmit buffer

STATION_ID     = 0;                            ; talk using direct station

RECV_OPTIONS   = 0C0h                          ; contiguous mac/data in bufs

open_cmd       =       3h                      ; LAN Support OpCodes
interrupt_cmd  =       0h
initialize_cmd =       20h
close_cmd      =       4h
modify_cmd     =       1h
restore_cmd    =       2h
trans_dir_cmd  =       0Ah
free_ccb_cmd   =       27h
recv_can_cmd   =       29h
open_recv_cmd  =       28h
get_status_cmd =       21h

SA_table_size = 32                             ; RIF info table max entries

LLC_AC         = 10h                           ; access control LLC
LLC_FC         = 40h                           ; frame control  LLC
LLC_SSAP_DSAP  = 0AAAAh                        ; reversed for network <grin>
LLC_CON        = 03h

MAC_hdr_size   = 22                            ; MAC+LLC+SNAP header length

not_SA_mask    = 7Fh
SA_mask        = 80h
RIF_size_mask  = 1Fh
RIF_dir_bit    = 80h

broadcast_byte = 0FFh                          ; broadcast is FF,FF,FF,FF,FF,FF

ARP_type       = 0608h                         ; reversed for network order
ARP_Eth_hwr    = 0100h                         ; reversed for network order
ARP_Tok_hwr    = 0600h                         ; reversed for network order
ARP_packet_size= 28                            ; fixes Ethernet assumption...
phony_RIF      = 2082h                         ; used for bridges...



LLC_info_size  = 8                             ; LLC (3) + SNAP(5) = 8

mark           = 0F90h                         ; marker debug pos on screen 25

marker         macro   st,nd

               IF  debug NE 0                    ; do marker if debug <> 0

               pushf                             ; show 2 char marker on
               push es                           ; 25th line, 1st column
               push ax
               mov  ax,0B800h
               mov  es,ax
               mov  al,'&st&'
               mov  byte ptr es:[mark],al
               mov  al,byte ptr es:[mark+1]      ; get color value
               inc  al
               and  al,0Fh
               or   al,1
               mov  byte ptr es:[mark+1],al      ; advance it to show activity
               mov  al,'&nd'
               mov  byte ptr es:[mark+2],al
               mov  al,byte ptr es:[mark+3]
               inc  al
               and  al,0Fh
               or   al,1
               mov  byte ptr es:[mark+3],al
               pop  ax
               pop  es
               popf

               ENDIF

               endm

call_token     macro   ccb
;--------------------------------------;
; loads address of CCB in ES:BX, then  ;
; calls the Token Ring Interface.      ;
;--------------------------------------;
               mov     ax,cs
               mov     es,ax
               mov     bx,offset &ccb&
               int     toke_vect
               endm


call_wait      macro
               local   wait_loop
;---------------------------------------;
; assumes ES:BX points to a CCB.  Waits ;
; for a pending command to terminate.   ;
;---------------------------------------;
wait_loop:
               mov     al,es:[bx+2]
               cmp     al,toke_wait
               je      wait_loop
               endm


set_ptr        macro   dest,addr
;---------------------------------------;
; loads a far pointer with a near       ;
; address offset and CS:                ;
;---------------------------------------;
               mov     ax,offset &addr&
               mov     word ptr [&dest&],ax
               mov     ax,cs
               mov     word ptr [&dest&+2],ax
               endm


print$         macro   string
;---------------------------------------;
;  sends $ terminated string to screen  ;
;---------------------------------------;
               mov     ah,9
               mov     dx,offset &string&      ; print $ terminated string
               int     21h
               endm


clr_struc      macro   name
;---------------------------------------;
;  clear all bytes of the named struc   ;
;  to zero.  Useful for Token calls.    ;
;---------------------------------------;
               mov     cx,SIZE &name&          ; uses ax, es:di, cx
               mov     ax,ds
               mov     es,ax
               mov     di,offset &name&
               xor     al,al
               cld
               rep     stosb                   ; set all elements to 0
               endm


rdupb          macro   l,n
&l&            db      ?
               rept    &n&-1
               db      ?
               endm
               endm

       IF debug NE 0

regs   struc                           ; from head.asm, [bp] references the
_RES   dw      ?                       ; IRQ service parameters with these.
_RDS   dw      ?
_RBP   dw      ?
_RDI   dw      ?
_RSI   dw      ?
_RDX   dw      ?
_RCX   dw      ?
_RBX   dw      ?
_RAX   dw      ?
_RIP   dw      ?
_RCS   dw      ?
_RCF   dw      ?               ;flags
regs   ends

       ENDIF


ccb_blk        struc                   ; CCB used for local token ring calls.
adapter        db      ?               ; adapter 0 or 1
command        db      ?               ; command code
retcode        db      ?               ; command completion code
work           db      ?               ; scratch
pointer        dd      ?               ; queue pointer
complt         dd      ?               ; command complete appendage
parms          dd      ?               ; pointer to CCB parameter table
ccb_blk ends


init_parms     struc                   ; parameters for DIR_INITIALIZE
bring_ups      dw      ?               ; result of bring up tests
sram_addr      dw      ?               ; shared ram address
reserved       dd      ?               ; not used...
chk_exit       dd      ?               ; adapter check exit
status         dd      ?               ; ring status exit
error          dd      ?               ; PC error exit
init_parms     ends


o_parms        struc                   ; ccb parms for DIR_OPEN
adapt          dd      ?               ; ptr to adapter parms
direct         dd      ?               ; ptr to direct parms
dlc            dd      ?               ; ptr to dlc parms
msg            dd      ?               ; ptr to msg parms
o_parms        ends


ada_blk        struc                   ; adapter open parms table format
err_code       dw      ?               ; open errors detected
options        dw      ?               ; various options
node_addr      dd      ?               ; node address ( 4 bytes here +  )
               dw      ?               ; rest of node address ( 2 here  )
group_add      dd      ?               ; group address
func_add       dd      ?               ; functional address
rcv_buff       dw      ?               ; number of receive buffers
rcv_len        dw      ?               ; receive buffer length
dhb_len        dw      ?               ; length of transmit buffers
hold_buf       db      ?               ; number of tx buffers
               db      ?               ; reserved
lock_code      dw      ?               ; lock code
id_addr        dd      ?               ; address of id code
ada_blk        ends


dir_blk        struc                   ; dir interfce open parms table format
buf_size       dw      ?               ; size of direct station buffer
pool_blks      dw      ?               ; number of 16 byte blocks in buff pool
pool_addr      dd      ?               ; address of direct station buffer pool
chk_exit       dd      ?               ; the rest can be 0 (defaults) for now
stat_exit      dd      ?               ; ring status appendage pointer
err_exit       dd      ?               ; PC error exit
work_addr      dd      ?               ; work area segment value
len_req        dw      ?               ; work area length requested
len_act        dw      ?               ; actual length obtained
dir_blk        ends


dlc_blk        struc                   ; dlc interface open parms table format
max_sap        db      ?               ; max number of saps
max_sta        db      ?               ; max number of stations
max_gsap       db      ?               ; max group saps
max_gmem       db      ?               ; max members per group
t1_tick1       db      ?               ; DLC timer t1 interval
t2_tick1       db      ?               ; DLC timer t2 interval
TI_tick1       db      ?               ; DLC timer TI interval
t1_tick2       db      ?               ; DLC timer t1 group 2
t2_tick2       db      ?               ; DLC timer t2 group 2
TI_tick2       db      ?               ; DLC timer TI group 2
dlc_blk        ends


mod_blk        struc                   ; modify open parms parameter block
buf_size       dw      ?               ; size of SAP buffers
pool_blks      dw      ?               ; length in 16-byte, of buffer pool
pool_adrs      dd      ?               ; address of direct interface buf pool
chkt_exit      dd      ?               ; appendage, adapter check
stat_exit      dd      ?               ; appendage, ring status
err_exit       dd      ?               ; appendage, PC error exit
new_opts       dw      ?               ; new options (wrap is ignored)
mod_blk        ends


tx_blk         struc                   ; transmit.dir.frame parameter block
station        dw      ?               ; defines station sending data
trans_fs       db      ?               ; * stripped FS field (returned)
rsap           db      ?               ; RSAP (remote sap value)
queue_1        dd      ?               ; address of TX queue 1
queue_2        dd      ?               ; address of TX queue 2
buf_len_1      dw      ?               ; length of buffer 1
buf_len_2      dw      ?               ; length of buffer 2
buffer_1       dd      ?               ; address of the first transmit buffer
buffer_2       dd      ?               ; address of the second transmit buffer
tx_blk         ends


free_blk       struc                   ; buffer.free parameters
st_id          dw      ?               ; station id
buf_left       dw      ?               ; returns number of buffers left
resrvd         dd      ?               ;
first_buf      dd      ?               ; address of 1st buffer to free
free_blk       ends


get_blk        struc                   ; buffer.get parameters
stn_id         dw      ?               ; station id
buffr_lef      dw      ?               ; buffers left
buff_get       db      ?               ; number of buffers to get
resrv1         db      ?               ; 3 bytes not used
resrv2         db      ?
resrv3         db      ?
frst_buff      dd      ?               ; address of buffer obtained
get_blk        ends


rx_blk         struc                   ; receive parms
id             dw      ?               ; station id
user_len       dw      ?               ; size of user space in buffer
receiver       dd      ?               ; appendage for received data
first_bf       dd      ?               ; pointer to 1st buffer
opts           db      ?               ; receive options
rx_blk         ends


status_blk     struc                   ; parameter table for dir.status
encoded_addr   dw      ?               ; adapters permanent ring address
               dd      ?
node_adrs      dw      ?               ; ring address set by open
               dd      ?
group_adrs     dd      ?
func_adrs      dd      ?
               REPT    16
               db      ?
               ENDM
               REPT    3
               dd      ?
               ENDM
               dw      ?
status_blk     ends





mac_header     struc                   ; token ring mac header format
AC             db      ?               ; access control byte
FC             db      ?               ; frame control byte
               rdupb   dest,EADDR_LEN
               rdupb   source,EADDR_LEN
dsap           db      ?               ; LLC dsap
ssap           db      ?               ; LLC ssap
control        db      ?               ; control byte
ptype          db      ?
               db      ?               ; SNAP header
               db      ?
ethtype        dw      ?               ; EtherType
rif            dw      ?               ; optional RIF information
               REPT    8               ; segment information
               dw      ?               ; this is not its real position.
               ENDM                    ; this is a variable length field...
mac_header     ends


SA_blk         struc
               rdupb   s_addr,EADDR_LEN
RCF            db      ?
               db      ?
route          dw      ?
               REPT    7
               dw      ?
               ENDM    ?
SA_blk         ends


ether_hdr      struc                           ; ethernet header format
               rdupb   ether_dest,EADDR_LEN
               rdupb   ether_src,EADDR_LEN
ether_type     dw      ?
ether_hdr      ends


first_buffer   struc                           ; Token receive 1st buffer
next_buffer    dd      ?                       ; ptr to next buffer
xx1            dw      ?
data_size      dw      ?                       ; size of user data
               REPT    12
               db      ?
               ENDM
user_data      db      ?
first_buffer   ends

user_data2     =       12                      ; 2nd buffer slightly different



;=============================================================================;
;======================= START OF PROGRAM CODE ===============================;
;=============================================================================;

code           segment byte public
               assume  cs:code, ds:code

Token_address  db      EADDR_LEN dup (0)       ; holds my address after init.

ccb            ccb_blk <>                      ; scratch CCB
free_ccb       ccb_blk <>
tx_parms       tx_blk  <>                      ; transmit.dir.frame parms
iparms         init_parms <>                   ; init parms
pool_buff      db (pool_size+1)*16 dup (?)     ; buffer pool
free_parms     free_blk <>                     ; buffer.free parameters
get_parms      get_blk  <>                     ; buffer.get parameters

rx_ccb         ccb_blk <>                      ; receive CCB
rx_parms       rx_blk  <>                      ; receive parms


id_code        db 18 dup (0)   ; phony product id code
                               ; (a real space saver...)

ada_parm       ada_blk <0,0,0,0,0,0,num_rcv_buff,recv_size,tran_size,1,0,0,0>

dir_parm       dir_blk <0,pool_size,0,0,0,0,0,0,0>
dlc_parm       dlc_blk <0,0,0,0,0,0,0,0,0,0>
init_parm      o_parms <0,0,0,0>
initccb        ccb_blk <0,0,0,0,0,0,0>
toke_status    status_blk <>

modparms mod_blk <0,pool_size,0,0,0,0,0>
modccb ccb_blk < 0,modify_cmd,0,0,0,0,0>

lan_header  mac_header  <LLC_AC,LLC_FC>


;      SA RIF table has 1 entry in it by default, for the broadcast address.
;
SA_index dw            1
SA_table SA_blk <0ffh,0ffh,0ffh,0ffh,0ffh,0ffh,82h,0A0h>
         db    ((SIZE SA_blk - 1)*SA_table_size) dup (0)


dir_interrupt  proc
;---------------------------------------;
; Entry: token_card (0 or 1)            ;
;  Exit: AX = CCB return code           ;
;---------------------------------------;
               clr_struc ccb                   ; initialize CCB
               mov     ax,token_card
               mov     [ccb.adapter],al
               mov     al,interrupt_cmd
               mov     [ccb.command],al
               call_token ccb                  ; call the interface
               call_wait  ccb                  ; wait for completion
               xor     ah,ah
               mov     al,[ccb.retcode]        ; return the result in AX
               ret
dir_interrupt  endp


dir_initialize proc
;---------------------------------------;
; Entry: token_card (0 or 1)            ;
;  Exit:                                ;
;       Ah = bring up return code       ;
;       Al = ccb return code            ;
;---------------------------------------;
               clr_struc ccb                   ; clear ccb
               clr_struc iparms                ; clear init parms (defaults)

               mov     ax,token_card           ; assign parameters
               mov     [ccb.adapter],al
               mov     al,initialize_cmd       ; command....
               mov     [ccb.command],al

               set_ptr ccb.parms,iparms        ; link to init parms

               call_token ccb                  ; call the interface
               call_wait  ccb                  ; wait for completion

               mov     ah,byte ptr iparms.bring_ups
               mov  al,[ccb.retcode]

               ret
dir_initialize endp


dir_open_adapter proc
;---------------------------------------;
; Entry: token_card (0 or 1)            ;
;  Exit: AX = CCB return code           ;
;---------------------------------------;
               mov     ax,token_card           ; get adapter number
               mov     [initccb.adapter],al

               mov     al,open_cmd
               mov     [initccb.command],al    ; 03h open_adapter command

               set_ptr ada_parm.id_addr,id_code
               set_ptr dir_parm.pool_addr,pool_buff
               set_ptr init_parm.adapt,ada_parm
               set_ptr init_parm.direct,dir_parm
               set_ptr init_parm.dlc,dlc_parm
               set_ptr initccb.parms,init_parm

               xor     al,al
               mov     [initccb.retcode],al

               call_token initccb              ; call the interface


;               call_wait  initccb              ; wait for completion
wlxxx:
	       print$	msg_opening
               mov     al,es:[bx+2]
               cmp     al,toke_wait
               je      wlxxx

	       print$ msg_lf
               xor  ah,ah
               mov  al,[initccb.retcode]

               ret
dir_open_adapter endp


dir_close_adapter proc
;---------------------------------------;
; Entry: token_card (0 or 1)            ;
;  Exit: AX = CCB return code           ;
;---------------------------------------;
               clr_struc ccb                   ; clear CCB

               mov     ax,token_card           ; initialize local CCB
               mov     [ccb.adapter],al
               mov     al,close_cmd            ; close command
               mov     [ccb.command],al

               call_token ccb                  ; call the interface
               call_wait  ccb                  ; wait for completion

               xor     ah,ah
               mov     al,[ccb.retcode]        ; return the result
               ret
dir_close_adapter endp


dir_modify_open proc
;---------------------------------------;
; Entry: token_card (0 or 1)            ;
;  Exit: AX = CCB return code           ;
;---------------------------------------;
               mov     ax,token_card           ; get adapter number
               mov     [modccb.adapter],al     ; command is a constant in ccb

               set_ptr modparms.pool_adrs,pool_buff
               set_ptr modccb.parms,modparms

               xor     al,al
               mov     [modccb.retcode],al

               call_token modccb       ; call the interface
               call_wait  modccb       ; wait for completion

               xor     ah,ah
               mov     al,[modccb.retcode]
               ret
dir_modify_open endp


dir_restore_open proc
;---------------------------------------;
; Entry: token_card (0 or 1)            ;
;  Exit: AX = CCB return code           ;
;---------------------------------------;
               clr_struc ccb                   ; initialize CCB

               mov     ax,token_card
               mov     [ccb.adapter],al
               mov     al,restore_cmd          ; dir.restore.open.parms
               mov     [ccb.command],al

               call_token ccb                  ; call the interface
               call_wait  ccb                  ; wait for completion

               xor     ah,ah
               mov     al,[ccb.retcode]        ; return the result in AX
               ret
dir_restore_open endp


transmit_dir_frame proc
;---------------------------------------;
; Entry: token_card (0 or 1)            ;
;                                       ;
; Stack:                                ;
;       sp+14  dw [usr seg]             ;
;       sp+12  dw [usr ofs]             ;
;       sp+10  dw [usrsize]             ;
;       sp+8   dw [hdr seg]             ;
;       sp+6   dw [hdr ofs]             ;
;       sp+4   dw [hdrsize]             ;
;       sp+2   dw [ret ofs]             ;
;       sp+0   dw [  bp   ]             ;
;                                       ;
;  Exit:                                ;
;       Ah = stripped FS field          ;
;       al = CCB return code            ;
;---------------------------------------;

trans_frame    struc                           ; transmit_dir_frame parms
_x_bp          dw      ?                       ; old bp register
_x_ret_ofs     dw      ?                       ; near return address
header_size    dw      ?                       ; MAC header size
llc_header     dd      ?                       ; address of header
user_dsize     dw      ?                       ; user data size
user_daddress  dd      ?                       ; user data address
trans_frame    ends

               push    bp
               mov     bp,sp

               mov     ax,cs
               mov     ds,ax

               clr_struc ccb                   ; zero the CCB
               clr_struc tx_parms              ; zero parameters

               mov     ax,token_card           ; initialize local CCB
               mov     [ccb.adapter],al
               mov     al,trans_dir_cmd        ; transmit.dir.frame
               mov     [ccb.command],al
;
;      Set up transmit parameters, and link them to
;      the CCB...
;
               mov     ax,offset tx_parms
               mov     word ptr [ccb.parms],ax

               mov     ax,cs
               mov     word ptr [ccb.parms+2],ax
;
               mov     ax,STATION_ID

               mov     word ptr [tx_parms.station],ax

               mov     ax,[bp][user_dsize]
               mov     word ptr [tx_parms.buf_len_2],ax

               mov     ax,word ptr [bp][user_daddress]
               mov     word ptr [tx_parms.buffer_2],ax
               mov     ax,word ptr [bp][user_daddress+2]
               mov     word ptr [tx_parms.buffer_2+2],ax

               mov     ax,[bp][header_size]
               mov     word ptr [tx_parms.buf_len_1],ax

               mov     ax,word ptr [bp][llc_header]
               mov     word ptr [tx_parms.buffer_1],ax
               mov     ax,word ptr [bp][llc_header+2]
               mov     word ptr [tx_parms.buffer_1+2],ax

               call_token ccb                  ; call the interface
               call_wait  ccb                  ; wait for completion

               mov     ah,[tx_parms.trans_fs]
               mov     al,[ccb.retcode]

               pop     bp

               ret     (SIZE trans_frame)-4    ; (forget bp and ret address)
transmit_dir_frame endp


buffer_free    proc
;---------------------------------------;
; Entry:                                ;
;      sp+4    [ seg 1st buffer ]       ;
;      sp+2    [ ofs 1st buffer ]       ;
;      sp+0    [ bp             ]       ;
;                                       ;
;  Exit: AX = CCB return code           ;
;---------------------------------------;
               mov     ax,cs
               mov     ds,ax

               push    bp
               mov     bp,sp

               clr_struc free_ccb
               clr_struc free_parms

               mov     ax,token_card           ; initialize local CCB
               mov     [free_ccb.adapter],al

               mov     al,free_ccb_cmd         ; buffer.free
               mov     [free_ccb.command],al

               mov     ax,offset free_parms
               mov     word ptr [free_ccb.parms],ax

               mov     ax,cs
               mov     word ptr [free_ccb.parms+2],ax
;
;      Load free_parms to release buffer
;
               mov     ax,STATION_ID
               mov     word ptr [free_parms.st_id],ax

               mov     ax,word ptr [bp][4]
               mov     word ptr [free_parms.first_buf],ax
               mov     ax,word ptr [bp][6]
               mov     word ptr [free_parms.first_buf+2],ax

               call_token free_ccb             ; call the interface

               xor     ah,ah
               mov     al,[free_ccb.retcode]   ; return the result in AX

               pop     bp

               ret     4
buffer_free    endp


recv_cancel    proc
;---------------------------------------;
; Entry: token_card (0 or 1)            ;
;                                       ;
;  Exit:                                ;
;       AX = CCB return code            ;
;                                       ;
;---------------------------------------;
               mov     ax,token_card           ; initialize local CCB
               mov     [ccb.adapter],al

               mov     al,recv_can_cmd         ; receive.cancel
               mov     [ccb.command],al

               xor     ax,ax                   ; word/bytes set to 0
               mov     [ccb.retcode],al
               mov     [ccb.work],al
               mov     word ptr [ccb.pointer],ax
               mov     word ptr [ccb.pointer+2],ax
               mov     word ptr [ccb.complt],ax
               mov     word ptr [ccb.complt+2],ax
               mov     word ptr [ccb.parms+2],ax

               mov     ax,STATION_ID
               mov     word ptr [ccb.parms],ax

               call_token ccb                  ; call the interface
               call_wait  ccb                  ; wait for completion

               xor     ah,ah
               mov     al,[ccb.retcode]        ; return the result in AX
               ret

recv_cancel    endp


open_receive proc
;---------------------------------------;
; Entry: token_card (0 or 1)            ;
;                                       ;
; Stack:                                ;
;       sp+6   dw [ret ofs]             ;
;       sp+4   dw [  bp   ]             ;
;       sp+2   dw [  ds   ]             ;
;       sp+0   dw [  es   ]             ;
;                                       ;
;  Exit:                                ;
;       AX = CCB return code            ;
;---------------------------------------;
               mov     ax,cs
               mov     ds,ax

               clr_struc rx_ccb
               clr_struc rx_parms;

               mov     ax,token_card           ; initialize local CCB
               mov     [rx_ccb.adapter],al

               mov     al,open_recv_cmd        ; receive
               mov     [rx_ccb.command],al

               mov     ax,offset recv_complt
               mov     word ptr [rx_ccb.complt],ax
               mov     ax,cs
               mov     word ptr [rx_ccb.complt+2],ax
;
;      Link receive parameters table
;
               mov     ax,offset rx_parms
               mov     word ptr [rx_ccb.parms],ax
               mov     ax,cs
               mov     word ptr [rx_ccb.parms+2],ax

               mov     ax,STATION_ID
               mov     word ptr [rx_parms.id],ax

               mov     al,RECV_OPTIONS
               mov     rx_parms.opts,al

               mov     ax,offset _receiver
               mov     word ptr [rx_parms.receiver],ax
               mov     ax,cs
               mov     word ptr [rx_parms.receiver+2],ax
;
;       Note: The receive request is submitted, but it doesn't 'complete'
;             here.  So DON'T wait for a completion code!
;
               call_token rx_ccb               ; call the interface

               xor     ah,ah
               mov     al,[rx_ccb.retcode]     ; return the result
               ret
open_receive endp


recv_complt proc
;
;      This procedure is an interrupt routine called by the Token Card
;      when receive completion occurs after an error.  All it should have
;      to do is resubmit the receive request, then exit.
;
               pushf
               push ax
               push bx
               push cx
               push dx
               push si
               push di
               push ds
               push es
               push bp
               sti

               marker E,R
               call open_receive               ; restart communications

               pop  bp
               pop  es
               pop  ds
               pop  di
               pop  si
               pop  dx
               pop  cx
               pop  bx
               pop  ax
               popf
               iret
recv_complt    endp


recv_frame     struc                           ; stack frame for receiver
               RIF_size dw     ?               ; size of RIF in packet.
               user_buff dd    ?               ; pointer to users buffer
               user_size dw    ?               ; size of buffer needed/used
               _BP     dw      ?               ; register set on stack
               _ES     dw      ?
               _DS     dw      ?
               _DI     dw      ?
               _SI     dw      ?
               _DX     dw      ?
               _CX     dw      ?
               _BX     dw      ?
               _AX     dw      ?
recv_frame     ends


_receiver      proc
;
;      This interrupt procedure is called when the Token Ring
;      card has data.
;
;      On entry, ds:si points to the CCB
;                es:bx points to the receive first_buffer in the chain.
;
;
                pushf                          ; save CPU environment
                push   ax
                push   bx
                push   cx
                push   dx
                push   si
                push   di
                push   ds
                push   es
                push   bp

                push   ax                      ; local variables: size of receive data
                push   ax                      ; segment of user supplied buffer
                push   ax                      ; offset of user supplied buffer
                push   ax

                mov    bp,sp                   ; set stack frame reference

                sti                            ; enable further int activity

                marker R,X
;
;      If the source address is mine, ignore the transmission!
;
               mov     ax,cs
               mov     ds,ax
               mov     si,offset Token_address
               mov     di,bx
               add     di,user_data+source     ; ds:si -> token address
                                               ; es:di -> pkt
               mov     cx,EADDR_LEN
               push    word ptr es:[di]        ; save msb of address

               mov     al,es:[di]
               and     al,not_SA_mask          ; drop SA indicator
               mov     es:[di],al              ; fix the bit during compare

               repe    cmpsb                   ; do string compare now
               jne     not_mine

               mov     di,bx
               add     di,user_data+source
               pop     word ptr es:[di]        ; restore token address

               jmp     drop_buffer             ; from me, ignore it!

;      es:bx -> 1st receive buffer
not_mine:
               mov     di,bx
               add     di,user_data+source
               pop     word ptr es:[di]        ; save MSB of source address

               xor     ax,ax
               mov     cx,ax
               mov     word ptr [bp][RIF_size],ax ; zero RIF size value

get_size:
               mov     ax,es
               or      ax,bx
               je      got_size
               add     cx,word ptr es:[bx][data_size]
               push    word ptr es:[bx][next_buffer]
               push    word ptr es:[bx][next_buffer+2]
               pop     es                      ; ************************
               pop     bx                      ; ************************
               jmp     get_size

got_size:
               sub     cx,LLC_info_size        ; adjust size for Token

               mov     ax,word ptr [bp][_ES]
               mov     es,ax
               mov     bx,word ptr [bp][_BX]   ; get buffer address
               mov     al,es:[bx][user_data+source]
               and     al,SA_mask              ; if SA, adjust total
               je      got_no_fix

;
;      How big is the RIF?
;
               mov     ax,word ptr es:[bx][user_data+source+EADDR_LEN]
               and     ax,RIF_size_mask
               mov     word ptr [bp][RIF_size],ax
;
;      Take away size of RIF.  Upper level doesn't get it.
;
               sub     cx,ax                   ; subtract RIF size

got_no_fix:
;
;      Min Ethersize is RUNT, so check it first, round up if necessary
;
               cmp     cx,RUNT
               jge     no_adjust_cx
               mov     cx,RUNT

no_adjust_cx:
               mov     word ptr [bp][user_size],cx ; save size of receive data
;
;      Call recv_find to determine if the receiver wants the data,
;      and where it should be stored.
;
               mov     ax,word ptr [bp][_ES]   ; reload segment/offset
               mov     es,ax
               mov     di,word ptr [bp][_BX]   ; points to E-type in Token
               add     di,40                   ; assumes Buffer 1 format,
               add     di,word ptr [bp][RIF_size] ; RIF size added now...
;
;      if ARP type, convert hardware address space value back to Ethernet...
;
               mov     ax,word ptr es:[di]     ;  -> EtherType in SNAP
               cmp     ax,ARP_type             ; ARP packet?
               jne     not_rx_arp
               mov     ax,ARP_Eth_hwr
               mov     word ptr es:[di][2],ax  ; fix 1st field of data

not_rx_arp:
               call    recv_find               ; es:di -> Snap E-Type, CX = data size

               mov     word ptr [bp][user_buff],di
               mov     ax,es
               mov     word ptr [bp][user_buff+2],ax

               or      ax,di
               jne     do_copy
               jmp     drop_buffer             ; if ptr is 0, doesn't want it!
;
;      Copy Token Ring data to users Ethernet format receive buffer.
;
do_copy:
;
;      Since the upper level wants it, better keep the RIF info in case we
;      want to send a return message.
;
               mov     ax,word ptr [bp][_ES]
               mov     ds,ax
               mov     si,word ptr [bp][_BX]
               add     si,user_data+source     ; 1st byte of source address
               call    add_entry               ; do table maintenance
;
;      Copy data to the users buffer
;
               mov     di,word ptr [bp][user_buff] ; Ethernet destination buffer
               mov     ax,word ptr [bp][user_buff+2]
               mov     es,ax

               mov     si,word ptr [bp][_BX]   ; Token Ring Source buffer
               mov     bx,si
               mov     ax,word ptr [bp][_ES]
               mov     ds,ax
               add     si,user_data            ; offset to user data
;
;      ds:si points to 1st token buffer
;      es:di points to ethernet format buffer

;      1. Copy Token/Ether  dest/source field to users buffer
;         after stripping off the SA bit in the source address.

               mov    al,byte ptr ds:[si+6]    ;****************
               and    al,07Fh                  ;***** NEW ******
               mov    byte ptr ds:[si+6],al    ;****************

               mov    cx,EADDR_LEN*2           ; 2 address fields
               add    si,2                     ; offset to dest field
               cld
               rep     movsb

               add     si,LLC_info_size-2      ; assume no RIF,
               add     si,word ptr [bp][RIF_size] ; compensate for RIF

               movsw                           ; get ethertype

               mov     cx,[bx][data_size]      ; get length of data
               sub     cx,MAC_hdr_size         ; drop MAC header stuff
               sub     cx,[bp][RIF_size]       ; compensate for RIF

copy_buffer:
               cld
               rep     movsb                   ; copy rest of data to Ether..
               push    word ptr [bx][next_buffer]
               push    word ptr [bx][next_buffer+2]
               pop     ds
               pop     si
               mov     bx,si                   ; bx is base of buffer
               add     si,user_data2           ; si offsets to user data
               mov     cx,[bx][data_size]      ; length of user data
               mov     ax,ds
               or      ax,bx                   ; NULL pointer?
               jne     copy_buffer             ; no, keep copying...
;
;      Tell Upper layer I copied the data into his buffer...
;
               mov     si,word ptr [bp][user_buff]
               mov     ax,word ptr [bp][user_buff+2]
               mov     ds,ax
               mov     cx,word ptr [bp][user_size]

               call    recv_copy
;
;      _ES:_BX points to 1st receive buffer, drop it, then exit
;
drop_buffer:
               mov     ax,word ptr [bp][_ES]   ; tell Token, drop buffer
               mov     bx,word ptr [bp][_BX]
               push    ax
               push    bx
               call    buffer_free             ; seg:offs of 1st buff on stack

               pop     ax                      ; vacuum local variables off
               pop     ax                      ; the stack
               pop     ax
               pop     ax

               pop     bp
               pop     es
               pop     ds
               pop     di
               pop     si
               pop     dx
               pop     cx
               pop     bx
               pop     ax
               popf

               marker  r,x

               iret

_receiver      endp


comp_adr       proc
;
;      Compare two token address values, set flags without affecting any
;      other registers.  JE or JNE to test result.
;
               push    si
               push    di
               push    cx
               cld
               mov     cx,EADDR_LEN
               repe    cmpsb
               pop     cx
               pop     di
               pop     si
               ret
comp_adr       endp


make_adr       proc
;
;      Given CX as an index into the SA_table (1..n), build the resulting
;      address, in ES:DI.
;
               push    ax
               push    cx
               dec     cx
               xor     di,di
               cmp     cx,0
               je      make_adr1

make_adr0:
               add     di,SIZE SA_blk          ; build index into SA_table
               loop    make_adr0

make_adr1:
               add     di,offset SA_table      ; complete the address
               mov     ax,cs
               mov     es,ax
               pop     cx
               pop     ax
               ret
make_adr       endp



add_entry      proc
;
;      DS:SI -> Token Address, make an entry in the SA routing table
;
               mov     cx,EADDR_LEN            ; don't add broadcasts to table
               push    si                      ; leave the default intact
               cld

add_entry0:
               lodsb                           ; Broadcast?
               cmp     al,broadcast_byte
               loope   add_entry0
               pop     si
               je      add_done                ; yes...

               mov     al,ds:[si]              ; is it a source route address?
               and     al,SA_mask
               je      add_done
;
;      Is it in the table?

               call    loc_entry
               jc      add_done                ; c = 1, its in the table.
;
;      if its not in the table, lets add it, if there is room.
;
               mov     cx,word ptr cs:[SA_index]
               cmp     cx,SA_table_size
               je      add_done                ; table full, ignore new entries...

               inc     cx
               mov     word ptr cs:[SA_index],cx ; advance the table index

;      before entry is made, the broadcast bit must be cleared so bridges
;      will leave the segment values alone.

               mov     al,byte ptr ds:[si+EADDR_LEN]
               and     al,07Fh                 ; clear broadcast bit
               mov     byte ptr ds:[si+EADDR_LEN],al

               call    make_adr                ; build destination address
               push    si
               mov     cx,SIZE SA_blk
               cld
               rep     movsb                   ; copy RIF into table
               pop     si

add_done:
               ret
add_entry      endp




loc_entry      proc
;
;      DS:SI -> Token Address, locate entry in the SA routing table
;      ES:DI -> SA information in table, if carry is set.
;
               mov     cx,word ptr cs:[SA_index]  ; any entries in table?
               cmp     cx,0
               je      loc_done


loc_entry0:
               call    make_adr                ; build address into table
               call    comp_adr                ; compare Token Addresses
               je      loc_found               ; if matches, in table
               loop    loc_entry0

loc_done:
               clc
               ret

loc_found:                                     ; ES:DI points to matching entry
               stc
               ret

loc_entry endp


;==============================================================================;
;=================== DRIVER CODE  =============================================;
;==============================================================================;
;
;      Token Ring Card number, parsed from command line
;
token_card     dw      0                       ; default adapter number 0
               dw      0                       ; this prevents type error.

toke_ad_name   db      "Adapter (0 or 1) ",'$'

dir_open_mode  db      0                       ; set <> 0 if modify_open used
msg_modify     db      "  ERROR:  Card Already in Use.",CR,LF
               db      "          REBOOT and try again.",CR,LF
               db      '$'
msg_initialize db      "INSTALL: initializing the adapter...",CR,LF,'$'
msg_opening    db      "         opening the adapter...",CR,'$'
msg_complete   db      "         Adapter initialization is complete.",CR,LF,'$'
msg_bad_adapter db     "ERROR: adapter must be 0 or 1.",CR,LF,'$'
msg_bad_init   db      "  ERROR: Initialization Failed.",CR,LF
               db      "         Installation aborted.",CR,LF,'$'
msg_receiving  db      "         setting up receive process...",CR,LF,'$'
msg_lf		db	LF,'$'


       public  int_no
int_no db      0,0,0,0                 ;must be four bytes long for get_number.

       public  driver_class, driver_type, driver_name
driver_class   db      1               ;from the packet spec
driver_type    db      1               ;from the packet spec
driver_name    db      'IBMTokenR',0   ;name of the driver.

       public  rcv_modes
rcv_modes      dw      4               ;number of receive modes in our table.
               dw      0,0,0,rcv_mode_3


sp_frame       struc
__bp           dw      ?
u_size         dw      ?
u_data         dd      ?
u_snap         dw      ?
sp_frame       ends


               public  send_pkt
send_pkt:
;enter with ds:si -> packet, cx = packet length.
;exit with nc if ok, or else cy if error, dh set to error number.
               assume  ds:nothing
               sti
               marker  T,X

;
;      construct local stack frame
;
               mov     ax,word ptr ds:[si][ether_type]
               push    ax
               push    ds                      ; pointer to user data packet
               mov     ax,si
               add     ax,SIZE ether_hdr
               push    ax                      ; adjusted userdata pointer
               sub     cx,SIZE ether_hdr       ; adjust size for send
               push    cx
               push    bp
               mov     bp,sp                   ; use sp_frame for reference


               mov     ax,cs                   ; set dest pointer to LLC header
               mov     es,ax

               mov     di,offset lan_header.dest
               mov     cx,EADDR_LEN*2          ; copy dest|source fields
               cld
               rep  movsb
;
;      ds:si -> dest address, locate it in the SA RIF table
;
               mov     ax,cs
               mov     ds,ax
               mov     si,offset lan_header.dest ; building LAN header info here

; Set bit 7 of address, force lookup in table.  If it is found, add RIF,
; otherwise, assume the local net.

               mov     al,byte ptr ds:[si]       ; ********************
               or      al,080h                   ; ****** NEW *********
               mov     byte ptr ds:[si],al       ;*********************

               call loc_entry
               jc   send_pkt1                  ; yes, copy out RIF information
;
;      add the rest of the fields to the LLC header, and set the size
;      for the transmit call.
;
               mov     al,byte ptr ds:[si]     ; dest address 1st byte,
                                               ; lop off SA bit
               and     al,not_SA_mask
               mov     byte ptr ds:[si],al

               mov     al,byte ptr ds:[si][EADDR_LEN]  ; force U bit high
               or      al,080h
               mov     byte ptr ds:[si][EADDR_LEN],al

               add     si,EADDR_LEN*2          ; point after dest/source addrs.
               mov     ax,es
               mov     bx,ds
               mov     ds,ax
               mov     es,bx
               xchg    si,di

;      addresses acquired from ARP default to broadcast mode, using phony
;      RIF info so the bridge will pass the packet along.
;
               mov     ax,phony_RIF            ; copy phony RIF to LLC buffer,
               cld                             ; so 'local' can cross bridge..
               stosw
               jmp     send_pkt2

send_pkt1:
;
;      source/dest address need to be adjusted for routing.
;
               mov     cx,EADDR_LEN
               push    si

send_pkt3:
               mov     al,byte ptr ds:[si]
               inc     si
               cmp     al,broadcast_byte
               loope   send_pkt3
               pop     si
               je      send_pkt4               ; broadcast address?


               mov     al,byte ptr ds:[si]     ; dest, lop off SA bit
               and     al,not_SA_mask
               mov     byte ptr ds:[si],al

send_pkt4:
               mov     al,byte ptr ds:[si][EADDR_LEN]
               or      al,SA_mask              ; set SA bit for RIF
               mov     byte ptr ds:[si][EADDR_LEN],al

               add     si,EADDR_LEN*2          ; ds:si -> dest for RIF info.
               add     di,EADDR_LEN            ; es:di -> RIF info, addr fld

               mov     bx,si                   ; keep RIF pos in LLC header

               mov     ax,word ptr es:[di]     ; get rif info
               and     ax,RIF_size_mask        ; get length of RIF
               mov     cx,ax
               mov     ax,es
               mov     dx,ds
               mov     ds,ax
               mov     es,dx
               xchg    si,di
               cld
               rep     movsb

;
;      Got RIF, fix direction bit.
;
               mov     al,es:[bx][1]           ; RIF+1 = dir bit location
               xor     al,RIF_dir_bit          ; change direction
               mov     es:[bx][1],al

send_pkt2:
;
;      es:di -> target in LLC for the rest of the header,
;      add LLC and SNAP information.
;
               mov     ax,LLC_SSAP_DSAP        ; build LLC portion
               stosw
               mov     al,LLC_CON
               stosb
               xor     ax,ax                   ; 3 bytes for Ptype in SNAP
               stosw
               stosb
               mov     ax,word ptr [bp][u_snap]
               stosw
;
;      header is complete.
;
               sub     di,offset lan_header    ; calculate size of LLC header
;
;      stack parameters for Transmit
;
               pop     bp

               mov     ax,cs
               mov     ds,ax                   ; set ds for transmit entry
               push    ax
               mov     ax,offset lan_header
               push    ax
               push    di

;--------------------------------------------------------------------
;       If Users data is an ARP packet, 0806 type, then the 1st field
;       must be changed from 0001 to 0006 for Token Ring broadcast, or
;       no one will respond.  Funny, eh?  Another thing.  Since an ARP
;       packet is smaller than the min size for Ethernet, the caller rounds
;       up the size.  I have to change it back, or some Token hosts won't
;       ARP for me.  The nerve!
;
               push    bp
               mov     bp,sp
               mov     ax,word ptr [bp][14]    ; offset to ARP type on stack...
               pop     bp

               cmp     ax,ARP_type             ; network byte order is backwards
               jne     not_tx_arp
;
;      The first field of the ARP data has to be changed from 0001 to 0006
;
               push    bp                      ; use trans_frame
               push    bp                      ; dummy entry on stack...
               mov     bp,sp
               mov     ax,word ptr [bp][user_daddress+2] ; addr of user data
               mov     es,ax
               mov     di,word ptr [bp][user_daddress]

               mov     ax,ARP_Tok_hwr
               mov     word ptr es:[di],ax     ; change ARP type to 0006

               mov     ax,ARP_packet_size      ; 28  bytes in an ARP packet
               mov     word ptr [bp][user_dsize],ax ; reset users data size

               pop     bp                      ; pop fake return address
               pop     bp                      ; pop real bp

not_tx_arp:
               call    transmit_dir_frame      ; send the packet

               pop     ax                      ; vacuum
               clc
               ret


               public  get_address
get_address:
;get the address of the interface.
;enter with es:di -> place to get the address, cx = size of address buffer.
;exit with nc, cx = actual size of address, or cy if buffer not big enough.
               assume  ds:code
;
               push    di
               push    es
               push    cx

               mov     ax,cs
               mov     ds,ax
               clr_struc ccb
               clr_struc toke_status

               mov     al,get_status_cmd       ; get status returns address
               mov     ccb.command,al
               mov     ax,offset toke_status
               mov     word ptr [ccb.parms],ax
               mov     ax,ds
               mov     word ptr [ccb.parms+2],ax

               call_token ccb
               call_wait  ccb

               mov     si,offset toke_status.encoded_addr
               pop     cx
               pop     es
               pop     di
               cmp     cx,EADDR_LEN            ; got the room for it?
               jb      get_address_fail

               cld
               mov     cx,EADDR_LEN
               rep     movsb
               mov     cx,EADDR_LEN
               clc
               ret

get_address_fail:
               stc
               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:nothing
               clc
               ret


rcv_mode_3:
;receive mode 3 is the only one we support, so we don't have to do anything.
       ret


       public  set_multicast_list
set_multicast_list:
;enter with es:di ->list of multicast addresses, cx = number of bytes.
;return nc if we set all of them, or cy,dh=error if we didn't.
       mov     dh,NO_MULTICAST
       stc
       ret


       public  get_multicast_list
get_multicast_list:
;return with nc, es:di ->list of multicast addresses, cx = number of bytes.
;return cy, NO_ERROR if we don't remember all of the addresses ourselves.
;return cy, NO_MULTICAST if we don't implement multicast.
       mov     dh,NO_MULTICAST
       stc
;
;        DEBUG: get_multicast_list reports RIF accress instead, so I can
;               check its contents from UL.
;
       IF debug NE 0
       mov     _RES[bp],cs
       mov     _RDI[bp],offset SA_table
       mov     ax,word ptr cs:SA_index
       mov     _RCX[bp],ax
       clc
       ENDIF
       ret


               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.
               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

               extrn   count_in_err: near
               extrn   count_out_err: near

               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
               ret


       public  recv_exiting
recv_exiting:
;called from the recv isr after interrupts have been acknowledged.
;Only ds and ax have been saved.
       assume  ds:nothing
       ret




;any code after this will not be kept after initialization.
end_resident   label   byte


               public  usage_msg
usage_msg      db      CR,LF
               db      "usage: IBMTOKEN <packet_int_no> <adapter>",CR,LF,LF
               db      "where: packet_int_no     is the interrupt vector",CR,LF
               db      "       adapter           is adapter 0 or 1",CR,LF,CR,LF
               db      " note: IBM LAN Support Program required.",CR,LF,'$'

               public  copyright_msg
copyright_msg  db      "*************************************************",CR,LF
               db      "*   Ethernet Packet Driver for IBM Token Ring   *",CR,LF
               db      "*                                               *",CR,LF
               db      "*   3C501 Emulation Mode, Version 1.",'0'+version
               db      "           *",CR,LF
               db      "*   portions -                                  *",CR,LF
               db      "*   Copyright 1989, Queens University           *",CR,LF
               db      "*   Computing and Communications Services       *",CR,LF
               db      "*   Written by Brian Fisher                     *",CR,LF
               IF  debug NE 0
               db      "*   DEBUG VERSION                               *",CR,LF
               ENDIF
               db      "*************************************************",CR,LF
               db      LF,LF
               db      '$'

               extrn   set_recv_isr: near

;enter with si -> argument string, di -> wword to store.
;if there is no number, don't change the number.
               extrn   get_number: near

               public  parse_args
parse_args:
;
;      si points to next argument of command line...
;
               mov     bx,offset toke_ad_name  ; next argument is card number
               mov     di,offset token_card    ; default is zero
               call    get_number
               ret


               public  etopen
;
;      Initialize the IBM Token Ring Adapter, or use
;      Modify Open if its already in use.
;
etopen:
               mov     ax,cs
               mov     ds,ax

               mov     ax,token_card           ; check token card for range
               cmp     ax,1
               jg      et_error

               call    dir_modify_open
               cmp     ax,9
               jne     et_modify_error         ; can't modify open adapter!

do_init:
               print$  msg_initialize          ; initialize the adapter
               call    dir_initialize
               cmp     ax,0
               jne     et_init_error

               print$  msg_opening             ; open the adapter
               call    dir_open_adapter
               cmp     ax,0
               jne     et_init_error

no_init:
               print$  msg_receiving           ; set up receive routines
               call    open_receive
               cmp     ax,0ffh
               jne     et_init_error           ; no receive open...

               print$  msg_complete            ; card ready to go


               mov     ax,cs
               mov     es,ax                   ; get Token Address for _receiver
               mov     di,offset Token_address
               mov     ds,ax
               mov     cx,6
               call    get_address

all_ok:
;if all is okay,
               mov     dx,offset end_resident
               clc
               ret

et_error:
;if we got an error,
               print$  msg_bad_adapter
               stc
               ret

et_init_error:
               call    dir_close_adapter       ; make sure adapter is closed
               print$  msg_bad_init
               stc
               ret

et_modify_error:
               print$  msg_modify
               stc
               ret

code           ends
               end
