home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / packetdrivers.tar.gz / pd.tar / src / pi.asm < prev    next >
Assembly Source File  |  1995-06-25  |  35KB  |  1,507 lines
  1. ;   PC/FTP Packet Driver source, conforming to version 1.09 of the spec,
  2. ;   for the Ottawa PI card.
  3. ;   Dave Perry, VE3IFB, October 16, 1991
  4. ;   Portions (C) Copyright 1991, 1992 David G Perry
  5. ; 
  6. ;   Copyright, 1988, 1989, 1990, 1991 Russell Nelson
  7.  
  8. ;   This program is free software; you can redistribute it and/or modify
  9. ;   it under the terms of the GNU General Public License as published by
  10. ;   the Free Software Foundation, version 1.
  11. ;
  12. ;   This program is distributed in the hope that it will be useful,
  13. ;   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. ;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. ;   GNU General Public License for more details.
  16. ;
  17. ;   You should have received a copy of the GNU General Public License
  18. ;   along with this program; if not, write to the Free Software
  19. ;   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21. ; Change history:
  22. ; October 16, 1991 (dp) - Creation
  23. ; January 8, 1992 (dp) - Fixed bug in set_acc_delay (rewritten).
  24. ;    - Improved high speed performance by decreasing the amount
  25. ;      of time DMA is disabled in scc routines.
  26. ;    - Added new options to command line to allow more clocking
  27. ;      options (see documentation file).
  28. ;    - Added transmit buffer queue.
  29. ;    - Added command line option to specify number and size of
  30. ;      DMA buffers.
  31. ;    - Optional support for "pseudo" ethernet class
  32. ;    - Fixed bug in internal clocking mode
  33.  
  34.     include 8530inc.asm
  35.     include piinc.asm
  36.  
  37. ETHER    equ    1    ; This driver will "pretend" the PI card is an ethernet
  38.             ; card. I have used this method to run QVT/NET
  39.             ; using back-to-back PI cards between
  40.             ; two PCs. Do not use this feature on a radio link,
  41.             ; as no call signs would be transmitted.
  42.             ; To use it, reassemble with MYCLASS equ ETHER
  43.             ; and etheraddr = desired ethernet address
  44.  
  45. AX25    equ    9    ; Driver class
  46. MYCLASS    equ    AX25
  47.  
  48. PITYPE    equ    1    ; Driver type
  49.  
  50. ; transmitter states
  51. IDLE        equ    0 ; Transmitter off
  52. TXDELAY        equ    1 ; Sending leading flags
  53. ACTIVE        equ    2 ; Transmitter on, sending data
  54. UNDERRUN    equ    3 ; Transmitter on, flushing CRC
  55. FLAGOUT        equ    4 ; CRC sent - attempt to start next frame
  56. DEFER        equ    5 ; DCD Active - DEFER Transmit
  57. CRCOUT        equ    6 ; Waiting for CRC bytes to clear the fifo
  58.  
  59. DEFAULTBUFSIZE    equ    2048
  60.  
  61. version    equ    2
  62.  
  63.     include    defs.asm
  64.  
  65. code    segment    word public
  66.     assume    cs:code, ds:code
  67.  
  68. etheraddr    db    00h,00h,00h,00h,00h,00h
  69.  
  70. tstate    db    0
  71.  
  72. ; Short pointers to DMA buffers.
  73. rxbufptr    dw    0 ; Current rx buffer
  74. altbufptr    dw    0 ; Alternate receive buffer
  75. bufptr1        dw    0 ; DMA approved buffer
  76. bufptr2        dw    0 ; DMA approved buffer
  77. txbufptr    dw    0 ; Current tx buffer
  78. freelist    dw    0 ; Head of free list
  79. txqueue        dw    0 ; Head of transmit queue
  80.  
  81. txlength    dw    0 ; Save area for length of incoming packet
  82.  
  83.     public    acc_delay
  84. acc_delay dw    0,0
  85. diff        dw    0,0
  86. tick1        dw    0,0
  87. tick2        dw    0,0
  88. tx_tc    dw    0,0 ; Time constant for baud rate generator (transmit)
  89. rx_tc    dw    0,0 ; Time constant for baud rate generator (receive)
  90. random        db    0        ; Pseudo random number
  91.  
  92. ; The following values may be overridden from the command line.
  93. ; If they are omitted from the command line, these defaults are used.
  94. ; All of them occupy 4 bytes to satisfy the call to get_number.
  95.     public    int_no, io_addr, dma_channel
  96. int_no        db    7,0,0,0        ; HW Interrupt
  97. io_addr        dw    0380h,0        ; I/O address for card (jumpers)
  98. dma_channel    db    1,0,0,0     ; DMA channel for card (jumpers)
  99. speed        dw    0,0        ; Baud rate (0 for external clock)
  100. txdelayparm    dw    15,0        ; TX delay (length of flags before data)
  101. persist        dw    128,0        ; P - persistance probability out of 256
  102. slottime    dw    10,0        ; Slot time for backoff
  103. tailtime    dw    1,0        ; Depends on baud rate
  104. clkmode        dw    0,0        ; Clocking mode
  105. bufsiz        dw    DEFAULTBUFSIZE,0; Buffer size
  106. numbufs        dw    5,0        ; Number of buffers
  107.  
  108. ; The following 3 values are calculated at initialization and depend
  109. ; on which DMA channel has been selected
  110. page_addr    dw    83h        ; To be calculated from dma channel
  111. dma_dest    dw    2        ; Defaults are for channel 1
  112. dma_wcr        dw    3
  113.  
  114.     public    driver_class, driver_type, driver_name, driver_function, parameter_list
  115. driver_class    db    MYCLASS,0    ; null terminated list of classes.(ax25)
  116. driver_type    db    PITYPE        ;Assigned by FTP Software Inc.
  117. driver_name    db    'pi',0        ;name of the driver.
  118. driver_function    db    1        ;Only basic functionality
  119. parameter_list    label    byte
  120.     db    1    ;major rev of packet driver
  121.     db    9    ;minor rev of packet driver
  122.     db    14    ;length of parameter list
  123.     db    0    ;length of MAC-layer address
  124. parm_mtu    label    word
  125.     dw    DEFAULTBUFSIZE    ; MTU, including MAC headers
  126.     dw    MAX_MULTICAST * EADDR_LEN    ;buffer size of multicast addrs
  127.     dw    0    ;(# of back-to-back MTU rcvs) - 1
  128.     dw    0    ;(# of successive xmits) - 1
  129. int_num    dw    0    ;Interrupt # to hook for post-EOI
  130.             ;processing, 0 == none,
  131.  
  132.     public    rcv_modes
  133. rcv_modes    dw    4        ;number of receive modes in our table.
  134.         dw    0,0,0,rcv_mode_3
  135.  
  136. ; Switch receive buffers so we can quickly set up DMA again
  137.     public    switchbuffers
  138. switchbuffers:
  139.     mov    ax,rxbufptr
  140.     cmp    ax,bufptr1
  141.     jnz    sw_1
  142.     mov    ax,bufptr2
  143.     mov    rxbufptr,ax
  144.     mov    ax,bufptr1
  145.     mov    altbufptr,ax
  146.     ret
  147. sw_1:
  148.     mov    ax,bufptr1
  149.     mov    rxbufptr,ax
  150.     mov    ax,bufptr2
  151.     mov    altbufptr,ax
  152.     ret
  153.  
  154.     public bad_command_intercept
  155. bad_command_intercept:
  156. ;called with ah=command, unknown to the skeleton.
  157. ;exit with nc if okay, cy, dh=error if not.
  158.     mov    dh,BAD_COMMAND
  159.     stc
  160.     ret
  161.  
  162.     public    as_send_pkt
  163. ; The Asynchronous Transmit Packet routine.
  164. ; Enter with es:di -> i/o control block, ds:si -> packet, cx = packet length,
  165. ;   interrupts possibly enabled.
  166. ; Exit with nc if ok, or else cy if error, dh set to error number.
  167. ;   es:di and interrupt enable flag preserved on exit.
  168. as_send_pkt:
  169.     ret
  170.  
  171.     public    drop_pkt
  172. ; Drop a packet from the queue.
  173. ; Enter with es:di -> iocb.
  174. drop_pkt:
  175.     assume    ds:nothing
  176.     ret
  177.  
  178.     public    xmit
  179. ; Process a transmit interrupt with the least possible latency to achieve
  180. ;   back-to-back packet transmissions.
  181. ; May only use ax and dx.
  182. xmit:
  183.     assume    ds:nothing
  184.     ret
  185.  
  186. ; Append buffer pointed to by ax to queue specified by bx
  187.     public    enqueue
  188. enqueue:
  189.     pushf
  190.     cli
  191.     push    si
  192.     push    bp
  193.  
  194.     mov    si,cs:bufsiz
  195.     mov    bp,ax
  196.     mov    word ptr cs:[bp+si],0    ; Make sure next pointer is null
  197.  
  198.     cmp    word ptr cs:[bx],0    ; Is list empty?
  199.     jne    en1            ; No - find the end
  200.     mov    cs:[bx],ax        ; Yes - add it
  201.  
  202.     pop    bp
  203.     pop    si
  204.     popf
  205.     ret
  206.  
  207. en1:    mov    bp,word ptr cs:[bx] ; get pointer to first element
  208. en2:
  209.     cmp    word ptr cs:[bp+si],0    ; Is next pointer null?
  210.     je    en3        ; Yes, append our buffer
  211.     mov    bp,cs:[bp+si]    ; No - advance to next element
  212.     jmp    en2    
  213. en3:    mov    cs:[bp+si],ax
  214.  
  215.     pop    bp
  216.     pop    si
  217.     popf
  218.     ret
  219.  
  220.     public    dequeue
  221. dequeue:
  222.     pushf
  223.     cli
  224.     push    si
  225.     mov    si,cs:bufsiz
  226.     cmp    word ptr cs:[bx],0    ; Is list empty?
  227.     jne    deq1
  228.     xor    ax,ax        ; Yes, return error
  229.     pop    si
  230.     popf
  231.     stc
  232.     ret
  233. deq1:
  234.     push    bp
  235.     mov    bp,cs:[bx]        ; No, dequeue buffer
  236.     mov    ax,cs:[bp+si]
  237.     mov    cs:[bx],ax
  238.     mov    ax,bp
  239.  
  240.     pop    bp
  241.     pop    si
  242.     popf
  243.     clc
  244.     ret
  245.  
  246. ; Check to see if we should transmit or DEFER
  247. ; Return: Carry set - DEFER
  248.     public check_dcd
  249. check_dcd:
  250. ; Check DCD - see if we should DEFER transmission
  251.     cmp    tstate,FLAGOUT
  252.     je    go        ; The transmitter is already on - don't defer
  253.     mov    bx,R0+RES_EXT_INT
  254.     call    wrtscc
  255.     mov    bx,R0+RES_EXT_INT
  256.     call    wrtscc
  257.     mov    bx,R0
  258.     call    rdscc
  259.     test    al,DCD
  260.     jne    check_dcd_1    ; Carrier detected - we have to DEFER
  261.  
  262.  
  263.     mov    al,21        ; Generate pseudo random number
  264.     mul    cs:random
  265.     add    ax,53
  266.     mov    cs:random,al    ; Save it for next one in sequence
  267.  
  268.     xor    ah,ah
  269.     cmp    ax,cs:persist    ; Should we DEFER?
  270.     jle    go        ; No
  271.     mov    cs:tstate,DEFER    ; We have to wait
  272.     mov    ax,cs:slottime    ; Yes - DEFER 1 slot time
  273.     call    tdelay
  274.     stc            ; We are DEFERring
  275.     ret
  276.  
  277. go:    clc            ; We don't have to wait
  278.     ret
  279.  
  280. check_dcd_1:
  281.     mov    cs:tstate,DEFER    ; We have to wait
  282.     mov    ax,1000        ; In case DCD int. missed (shouldn't happen)
  283.     call    tdelay
  284. ; Defer until dcd transition or 1S timeout or abort
  285.     mov    bx,R15+CTSIE+DCDIE+BRKIE
  286.     call    wrtscc
  287.     stc            ; We are DEFERring
  288.     ret
  289.  
  290.     public    send_pkt
  291. send_pkt:
  292. ;enter with es:di->upcall routine, (0:0) if no upcall is desired.
  293. ;  (only if the high-performance bit is set in driver_function)
  294. ;enter with ds:si -> packet, cx = packet length.
  295. ;if we're a high-performance driver, es:di -> upcall.
  296. ;exit with nc if ok, or else cy if error, dh set to error number.
  297.     assume    ds:nothing
  298. ; Copy packet into local DMA approved buffer
  299. ; Enqueue it for transmission. If the queue is full, return error.
  300. ; If the transmitter is not active and the channel is free, start
  301. ; transmission, else defer. Return as soon as buffer can be released.
  302.     
  303.     pushf
  304.     cli
  305.  
  306.     mov    ax,cs        ;  Point es at the code segment
  307.     mov    es,ax
  308.  
  309.     mov    bx,offset freelist    ; Get a buffer from the freelist
  310.     call    dequeue
  311.     jc    send_error    ; None left
  312.  
  313.     mov    di,ax        ; Use newly aquired DMA buffer
  314.     push    bp
  315.     push    si
  316.     mov    bp,ax
  317.     mov    si,cs:bufsiz
  318.     mov    cs:[bp+si+2],cx    ; Tack on length
  319.     pop    si
  320.     pop    bp    
  321.     
  322.     cld
  323.     rep    movsb        ; Copy packet
  324.  
  325.     mov    bx,offset txqueue    ; Append it to the tx queue
  326.     call    enqueue
  327.  
  328.     mov    al,cs:tstate    ; Is transmitter idle?
  329.     cmp    al,IDLE
  330.     je    send_pkt_1    ; Yes - start transmitting
  331.     popf            ; Else return without error
  332.     clc
  333.     ret    
  334.  
  335. send_error:
  336.     popf
  337.     stc            ; Return error
  338.     ret
  339.     
  340. send_pkt_1:
  341.     cli
  342.  
  343.     mov    bx,offset txqueue; Get a buffer from the txqueue
  344.     call    dequeue
  345.     jc    none_to_send    ; None left
  346.     mov    cs:txbufptr,ax    ; Make it the active tx buffer
  347.  
  348.     push    bp
  349.     push    si
  350.     mov    bp,ax
  351.     mov    si,cs:bufsiz
  352.     mov    cx,cs:[bp+si+2]    ; Get length
  353.     pop    si
  354.     pop    bp    
  355.  
  356.     mov    cs:txlength,cx
  357.  
  358. ; Check DCD - see if we should DEFER transmission
  359.     call    check_dcd
  360.     jc    send_pkt_exit    ; DEFER
  361.     mov    ax,cs        ; Set up for TX DMA
  362.     mov    cx,ax
  363.     mov    bx,cs:txbufptr
  364.     mov    ax,cs:txlength
  365.     call    setup_tx_dma
  366.  
  367.     mov    cs:tstate,TXDELAY
  368.     call    tx_on    ; Start sending flags
  369.     mov    ax,cs:txdelayparm    ; generate an exint after TXDELAY
  370.     call    tdelay
  371.  
  372. send_pkt_exit:
  373.     popf
  374.     clc    ;  No error
  375.     ret
  376.  
  377. none_to_send:
  378.     call    tx_off
  379.     mov    cs:tstate,IDLE
  380.     popf
  381.     clc    ;  No error
  382.     ret
  383.  
  384.     public    set_address
  385. set_address:
  386. ;enter with ds:si -> Ethernet address, CX = length of address.
  387. ;exit with nc if okay, or cy, dh=error if any errors.
  388.     assume    ds:nothing
  389.     ret
  390.  
  391.  
  392. rcv_mode_3:
  393. ;receive mode 3 is the only one we support, so we don't have to do anything.
  394.     ret
  395.  
  396.  
  397.     public    set_multicast_list
  398. set_multicast_list:
  399. ;enter with ds:si ->list of multicast addresses, cx = number of addresses.
  400. ;return nc if we set all of them, or cy,dh=error if we didn't.
  401.     mov    dh,NO_MULTICAST
  402.     stc
  403.     ret
  404.  
  405.  
  406.     public    terminate
  407. terminate:
  408.     ret
  409.  
  410.     public    reset_interface
  411. reset_interface:
  412. ;reset the interface.
  413.     assume    ds:code
  414.     ret
  415.  
  416.  
  417. ;called when we want to determine what to do with a received packet.
  418. ;enter with cx = packet length, es:di -> packet type, dl = packet class.
  419.     extrn    recv_find: near
  420.  
  421. ;called after we have copied the packet into the buffer.
  422. ;enter with ds:si ->the packet, cx = length of the packet.
  423.     extrn    recv_copy: near
  424.  
  425. ;call this routine to schedule a subroutine that gets run after the
  426. ;recv_isr.  This is done by stuffing routine's address in place
  427. ;of the recv_isr iret's address.  This routine should push the flags when it
  428. ;is entered, and should jump to recv_exiting_exit to leave.
  429. ;enter with ax = address of routine to run.
  430.     extrn    schedule_exiting: near
  431.  
  432. ;recv_exiting jumps here to exit, after pushing the flags.
  433.     extrn    recv_exiting_exit: near
  434.  
  435. ;enter with dx = amount of memory desired.
  436. ;exit with nc, dx -> that memory, or cy if there isn't enough memory.
  437.     extrn    malloc: near
  438.  
  439.     extrn    count_in_err: near
  440.     extrn    count_out_err: near
  441.  
  442. wcrsave    dw    0
  443. rsesave    db    0
  444.  
  445.     public rxint
  446. rxint:
  447.     assume    ds:code
  448.  
  449.     mov    bx,R1 ; Get special condition bits from R1
  450.     call    rdscc
  451.     mov    rsesave,al
  452.  
  453. ; save length of frame from 8237 */
  454.     xor    al,al
  455.     out    DMA_RESETFF,al    ; Reset byte pointer flipflop
  456.     mov    dx,dma_wcr    ; Get address of word count register
  457.     in    al,dx        ; Input low byte of word
  458.     mov    bl,al        ; Save it
  459.     in    al,dx        ; Input high byte
  460.     mov    bh,al        ; Save it - bx = bytes left
  461.     mov    wcrsave,bx
  462.     call    switchbuffers    ; Switch buffers so we can get DMA happening
  463. ; Error reset lets the receive fifo empty out using dma. There can be a few
  464. ; garbage bytes left in there so it is important to 'drain' them by
  465. ; issuing the error reset *before* we set up DMA for the next receive.
  466.     mov    bx,R0+ERR_RES    ; Error reset
  467.     call    wrtscc
  468.  
  469.     mov    ax,cs        ; Setup for next receive
  470.     mov    cx,ax
  471.     mov    bx,rxbufptr
  472.     mov    ax,cs:bufsiz
  473.     call    setup_rx_dma
  474.  
  475.     mov    al,rsesave    ; Recover status
  476.     test    al,END_FR    ; Is this an end of packet int?
  477.     jz    rxint_exit    ; no
  478.     test    al,CRC_ERR    ; CRC ok?
  479.     jnz    rxint_exit    ; No - toss frame
  480.  
  481.     mov    bx,wcrsave    ; Recover frame length
  482.     mov    ax,cs:bufsiz    ; ax = buf size - 1
  483.     sub    ax,1
  484.     sub    ax,bx        ; minus bytes left = byte count
  485.     cmp    ax,10        ; Runt?
  486.     jl    rxint_exit    ; Yes, ignore it
  487. ; Valid frame
  488.     sub    ax,2        ; Subtract 2 CRC bytes from byte count
  489.  
  490.     mov    cx,ax        ; Load packet length
  491.     mov    dl,MYCLASS    ; Load packet class
  492.  
  493.     mov    ax,cs        ; Get our segment
  494.     mov    es,ax        ; into es
  495.     mov    di,rxbufptr    ; Point to type field (not needed for AX25)
  496.     add    di,12
  497.  
  498.     call    recv_find    ; Try to get a buffer to send it up in.
  499.     mov ax,    es        ; Did recv_find give us a null pointer?
  500.     or ax,    di        ; ..
  501.     je    rxint_exit    ; If null, we must throw this one away
  502.     
  503.     cld            ; Copies which follow are forward
  504.  
  505.     push    ds        ; Save our data seg
  506.     push    cx        ; We will want the count and pointer
  507.     push    es        ;  to hand to client after copying,
  508.     push    di        ;  so save them at this point
  509.  
  510.     mov    si,altbufptr
  511.     rep    movsb        ; Do the copy
  512.  
  513.     pop    si        ; Recover pointer to destination
  514.     pop    ds        ; Tell client it's his source
  515.     pop    cx        ; And it's this long
  516.     call    recv_copy    ; Give it to him
  517.     pop    ds        ; Recover our data seg
  518.  
  519. rxint_exit:
  520.  
  521.     ret
  522.  
  523. txint:
  524.     assume    ds:code
  525.  
  526.     ret
  527.  
  528. exint:
  529.     assume    ds:code
  530.     pushf
  531.     cli
  532.  
  533.     mov    bx,R0    ; Get status
  534.     call    rdscc
  535.  
  536. ; reset external status latch
  537.     mov    bx,R0+RES_EXT_INT
  538.     call    wrtscc
  539.  
  540.     mov    al,cs:tstate    ; Is transmit IDLE?
  541.     cmp    al,IDLE    
  542.     jnz    exint_1        ; No
  543.  
  544.     mov    bx,R0+ERR_RES    ; TX IDLE - unlock fifo to flush any garbage
  545.     call    wrtscc
  546.     mov    ax,cs        ; Assume abort - Reset receive DMA
  547.     mov    cx,ax
  548.     mov    bx,rxbufptr
  549.     mov    ax,cs:bufsiz
  550.     call    setup_rx_dma
  551.     jmp    exint_exit    ; exit
  552.     
  553. exint_1:
  554.     mov    al,cs:tstate    
  555.     cmp    al,ACTIVE
  556.     jne    exint_2
  557.                 ; Transmitter is ACTIVE
  558.     mov    cs:tstate,FLAGOUT
  559.     mov    ax,tailtime
  560.     call    tdelay
  561.     jmp    exint_exit
  562. exint_2:
  563.     cmp    al,FLAGOUT
  564.     jne    exint_3
  565.                 ; Transmitter in FLAGOUT state
  566.     mov    ax,cs:txbufptr    ; Free the tx buffer
  567.     mov    bx, offset freelist
  568.     call enqueue
  569.     jmp    send_pkt_1    ; Go see if there are more to send
  570. exint_3:
  571.     cmp    al,TXDELAY
  572.     jne    exint_4
  573.                 ; Transmitter is in TXDELAY
  574.     mov    bx,R0+RES_Tx_CRC+RES_Tx_P ; reset CRC, txint pending
  575.     call    wrtscc
  576.     mov    bx,R15+TxUIE    ; Allow underrun int only
  577.     call    wrtscc
  578.                 ; Enable TX DMA
  579.     mov    bx,R1+WT_RDY_ENAB+WT_FN_RDYFN+EXT_INT_ENAB
  580.     call    wrtscc
  581.                 ; Unmask channel n (enable DMA controller chip)
  582.     mov    al,Byte Ptr dma_channel ; Enable DMA for this channel
  583.     add    al,DMA_ENABLE
  584.     out    DMA_MASK,al
  585.     
  586.     mov    bx,R0+RES_EOM_L ; Send CRC on underrun
  587.     call    wrtscc
  588.     mov    cs:tstate,ACTIVE    ; Packet going out now
  589.     jmp    exint_exit
  590.  
  591. exint_4:
  592.                 ; Transmitter must be in DEFER
  593.     call    check_dcd    ; See if we should DEFER again
  594.     jc    exint_exit    ; DEFER
  595.  
  596.     mov    ax,cs        ; Set up for TX DMA
  597.     mov    cx,ax
  598.     mov    bx,txbufptr
  599.     mov    ax,txlength
  600.     call    setup_tx_dma
  601.  
  602.     mov    cs:tstate,TXDELAY
  603.     call    tx_on        ; Start sending flags
  604.     mov    ax,txdelayparm    ; generate an exint after TXDELAY
  605.     call    tdelay
  606.     popf
  607.     ret
  608.  
  609. exint_exit:
  610.     popf
  611.     ret
  612.  
  613.     public    recv
  614. recv:
  615. ;called from the recv isr.  All registers have been saved, and ds=cs.
  616. ;Upon exit, the interrupt will be acknowledged.
  617.     assume    ds:code
  618. ; Read interrupt status register from channel A
  619. ; Process all pending interrupts in a loop
  620.  
  621. recv_1:
  622.  
  623.     mov    bx,R3
  624.     call    rdscc
  625.     cmp    al,0
  626.     jz    recv_exit
  627.     test    al,CHARxIP    ; Is channel A receive int pending?
  628.     jz    recv_2        ; no
  629.     call    rxint        ; yes
  630.     jmp    recv_eoi
  631. recv_2:    test    al,CHATxIP    ; Is channel A tx int pending?
  632.     jz    recv_3        ; no
  633.     call    txint        ; yes
  634.     jmp    recv_eoi
  635. recv_3:    test    al,CHAEXT    ; Is channel external/status int pending?
  636.     jz    recv_eoi    ; no
  637.     call    exint        ; yes
  638. ; Reset highest interrupt under service
  639. recv_eoi:
  640.     mov    bx,R0+RES_H_IUS
  641.     call    wrtscc
  642.     jmp    recv_1 ; Loop for more int processing
  643. recv_exit:    
  644.     ret
  645.  
  646. ; This routine is used for all writes to the SCC. It satisfies the
  647. ; The SCCs access time restriction by using delay loops. These loops
  648. ; are processor speed dependent and are determined by acc_delay.
  649.  
  650. ; Enter with bh = register, bl = value
  651.  
  652.     public    wrtscc
  653. wrtscc:
  654.     pushf        ; Save current interrupt state
  655.     cli        ; Wouldn't do to be interrupted now
  656.     push ax
  657.     push cx
  658.     push dx
  659.     push di
  660.     push si
  661.     push bp
  662.  
  663.     mov di,acc_delay; Load this into a register for speed
  664.  
  665.     mov dx,io_addr    ; Get card address
  666.     add dx,CTL_A    ; Point to channel A control reg
  667.     mov bp,dx    ; Save it
  668.  
  669.     mov dx,io_addr    ; get address of dma enable port
  670.     add dx,DMAEN
  671.     mov si,dx    ; save it
  672.  
  673.     mov cx,di    ; For loop below
  674.  
  675.     mov ax,100h    ; Write a 0 to disable DMA while we touch the scc
  676.     out dx,al
  677. ; ******** DMA off
  678.  
  679. Loop1: loop Loop1    ;[5]
  680.  
  681.     mov dx,bp    ;[2] Get pointer to ch A control reg
  682.     mov al,bh    ;[2] Select register
  683.     out dx,al    ;[8]
  684.  
  685.     mov cx,di    ;[2]
  686. Loop2:    loop Loop2    ;[5]
  687.  
  688.     mov dx,si    ;[2] get address of dma enable port
  689.     mov al,ah    ;[2] Enable DMA in between accesses
  690.     out dx,al    ;[8]
  691. ; ******** DMA on - was off for 36 cycles
  692.     nop        ; Leave extra time for XT ram refresh cycle to finish
  693.     nop
  694.     nop
  695.     mov cx,di    ; For loop below
  696.     mov al,0    ; now disable DMA in between accesses
  697.     out dx,al    ;
  698. ; ******** DMA off
  699.  
  700. Loop2a:    loop Loop2a    ;[5]
  701.  
  702.     mov dx,bp    ;[2] Get pointer to ch A control reg
  703.     mov al,bl    ;[2] Output value
  704.     out dx,al    ;[8]
  705.  
  706.     mov cx,di    ;[2]
  707. Loop3:    loop Loop3    ;[5]
  708.  
  709.     mov dx,si    ;[2] get address of dma enable port
  710.     mov al,ah    ;[2] Enable DMA
  711.     out dx,al    ;[8]
  712. ; ******** DMA on - was off for 36 cycles
  713.  
  714.     pop bp
  715.     pop si
  716.     pop di 
  717.     pop dx
  718.     pop cx
  719.     pop ax
  720.     popf
  721.     ret
  722.  
  723. ; Enter with bh = reg
  724.  
  725.     public    rdscc
  726. rdscc:
  727.     pushf
  728.     cli
  729.     push cx
  730.     push dx
  731.     push di
  732.     push si
  733.     push bp
  734.  
  735.     mov di,acc_delay; Save it
  736.  
  737.     mov dx,io_addr    ; Get card address
  738.     add dx,CTL_A    ; Point to channel A control reg
  739.     mov bp,dx    ; Save it
  740.  
  741.     mov dx,io_addr    ; get address of dma enable port
  742.     add dx,DMAEN
  743.     mov si,dx    ; save it
  744.  
  745.     mov cx,di    ; For loop below
  746.  
  747.     mov ax,100h    ; Disable DMA while we touch the scc
  748.     out dx,al
  749. ; ******** DMA off
  750. Loop4:    loop Loop4    ;[5]
  751.  
  752.     mov dx,bp    ;[2] Get address of SCC control reg
  753.     mov al,bh    ;[2] Select register
  754.     out dx,al;    ;[8]
  755.  
  756.     mov cx,di    ;[2]
  757. Loop5:    loop Loop5    ;[5]
  758.  
  759.     mov dx,si    ;[2] get address of dma enable port
  760.     mov al,ah    ;[2] Enable DMA
  761.     out dx,al    ;[8]
  762. ;********* DMA on - was off for 36 cycles
  763.     nop        ; Leave extra time for XT ram refresh cycle to finish
  764.     nop
  765.     nop
  766.     mov cx,di    ; For loop below
  767.     mov al,0
  768.     out dx,al
  769. ;********* DMA off
  770. Loop5a:    loop Loop5a    ;[5]
  771.  
  772.     mov dx,bp    ;[2] Get address of SCC control reg
  773.     in al,dx    ;[8] read register
  774.     mov bl,al    ;[2] save return value
  775.  
  776.     mov cx,di    ;[2]
  777. Loop6:    loop Loop6    ;[5]
  778.  
  779.     mov dx,si    ;[2] get address of dma enable port
  780.     mov al,ah    ;[2] Enable DMA
  781.     out dx,al    ;[8]
  782. ; ******** DMA on - was off for 36 cycles
  783.  
  784.     mov    al,bl    ; recover return value
  785.  
  786.     pop    bp
  787.     pop    si
  788.     pop    di
  789.     pop    dx
  790.     pop    cx
  791.     popf
  792.     ret
  793.  
  794.     public delay8253
  795. delay8253:
  796.     nop
  797.     nop
  798.     nop
  799.     nop
  800.     nop
  801.     ret
  802.  
  803. ; Setup for DMA
  804. ; Initializes certain DMA chip registers - called by setup_rx_dma
  805. ; and setup_tx_dma
  806. ; Enter with cx:bx = buffer, ax = length
  807. ; Writes the dma chip word count reg, dest reg, and the dma page reg
  808. ;
  809.     public setup_dma
  810. setup_dma:
  811.     
  812.     pushf    ; Save interrupt state
  813.     cli    ; Disable interrupts
  814.  
  815.     sub    ax,1    ; adjust length for DMA chip
  816.     push    ax    ; Save it for later
  817.     
  818.     mov    al,Byte Ptr dma_channel ; Disable DMA for this channel
  819.     add    al,DMA_DISABLE
  820.     out    DMA_MASK,al
  821.  
  822.     xor    al,al
  823.     out    DMA_RESETFF,al    ; Reset byte pointer flipflop
  824.  
  825. ; Calculate high order 4 bits of the buffer area and store
  826. ; them in the DMA page register
  827.     mov    ax,cx    ; Make a working copy of the seg reg
  828.     shl    ax,1
  829.     shl    ax,1
  830.     shl    ax,1
  831.     shl    ax,1
  832.     add    ax,bx    ; add offset - we have bottom word of abs. address
  833.     pushf        ; Save carry bit
  834.     mov    dx,dma_dest    ; Output buf start (source) address
  835.     out    dx,al
  836.     mov    al,ah
  837.     out    dx,al
  838.     mov    ax,cx    ; Get another copy of the seg reg
  839.     mov    cl,12    ; shift it down
  840.     shr    ax,cl    ; to get page register
  841.     popf        ; Recover carry bit
  842.     adc    ax,0    ; add any carry from previous add
  843.  
  844.     mov    dx,page_addr    ; Set up DMA page register
  845.     out    dx,al
  846.  
  847.     mov    dx,dma_wcr    ; Get address of word count register
  848.     pop    ax        ; Recover length and output it
  849.     out    dx,al
  850.     mov    al,ah
  851.     out    dx,al
  852.  
  853.     popf    ; restore interrupt state
  854.     ret
  855.  
  856. ; Setup receive dma
  857. ; Enter with cx:bx = buffer, ax = length
  858. ;
  859.     public    setup_rx_dma
  860. setup_rx_dma:
  861.     pushf    ; Save interrupt state
  862.     cli    ; Disable interrupts
  863.  
  864.     call    setup_dma
  865.  
  866. ; Get ready for RX DMA
  867.     mov    bx,R1+WT_FN_RDYFN+WT_RDY_RT+INT_ERR_Rx+EXT_INT_ENAB
  868.     call    wrtscc
  869.  
  870. ; Set DMA mode register to single transfers, incrementing address,
  871. ; auto init, writes
  872.     mov    al,dma_channel    ; Put dma chip in transmit for this channel
  873.     add    al,DMA_RX_MODE
  874.     out    DMA_MODE,al
  875.  
  876. ; Unmask channel n (enable DMA controller chip)
  877.     mov    al,Byte Ptr dma_channel ; Enable DMA for this channel
  878.     add    al,DMA_ENABLE
  879.     out    DMA_MASK,al
  880.  
  881. ; If a packet is already coming in, this line is supposed
  882. ; to mess up the crc to avoid receiving a partial packet
  883.     mov    bx,R0+RES_Rx_CRC
  884.     call    wrtscc
  885.  
  886. ; Enable RX dma in SCC chip
  887.     mov    bx,R1+WT_RDY_ENAB+WT_FN_RDYFN+WT_RDY_RT+INT_ERR_Rx+EXT_INT_ENAB
  888.     call    wrtscc
  889.     popf
  890.     ret
  891.  
  892. ;
  893. ; Set up for transmit DMA
  894. ; Enter with cx:bx = buffer, ax = length
  895. ;
  896.     public    setup_tx_dma
  897. setup_tx_dma:
  898.     pushf    ; Save interrupt state
  899.     cli    ; Disable interrupts
  900.     call    setup_dma
  901. ; Set DMA mode register to single transfers, incrementing address,
  902. ; no auto init, reads
  903.     mov    al,dma_channel    ; Put dma chip in transmit for this channel
  904.     add    al,DMA_TX_MODE
  905.     out    DMA_MODE,al
  906.     popf
  907.     ret
  908.  
  909.  
  910. ; Set up 8253 chip for time delay
  911. ; enter with time to delay (mS) in ax
  912. ;
  913.     public    tdelay
  914. tdelay:
  915.     push    bx
  916.     push    cx
  917.     push    dx
  918.  
  919.     push    ax            ; Save delay time
  920.     mov    dx,io_addr
  921.     add    dx,TMRCMD
  922.     mov    al,SC1+LSB_MSB+MODE0    ; Setup timer sc
  923.     out    dx,al
  924.     call delay8253            ; Satisy access time restriction
  925.  
  926.     mov    dx,io_addr
  927.     add    dx,TMR1
  928.     pop    ax            ; Recover delay time
  929.     sal    ax,1            ; Times 2 to make milliseconds
  930.     out    dx,al            ; Write low byte
  931.     call delay8253
  932.     mov    al,ah
  933.     out    dx,al            ; then high byte
  934.  
  935.     mov    bx,R15+CTSIE         ; Enable interrupt for timeout
  936.     call    wrtscc
  937.     mov    bx,R1+EXT_INT_ENAB
  938.     call    wrtscc
  939.     mov    bx,R0+RES_EXT_INT
  940.     call    wrtscc
  941.     
  942.     pop    dx
  943.     pop    cx
  944.     pop    bx
  945.     ret
  946.  
  947.     public    tx_off
  948. tx_off:
  949.     pushf
  950.     cli
  951.     push    bx
  952.  
  953.     mov    bx,R5+Tx8+DTR            ; TX off
  954.     call    wrtscc
  955.  
  956.     mov    ax,speed    ; Internally clocked?
  957.     cmp    ax,0
  958.     jz    tx_off_1    ; Externally clocked, don't change BRG
  959.     mov    ax,clkmode    ; Clocking mode 1?
  960.     cmp    ax,1
  961.     jz    tx_search    ; Mode 1, don't change BRG
  962.                 ; But enter search mode
  963. ; Reprogram BRG for 32x clock for receive DPLL
  964.     mov    bx,R14+BRSRC    ; BRG off, keep Pclk source
  965.     call    wrtscc
  966.     mov    ax,rx_tc    ; Get receive time constant for BRG
  967.     mov    bx,R12        ; Write low byte of time constant to R12
  968.     mov    bl,al
  969.     call    wrtscc
  970.     mov    ax,rx_tc    ; Get receive time constant for BRG
  971.     mov    bx,R13        ; Write high byte of time constant to R13
  972.     mov    bl,ah
  973.     call    wrtscc
  974. tx_search:
  975.     mov    bx,R14+BRSRC+SEARCH ; SEARCH mode, BRG source
  976.     call    wrtscc
  977.     mov    bx,R14+BRSRC+BRENABL ; Enable the baud rate generator
  978.     call    wrtscc
  979. tx_off_1:
  980.     mov    bx,R3+RxENABLE+RxCRC_ENAB+Rx8    ; RX on
  981.     call    wrtscc
  982.     
  983.     push    cs        ; Set up RX DMA
  984.     pop    cx
  985.     mov    bx,rxbufptr
  986.     mov    ax,cs:bufsiz
  987.     call    setup_rx_dma
  988.  
  989.     mov    bx,R15+BRKIE
  990.     call    wrtscc        ; allow abort interrupt
  991.  
  992.     pop    bx
  993.     popf
  994.     ret
  995.  
  996.     public    tx_on
  997. tx_on:
  998.     pushf
  999.     cli
  1000.     push    bx
  1001.  
  1002.     mov    bx,R15+0    ; Exints off first to avoid abort interrupt
  1003.     call    wrtscc
  1004.     mov    bx,R3+Rx8    ; Rx off
  1005.     call    wrtscc
  1006.     mov    bx,R1+WT_FN_RDYFN+EXT_INT_ENAB    ; Set up for TX DMA
  1007.     call    wrtscc
  1008.     mov    ax,speed    ; Internally clocked?
  1009.     cmp    ax,0
  1010.     jz    tx_on_1        ; Externally clocked, don't change BRG
  1011.     mov    ax,clkmode    ; Clocking mode 1?
  1012.     cmp    ax,1
  1013.     jz    tx_on_1        ; Clocking mode 1, don't change BRG
  1014.     mov    ax,tx_tc    ; Get transmit time constant for BRG
  1015.     mov    bx,R12        ; Write low byte of time constant to R12
  1016.     mov    bl,al
  1017.     call    wrtscc
  1018.     mov    ax,tx_tc    ; Get transmit time constant for BRG
  1019.     mov    bx,R13        ; Write high byte of time constant to R13
  1020.     mov    bl,ah
  1021.     call    wrtscc
  1022. tx_on_1:
  1023.     mov    bx,R5+TxCRC_ENAB+RTS+TxENAB+Tx8+DTR
  1024.     call    wrtscc
  1025.  
  1026.     pop    bx
  1027.     popf
  1028.     ret
  1029.  
  1030.     include    popf.asm
  1031.  
  1032.     public    timer_isr
  1033. timer_isr:
  1034. ;if the first instruction is an iret, then the timer is not hooked
  1035.     iret
  1036.  
  1037. ;any code after this will not be kept.  Buffers used by the program, if any,
  1038. ;are allocated from the memory between end_resident and end_free_mem.
  1039.     public end_resident,end_free_mem
  1040. end_resident    label    byte
  1041.     db    30000 dup(?)
  1042. end_free_mem    label    byte
  1043.  
  1044.  
  1045. ; Initialize the SCC registers
  1046.     public scc_init
  1047. scc_init:
  1048.     pushf
  1049.     cli
  1050.  
  1051.     mov    cs:tstate,IDLE
  1052.     mov    bx,R9+CHRA    ; reset channel A
  1053.     call    wrtscc
  1054.     mov    bx,R2+0ffh    ; Set interrupt vector
  1055.     call    wrtscc
  1056.     mov    bx,R1+0        ; Deselect all Rx and Tx interrupts
  1057.     call    wrtscc
  1058.     mov    bx,R15+0    ; Turn off external interrupts
  1059.     call    wrtscc
  1060.     mov    bx,R4+SDLC+X1CLK ; SDLC mode and times 1 clock
  1061.     call    wrtscc
  1062.  
  1063.     mov    ax,speed    ; Get baud rate
  1064.     cmp    ax,0
  1065.     jz    scc_init_1    ; Jump if externally clocked
  1066.     mov    ax,clkmode    ; Clocking mode 1?
  1067.     cmp    ax,1
  1068.     jnz    scc_init_5    ; No - must be internal clocking
  1069.  
  1070.     mov    bx,R10+CRCPS ; Clock mode 1, CRC preset, not NRZI mode
  1071.     call    wrtscc
  1072.             ; Receive clock = RTxC pin
  1073.             ; Transmit clock = baud rate generator
  1074.             ; Transmit clock is output on TRxC pin 
  1075.     mov    bx,R11+TCBR+RCRTxCP+TRxCOI+TRxCTC
  1076.     call    wrtscc     
  1077.     jmp    scc_init_2
  1078.  
  1079. scc_init_5:
  1080.     mov    bx,R10+CRCPS+NRZI ; Internal clock, CRC preset, NRZI mode
  1081.     call    wrtscc
  1082.             ; Receive clock = DPLL
  1083.             ; Transmit clock = baud rate generator
  1084.             ; Transmit clock is output on TRxC pin 
  1085.     mov    bx,R11+TCBR+RCDPLL+TRxCOI+TRxCTC
  1086.     call    wrtscc     
  1087.     jmp    scc_init_2
  1088. scc_init_1:            ; Externally clocked
  1089.     mov    bx,R10+CRCPS    ; CRC preset
  1090.     call    wrtscc
  1091.             ; Receive clock = RTxC pin
  1092.             ; TRxC pin is input for transmit clock
  1093.     mov    bx,R11+TCTRxCP    ; Rcv clk is from Rtxcl, TRxC pin is input
  1094.     call    wrtscc
  1095.  
  1096. scc_init_2:
  1097.     mov    bx,R6+0        ; Null out SDLC start address
  1098.     call    wrtscc
  1099.     mov    bx,R7+FLAG    ; SDLC flag
  1100.     call    wrtscc
  1101.     mov    bx,R5+Tx8+DTR    ; Set up tx but don't enable it yet
  1102.     call    wrtscc
  1103.     mov    bx,R3+Rx8    ; Initial rx setup
  1104.     call    wrtscc
  1105.     mov    bx,R14+BRSRC
  1106.     call    wrtscc
  1107.  
  1108.     mov    ax,rx_tc    ; Get receive time constant for BRG
  1109.     mov    bx,R12        ; Write low byte of time constant to R12
  1110.     mov    bl,al
  1111.     call    wrtscc
  1112.     mov    ax,rx_tc    ; Get receive time constant for BRG
  1113.     mov    bx,R13        ; Write high byte of time constant to R13
  1114.     mov    bl,ah
  1115.     call    wrtscc
  1116.  
  1117.     mov    ax,speed    ; Internal clocking?
  1118.     cmp    ax,0
  1119.     jz    scc_init_3    ; Jump if External
  1120.     mov    ax,clkmode
  1121.     cmp    ax,1
  1122.     jnz    t1
  1123.  
  1124.     mov    bx,R14+BRSRC+SSRTxC+BRENABL
  1125.     call    wrtscc
  1126.     jmp scc_init_4
  1127.     
  1128. t1:
  1129.     mov    bx,R14+BRSRC+SSBR+BRENABL
  1130.     call    wrtscc
  1131.     jmp scc_init_4
  1132. scc_init_3:
  1133.     mov    bx,R14+BRSRC+SSRTxC ; Set DPLL source = RTxC
  1134.     call    wrtscc
  1135. scc_init_4:
  1136.     call    tx_off        ; Set up and enable RX
  1137.  
  1138.     popf
  1139.     ret
  1140.  
  1141. ;  This routine calculates the constant to be used in the delay loops
  1142. ;  which satisfy the SCC's access recovery time.  This needs to be timed and
  1143. ;  calculated because a fixed value would not work in a 4.77mhz XT
  1144. ;  to a 40mhz 486 (and beyond).
  1145.     public set_acc_delay
  1146. set_acc_delay:
  1147.     pushf
  1148.     cli
  1149.     push    ax
  1150.     push    bx
  1151.     push    cx
  1152.     push    dx
  1153.  
  1154.     mov    cx,1000
  1155.  
  1156.     mov    al,0            ;latch counter zero.
  1157.     out    43h,al
  1158.     in    al,40h            ;read counter zero.
  1159.     mov    ah,al
  1160.     in    al,40h
  1161.     xchg    ah,al
  1162.     mov    tick1,ax
  1163.  
  1164. h1:    loop    h1
  1165.  
  1166.     mov    al,0            ;latch counter zero.
  1167.     out    43h,al
  1168.     in    al,40h            ;read counter zero.
  1169.     mov    ah,al
  1170.     in    al,40h
  1171.     xchg    ah,al
  1172.     mov    tick2,ax
  1173.     mov    ax,tick1
  1174.     sub    ax,tick2
  1175.     mov    diff,ax    ; Elapsed counts
  1176.     mov    bx,ax
  1177.     mov    dx,0
  1178.     mov    ax,5000    ; Divide by
  1179.     div    bx    ; the number of counts elapsed
  1180.     cmp    al,0
  1181.     jne    set_acc_2
  1182.     mov    al,1    ; Delay constant must be at least 1
  1183. set_acc_2:
  1184.     xor    ah,ah
  1185.     mov    acc_delay,ax
  1186.  
  1187.     mov di, offset acc_delay    ; Processor speed constant
  1188.     mov dx,    offset acc_delay_name    ; Message for it
  1189.     call    print_number
  1190.  
  1191.     pop    dx
  1192.     pop    cx
  1193.     pop    bx
  1194.     pop    ax
  1195.     popf
  1196.     ret
  1197.  
  1198.     public    usage_msg
  1199. usage_msg    db    "usage: pi <packet_int_no> [hardware_irq] [io_addr] [dma] [baud] [TXD] [P] [slot] [tail] [clock mode] [buf size] [number of buffers]",CR,LF,'$'
  1200.  
  1201.     public    copyright_msg
  1202. copyright_msg    db    "Packet driver for the Ottawa PI card, version ",'0'+majver,".",'0'+version,CR,LF
  1203.         db    "Portions Copyright 1991, 1992 Dave Perry",CR,LF,'$'
  1204.  
  1205. int_no_name    db    "Interrupt number ",'$'
  1206. io_addr_name    db    "I/O port ",'$'
  1207. dma_name    db    "DMA channel ",'$'
  1208. acc_delay_name    db    "Processor constant ",'$'
  1209. diff_name    db    "diff ",'$'
  1210. tick1_name    db    "tick1 ",'$'
  1211. tick2_name    db    "tick2 ",'$'
  1212. speed_name    db    "Baud rate ",'$'
  1213. txdelay_name    db    "TX delay ",'$'
  1214. persist_name    db    "P value ",'$'
  1215. slottime_name    db    "Slot time ",'$'
  1216. tailtime_name    db    "Tail time ",'$'
  1217. clkmode_name    db    "Clocking mode ",'$'
  1218. bufsiz_name    db    "Buffer size ",'$'
  1219. numbufs_name    db    "Number of buffers ",'$'
  1220. baud_err_msg    db    "Error: Selected baud rate is out of range",CR,LF,'$'
  1221. no_memory_msg    db    "Unable to allocate enough memory, look at end_resident in PI.ASM",CR,LF,'$'
  1222.  
  1223.     extrn    set_recv_isr: near
  1224.  
  1225. ;enter with si -> argument string, di -> wword to store.
  1226. ;if there is no number, don't change the number.
  1227.     extrn    get_number: near
  1228.  
  1229. ;enter with dx -> argument string, di -> wword to print.
  1230.     extrn    print_number: near
  1231.  
  1232. ;-> the assigned Ethernet address of the card.
  1233.     extrn    rom_address: byte
  1234.  
  1235.     public    parse_args
  1236. parse_args:
  1237. ;exit with nc if all went well, cy otherwise.
  1238.     mov    di,offset int_no    ; May override interrupt channel
  1239.     call    get_number
  1240.     mov    di,offset io_addr    ; May override I/O address
  1241.     call    get_number
  1242.     mov    di,offset dma_channel    ; May override channel
  1243.     call    get_number
  1244.     mov    di,offset speed        ; May override speed
  1245.     call    get_number
  1246.     mov    di,offset txdelayparm    ; May override TX delay time
  1247.     call    get_number
  1248.     mov    di,offset persist    ; May override P value
  1249.     call    get_number
  1250.     mov    di,offset slottime    ; May override Slot time
  1251.     call    get_number
  1252.  
  1253. ; Calculate address of dma page register
  1254.     mov    al,Byte Ptr dma_channel
  1255.     cmp    al,2
  1256.     jne    parse_1
  1257.     mov    ax,81h
  1258.     jmp    parse_3
  1259. parse_1:
  1260.     cmp    al,3
  1261.     jne    parse_2
  1262.     mov    ax,82h
  1263.     jmp    parse_3
  1264. parse_2:
  1265.     mov    ax,83h
  1266. parse_3:
  1267.     mov    page_addr,ax
  1268.  
  1269. ; Calculate address of dma destination and dma word count regs
  1270.     mov    ax,Word Ptr dma_channel
  1271.     shl    ax,1
  1272.     mov    dma_dest,ax
  1273.     add    ax,1
  1274.     mov    dma_wcr,ax
  1275.     
  1276. ; Calculate time constants for baud rate generator
  1277.     mov    ax,word ptr speed
  1278.     cmp    ax,0
  1279.     jz    parse_4
  1280.  
  1281.     mov    dx,1ch        ; Load SCC clock freq into dx:ax
  1282.     mov    ax,2000h    
  1283.     div    speed        ; Divide by baud rate
  1284.     sub    ax,2        ; sub 2 - this is the BRG time constant
  1285.     mov    tx_tc,ax    ; for Transmit - save it
  1286.  
  1287.     mov    dx,0h        ; Load SCC clock freq/32 into dx:ax
  1288.     mov    ax,0e100h    
  1289.     div    speed        ; Divide by baud rate
  1290.     sub    ax,2        ; sub 2 - this is the BRG time constant
  1291.     mov    rx_tc,ax    ; for receive - save it
  1292.  
  1293. ; Calculate tail time. This is the time required for the CRC and closing
  1294. ; flag to be sent, during which the transmitter must be held on.
  1295.     mov    dx,0        ; Magic number
  1296.     mov    ax,8ca0h
  1297.     div    speed
  1298.     add    ax,1        ; Tail time is at least 1 ms
  1299.     mov    tailtime,ax
  1300. parse_4:
  1301.     mov    di,offset tailtime    ; May override Tail time
  1302.     call    get_number
  1303.  
  1304.     mov    di,offset clkmode    ; May override clocking mode
  1305.     call    get_number
  1306.  
  1307.     mov    di,offset bufsiz    ; May override buffer size
  1308.     call    get_number
  1309.     mov    ax,bufsiz
  1310.     mov    parm_mtu,ax
  1311.  
  1312.     mov    di,offset numbufs    ; May override number of buffers
  1313.     call    get_number
  1314.     cmp    numbufs,3        ; But we need at least 3
  1315.     jge    parse_4a
  1316.     mov    numbufs,3
  1317. parse_4a:
  1318.  
  1319.     clc    ; Return without error
  1320.     ret
  1321.  
  1322. baud_error:
  1323.     mov    dx,offset baud_err_msg
  1324.     mov    ah,9
  1325.     int    21h
  1326.     stc
  1327.     ret
  1328.  
  1329. ; Return offset of a buffer which does not cross a DMA page boundary.
  1330. ; Returns nc, ax=offset of buffer, or cy if no mem. Buffers are in code segment.
  1331.     public getbuffer
  1332. getbuffer:
  1333.     push    dx
  1334.     push    cx
  1335.     push    bx
  1336.  
  1337.     mov    ax,cs        ; get buffer segment
  1338.     mov    cx,ax
  1339.  
  1340. get1:    mov    ax,cs:bufsiz
  1341.     add    ax,4        ; Leave room for next pointer and length
  1342.     mov    dx,ax
  1343.     call    malloc
  1344.     jc    get_exit
  1345.     mov    bx,dx
  1346.     call    test_buffer
  1347.     jnc    get_exit    ; found one
  1348.     add    numbufs,1    ; Account for it
  1349.     
  1350.     pop    bx
  1351.     pop    cx
  1352.     pop    dx
  1353.     jmp    getbuffer
  1354. get_exit:
  1355.     mov    ax,dx        ; recover pointer
  1356.  
  1357.     pop    bx
  1358.     pop    cx
  1359.     pop    dx
  1360.     ret            ; return buffer found
  1361.  
  1362.     public    etopen
  1363. etopen:
  1364.  
  1365. ; Not meaningful for AX25 class - this code assumes DIX ethernet
  1366. ;get the address of the interface.
  1367.     mov    si,offset etheraddr
  1368.     movseg    es,ds
  1369.     mov    di,offset rom_address
  1370.     mov    cx,EADDR_LEN
  1371.     rep    movsb
  1372.  
  1373. ; Set up DMA buffer pool
  1374.     mov    cx,numbufs    ; We want this many
  1375. et1:
  1376.     call    getbuffer    ; Get a DMA buffer
  1377.     jc    etopen_error
  1378.     mov    bx,offset freelist    ; Append it to the free list
  1379.     call    enqueue
  1380.     loop    et1
  1381.  
  1382.     mov    bx,offset freelist    ; Get a buffer from the freelist
  1383.     call    dequeue
  1384.     jc    etopen_error    ; None left
  1385.     mov    bufptr1,ax    ; Remember as primary
  1386.     mov    rxbufptr,ax    ; Make it current
  1387.  
  1388.     mov    bx,offset freelist    ; Get a buffer from the freelist
  1389.     call    dequeue
  1390.     jc    etopen_error    ; None left
  1391.     mov    bufptr2,ax    ; Use it for secondary rx buffer
  1392.  
  1393. ; Adjust scc delay for speed of host cpu
  1394.     call    set_acc_delay
  1395.  
  1396.     mov    bx,R9+FHWRES    ; Hardware reset SCC
  1397.     call    wrtscc
  1398.  
  1399. ; Disable interrupts with Master interrupt ctrl reg */
  1400.     mov    bx,R9+0
  1401.     call    wrtscc
  1402.     call    scc_init
  1403.     mov    bx,R9+MIE+NV ; master interrupt enable
  1404.     call    wrtscc
  1405.  
  1406. ; Set up counter chip
  1407.     mov    dx,io_addr
  1408.     add    dx,TMRCMD
  1409.     mov    al,SC0+LSB_MSB+MODE3 ; 500 uS square wave
  1410.     out    dx,al
  1411.     call delay8253        ; Satisfy access time restriction
  1412.     mov    ax,922        ; time constant
  1413.     mov    dx,io_addr
  1414.     add    dx,TMR0
  1415.     out    dx,al        ; LSB
  1416.     call delay8253        ; Satisy access time restriction
  1417.     mov    al,ah
  1418.     out    dx,al        ; MSB
  1419.     call delay8253        ; Satisy access time restriction
  1420.  
  1421.     call    set_recv_isr    ; Hook the board int
  1422. ;if all is okay,
  1423.     clc
  1424.     ret
  1425. etopen_error:
  1426.     mov    dx,offset no_memory_msg
  1427.     stc
  1428.     ret
  1429.  
  1430. dma_page_save    dw    0
  1431. dma_dest_save    dw    0
  1432. dma_wcr_save    dw    0
  1433. ; Test a buffer to see if it crosses a DMA page boundary.
  1434. ; Enter with cx:bx = buffer, ax = length
  1435.     public test_buffer
  1436. test_buffer:
  1437.     sub    ax,1    ; adjust length for DMA chip
  1438.     mov    dma_wcr_save,ax ; Save it for the dma_wcr register
  1439.     
  1440. ; Calculate high order 4 bits of the buffer area and store
  1441. ; them in the DMA page register
  1442.     mov    ax,cx    ; Make a working copy of the seg reg
  1443.     shl    ax,1
  1444.     shl    ax,1
  1445.     shl    ax,1
  1446.     shl    ax,1
  1447.     add    ax,bx    ; add offset - we have bottom word of abs. address
  1448.     pushf        ; Save carry bit
  1449.     mov    dma_dest_save,ax ; save this for the dma_dest register
  1450.  
  1451.     mov    ax,cx    ; Get another copy of the seg reg
  1452.     mov    cl,12    ; shift it down
  1453.     shr    ax,cl    ; to get page register
  1454.     popf        ; Recover carry bit
  1455.     adc    ax,0    ; add any carry from previous add
  1456.     mov    dma_page_save,ax ; Save this for the dma_page register
  1457.  
  1458. ; Now do the test: add the buffer size to the destination address
  1459. ; and see if we're still in the same page
  1460.     mov    ax,dma_dest_save ; recover bottom 16 bits of absolute addr
  1461.     add    ax,cs:bufsiz    ; add the buffer size
  1462.                 ; if carry is set, we spilled over the page
  1463.     ret            ; return carry clear on success
  1464.  
  1465.     public    print_parameters
  1466. print_parameters:
  1467. ;echo our command-line parameters
  1468.     mov di,    offset int_no        ; Interrupt channel
  1469.     mov dx,    offset int_no_name    ; Message for it
  1470.     call    print_number
  1471.     mov di,    offset io_addr        ; I/O address
  1472.     mov dx,    offset io_addr_name    ; Message for it
  1473.     call    print_number
  1474.     mov di,    offset dma_channel    ; DMA channel
  1475.     mov dx,    offset dma_name        ; Message for it
  1476.     call    print_number
  1477.     mov di, offset speed        ; Baud rate
  1478.     mov dx,    offset speed_name 
  1479.     call    print_number
  1480.     mov di, offset txdelayparm    ; TX delay
  1481.     mov dx,    offset txdelay_name
  1482.     call    print_number
  1483.     mov di, offset persist        ; P persistance 
  1484.     mov dx,    offset persist_name
  1485.     call    print_number
  1486.     mov di, offset slottime        ; Slot time
  1487.     mov dx,    offset slottime_name
  1488.     call    print_number
  1489.     mov di, offset tailtime        ; Tail time
  1490.     mov dx,    offset tailtime_name
  1491.     call    print_number
  1492.     mov di, offset clkmode        ; Clocking mode
  1493.     mov dx,    offset clkmode_name
  1494.     call    print_number
  1495.     mov di, offset bufsiz        ; Buffer size
  1496.     mov dx,    offset bufsiz_name
  1497.     call    print_number
  1498.     mov di, offset numbufs        ; Number of buffers
  1499.     mov dx,    offset numbufs_name
  1500.     call    print_number
  1501.  
  1502.     ret
  1503.  
  1504. code    ends
  1505.  
  1506.     end
  1507.