home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-387-Vol-3of3.iso / t / twindv21.zip / TWIN_DR.C < prev    next >
C/C++ Source or Header  |  1992-09-12  |  53KB  |  2,035 lines
  1. /****************************************************************************
  2. *
  3. *            COPYRIGHT 1990,91,92 BY GRACILIS INC.
  4. *
  5. *             623 Palace St.
  6. *             Aurora, Il. 60506
  7. *
  8. *             (708)-801-8800        Office
  9. *             (708)-844-0183        (FAX - Support BBS)
  10. *
  11. * GRACILIS, INC., MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS 
  12. * SOFTWARE FOR ANY PURPOSE.  
  13. *
  14. * THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
  15. * 
  16. * Permission is granted for non-commercial use/distribution only, as long as
  17. * this copyright header is included intact and unaltered.
  18. *
  19. ******************************************************************************/
  20.  
  21. /****************************************************************************
  22. *
  23. *
  24. * File: twin_dr.c
  25. *
  26. * Rev : 3.0
  27. *
  28. * Description:    
  29. *
  30. *    This File contains routines that implement PackeTwin
  31. *    synchronous SCC driver with an interface to KA9Q's TCP/IP suite.
  32. *
  33. *
  34. * Routines: 
  35. *
  36. *    tsync_raw    - Applications' routine for transmitting
  37. *                   a message via tsync_driver.
  38. *
  39. *    tsync_stop   - Stop I/O
  40. *
  41. *    tsync_recv   - Applications' routine for receiving a message
  42. *                   from the tsync_driver.   Left over from NET.
  43. *
  44. *    
  45. *    tsync_hwinit - Initialize the SCC chip for synchronous operation.
  46. *
  47. *    tsync_txisr  - Handles transmit interrupts.
  48. *
  49. *    tsync_rxisr  - Handles receive interrupts.
  50. *
  51. *    tsync_xstatisr - Handles the SCC's external status interrupts.
  52. *
  53. *    transon      - Turn-on transmitter and turn-off receiver or
  54. *                   turn-off transmitter and turn-on receiver.
  55. *                   Will change txstate.  Also
  56. *                   handles time delays needed for data set 
  57. *                   control signals (RTS).
  58. *
  59. *
  60. * Revision History:
  61. *
  62. *    Release 2.0        - 9/7/92    First Release of cleaned up Twin driver
  63. *                                with fewer files, and called twin_at instead
  64. *                                of tsync_at
  65. *
  66. *    Release 2.1        - 9/12/92    Fix bug in half-duplex dma mode, which caused
  67. *                                loss of every other receive frame in a multi-
  68. *                                frame transmission.  
  69. */
  70.  
  71.  
  72. #include <stdio.h>
  73. #include <dos.h>
  74. #include "global.h"
  75. #include "config.h"
  76. #include "hardware.h"
  77. #include "mbuf.h"
  78. #include "iface.h"
  79. #include "ax25.h"
  80. #include "trace.h"
  81. #include "proc.h"
  82. #include "pktdrvr.h"
  83. #include "z8530.h"
  84. #include "gracilis.h"
  85. #include "twin.h"
  86.  
  87.  
  88. #ifdef TSYNC_DEBUG
  89. unsigned char Lastint;
  90. #endif
  91.  
  92. #ifdef SCOPE_LOOP
  93. unsigned char scope_state = 0;
  94. #endif
  95.  
  96.  
  97. /* interrupt handler */
  98. extern INTERRUPT twinvec();
  99.  
  100. INTERRUPT (*Twin_oldvec) __ARGS((void)); /* Old vector contents */
  101. INTERRUPT (*Twin_handler) __ARGS((void)) = { twinvec };  
  102.  
  103. char            *Twin_dvr_version = "2.1";
  104. unsigned int     Twin_io_base = 0x230; 
  105. int16            Twin_vector;
  106. int             Twin_cputype;
  107.  
  108. /* The pwait/psignal inter-process communication wake-up array */
  109. /* for getting pre-allocated receive buffers */
  110. int  Twin_bufpp[5];
  111.  
  112. /* The pwait/psignal inter-process communication wake-up array */
  113. /* for kicking the transmitter */
  114. int  Twin_kickpp[5];
  115.  
  116. /* The pwait/psignal inter-process communication wake-up array */
  117. /* for free-ing transmitted messages */
  118. int  Twin_freetxpp[5];
  119.  
  120.  
  121. extern    void tsync_txisr();
  122.  
  123. uchar            Twin_sercfg = 0;        /* image of the SERIAL_CFG port */
  124. uchar            Twin_dmacfg = 0;        /* image of the DMA_CFG port */
  125.  
  126. /* Master device control blocks for the Tsync drivers... */
  127. UNI_DCB Twin_udcb[2] = {
  128.     FALSE, 0, NULL, NULL, NULL, NULL, NULL,    
  129.     FALSE, 0, NULL, NULL, NULL, NULL, NULL,    
  130. };
  131.  
  132. /* a simple delay instruction... */
  133. int    nop1;
  134. #define nop nop1++;
  135.  
  136. /* Send raw packet */
  137. int
  138. tsync_raw(intfp, mbufp)
  139. register struct iface *intfp;
  140. register struct mbuf *mbufp;
  141. {
  142.     register DCB *dcbp;
  143.     register struct drvbuf *xbufp ;
  144.     int16  msgsize;
  145.     char i_state;
  146.     void tsync_txisr();
  147.     int16 len_p();
  148.  
  149. #ifdef TSYNC_DEBUG_PRT
  150.     int16  pullsize;
  151. #endif
  152.  
  153. #ifdef OLD_KA9Q
  154.     dump(intfp, IF_TRACE_OUT, CL_AX25, mbufp);
  155. #else
  156.     dump(intfp,IF_TRACE_OUT,mbufp);
  157. #endif
  158.  
  159.     dcbp = (DCB *)Twin_udcb[intfp->dev].dcbp;
  160.  
  161.     /* get packet's transmission size */
  162.     msgsize = len_p(mbufp);
  163.  
  164.     xbufp = (struct drvbuf *)malloc(sizeof(struct drvbuf) + msgsize);
  165.  
  166.     /* If no memory for buffering... then dump the packet on floor */
  167.     /* and return error to caller */
  168.     if(xbufp == (struct drvbuf *)NULL)
  169.     {
  170.         free_p(mbufp);
  171.         return(-1);
  172.     }
  173.  
  174.  
  175.     xbufp->msgsize = msgsize;
  176.     xbufp->next = (struct drvbuf *)NULLBUF;
  177.  
  178. #ifdef TSYNC_DEBUG_PRT
  179.     if ( (pullsize = dqdata(mbufp, &(xbufp->buf), msgsize+1)) != msgsize )
  180.     {   /* somethings wrong.  should have gotten all of message */
  181.         printf("tsync_raw error wanted %d bytes pullup-up got only %d\n",
  182.                msgsize, pullsize);
  183.     }
  184. #else    
  185.     /* there will be no check for mismatching msgsize and pullsize */
  186.     dqdata(mbufp, &(xbufp->buf), msgsize);
  187. #endif
  188.  
  189.     /* now enqueue the message !!! */
  190.     i_state = dirps();
  191.     if ( dcbp->xmtq == (struct drvbuf *)NULLBUF )
  192.     {
  193.         dcbp->xmtq = dcbp->xmtqtail = xbufp;
  194.     }
  195.     else
  196.     {
  197.         dcbp->xmtqtail->next = xbufp;
  198.         dcbp->xmtqtail = xbufp;
  199.     }
  200.  
  201.     /* Note tsync_txisr must be able to run from ISR level as well */
  202.     /* as from "task" level, since tsync_raw is called from task */
  203.     /* level */
  204.  
  205.     /* Only if the transmitter is not doing anything then call it */
  206.  
  207.     if ( dcbp->txstate == IDLE )tsync_txisr(dcbp);        
  208.  
  209.     restore(i_state);
  210.  
  211.     return(0);
  212. }
  213.  
  214. /* 
  215.  * Master interrupt handler.  One interrupt at a time is handled.
  216.  * here. Service routines are called from here.
  217.  *
  218.  * This 8530 interrupt handler will take care of both async and
  219.  * sync drivers' interrupts.
  220.  */
  221.  
  222. /******************************************************/
  223. /* 85230 Mods:                                        */
  224. /******************************************************/
  225. /* NOTE: This interrupt handler is constructed to get */
  226. /*         around a bug in the Zilog 85c230 while          */
  227. /*         still allowing use of it's advanced FIFOs     */
  228. /*                                                    */
  229. /*        The basic bug is as follows...                   */
  230. /*            If an interrupt driver is written for the */
  231. /*            85230, which does NOT make use of the     */
  232. /*            automatic vector generation facilities    */
  233. /*            provided by RR2,      AND.....            */
  234. /*             If RR1 is used as the ONLY means of       */
  235. /*            identifying the End of a received frame,  */
  236. /*            then the 85230 will mis-report the EOF    */
  237. /*          when the 1st byte of a CRC is read from   */
  238. /*             the receive FIFO, resulting in checking   */
  239. /*            the CRC status flag at the wrong time.    */
  240. /*          This of course then indicates a CRC       */
  241. /*            error, and results in the driver          */
  242. /*          discarding an otherwise good frame...     */
  243. /*                                                      */
  244. /*        The FIX:                                      */
  245. /*            The Basic idea here is to simulate the    */
  246. /*          use of true VECTORED interrupts.          */
  247. /*                                                    */
  248. /*            First look for a pending interrupt in     */
  249. /*            RR3, then read the VECTOR which would     */
  250. /*            have been generated IF we were using      */
  251. /*             vectored interrupts.  Dispatch to the     */
  252. /*            appropriate handler routine.                */
  253. /*                                                      */
  254. /*        The reason this approach works is that the    */
  255. /*         Special Receive condition interrupt VECTOR    */
  256. /*         is not asserted until AFTER the first CRC     */
  257. /*        byte is read from the FIFO.  This is the      */
  258. /*        expected behaviour, and allows the programmer */
  259. /*         to read the second CRC byte, and know that    */
  260. /*         he/she may appropriately check the CRC status */
  261. /*      indicator, for the completed frame.           */
  262. /*        Additionally, it is known at this point that  */
  263. /*        the last two bytes received are the CRC bytes */
  264. /*      which must be discarded, since they are not   */
  265. /*        a part of the user data frame.                */
  266. /*                                                    */
  267. /* MORAL: Dont believe RR1's end of received frame    */
  268. /*        indication, until you have first waited     */
  269. /*        for a SPECIAL RECEIVE CONDITION VECTOR      */
  270. /*        to be asserted... or YOU'll be SORRY!!!     */
  271. /******************************************************/
  272. void
  273. tsync_entpt()
  274. {
  275.     register char st;
  276.  
  277. #ifdef notdef
  278.     char    i_state;
  279. #endif
  280.  
  281.     register DCB  *dcbp;
  282.     register int16    ctl;
  283.     register unsigned intreg;
  284.     struct drv_timer *tblk;
  285.     void    (*timer_func)();
  286.  
  287. #ifdef notdef
  288.     i_state = dirps();
  289. #endif
  290.  
  291.     intreg = inportb( Twin_io_base + INT_REG);
  292.     
  293.     while((intreg & (0x07)) != 0x07 )
  294.     {
  295.  
  296.  
  297.       /* Read interrupt pending register from channel A */
  298.       while(Twin_read_scc( Twin_io_base+SCCA_CMD,R3) != 0 ) 
  299.       {
  300.         /* Get interrupt vector info from Channel B RR2 */
  301.           st = (Twin_read_scc( Twin_io_base+SCCB_CMD,R2) & 0x0E);
  302.  
  303. #ifdef TSYNC_DEBUG
  304.         Lastint = st;
  305. #endif
  306.         switch(st)
  307.         {
  308.             case    VEC_CHB_TBE:
  309.                 /* Channel B Transmit Int Pending */
  310.                 dcbp = (DCB *)Twin_udcb[TWINCOMM2].dcbp;
  311.                 /* milt tsync_txisr(dcbp); */
  312.                 /* Call the Transmit Buffer Empty Handler */
  313.                 (*(Twin_udcb[TWINCOMM2].prev_vec2))(dcbp);
  314.                 ctl = (int16)(Twin_io_base+SCCB_CMD);
  315.                 break;
  316.  
  317.             case    VEC_CHB_XTS:
  318.                 /* Channel B External Status Int */
  319.                 dcbp = (DCB *)Twin_udcb[TWINCOMM2].dcbp;
  320.                 /* milt tsync_xstatisr(dcbp); */
  321.                 /* Call the External Status Change Handler */
  322.                 (*(Twin_udcb[TWINCOMM2].prev_vec4))(dcbp);
  323.                 ctl = (int16)(Twin_io_base+SCCB_CMD);
  324.                 break;
  325.  
  326.             case    VEC_CHB_RCAV:
  327.                 /* Channel B Rcv Interrupt Pending */
  328.                 dcbp = (DCB *)Twin_udcb[TWINCOMM2].dcbp;
  329.                 /* milt tsync_rxisr(dcbp); */
  330.                 /* Call the Receive Character Available Handler */
  331.                 (*(Twin_udcb[TWINCOMM2].prev_vec3))(dcbp);
  332.                 ctl = (int16)(Twin_io_base+SCCB_CMD);
  333.                 break;
  334.  
  335.             case    VEC_CHB_SRC:
  336.                 /* Channel B Special Rcv Int Pending */
  337.                 dcbp = (DCB *)Twin_udcb[TWINCOMM2].dcbp;
  338.                 /* milt tsync_rxisr(dcbp); */
  339.                 /* Call the Special Receive Condition Handler */
  340.                 (*(Twin_udcb[TWINCOMM2].prev_vec3))(dcbp);
  341.                 ctl = (int16)(Twin_io_base+SCCB_CMD);
  342.                 break;
  343.  
  344.             case    VEC_CHA_TBE:
  345.                 /* Channel A Transmit Int Pending */
  346.                 dcbp = (DCB *)Twin_udcb[TWINCOMM1].dcbp;
  347.                 /* milt tsync_txisr(dcbp); */
  348.                 /* Call the Transmit Buffer Empty Handler */
  349.                 (*(Twin_udcb[TWINCOMM1].prev_vec2))(dcbp);
  350.                 ctl = (int16)(Twin_io_base+SCCA_CMD);
  351.                 break;
  352.  
  353.             case    VEC_CHA_XTS:
  354.                 /* Channel A External Status Int */
  355.                 dcbp = (DCB *)Twin_udcb[TWINCOMM1].dcbp;
  356.                 /* milt tsync_xstatisr(dcbp); */
  357.                 /* Call the External Status Change Handler */
  358.                 (*(Twin_udcb[TWINCOMM1].prev_vec4))(dcbp);
  359.                 ctl = (int16)(Twin_io_base+SCCA_CMD);
  360.                 break;
  361.  
  362.             case    VEC_CHA_RCAV:
  363.                 /* Channel A Rcv Interrupt Pending */
  364.                 dcbp = (DCB *)Twin_udcb[TWINCOMM1].dcbp;
  365.                 /* milt tsync_rxisr(dcbp); */
  366.                 /* Call the Receive Character Available Handler */
  367.                 (*(Twin_udcb[TWINCOMM1].prev_vec3))(dcbp);
  368.                 ctl = (int16)(Twin_io_base+SCCA_CMD);
  369.                 break;
  370.  
  371.             case    VEC_CHA_SRC:
  372.                 /* Channel A Special Rcv Int Pending */
  373.                 dcbp = (DCB *)Twin_udcb[TWINCOMM1].dcbp;
  374.                 /* milt tsync_rxisr(dcbp); */
  375.                 /* Call the Special Receive Condition Handler */
  376.                 (*(Twin_udcb[TWINCOMM1].prev_vec3))(dcbp);
  377.                 ctl = (int16)(Twin_io_base+SCCA_CMD);
  378.                 break;
  379.         }
  380.  
  381.         /* Reset highest interrupt under service */
  382. #ifdef TSYNC_DEBUG
  383.         Twin_write_scc(ctl,R0,(dcbp->wr0 = RES_H_IUS));
  384. #else
  385.         Twin_write_scc(ctl,R0,RES_H_IUS);
  386. #endif
  387.       }
  388.  
  389.       if(!(intreg & PKTWIN_TMR1_MSK))
  390.       {
  391.         dcbp = (DCB *)Twin_udcb[TWINCOMM1].dcbp;
  392.         tblk = dcbp->timer1;
  393.         /* Now clear the timer interrupt */
  394.         inportb(Twin_io_base + CLR_TMR1);
  395.  
  396.         /* Now perform the timer's requested function */
  397.         if(tblk->thandler != NULL)
  398.         {
  399.             timer_func = tblk->thandler;
  400.             tblk->thandler = (void (*)())NULL;
  401.             (timer_func)(tblk->targ);
  402.         }
  403.       }
  404.  
  405.  
  406.       if(!(intreg & PKTWIN_TMR2_MSK))
  407.       {
  408.         dcbp = (DCB *)Twin_udcb[TWINCOMM2].dcbp;
  409.         tblk = dcbp->timer1;
  410.         /* Now clear the timer interrupt */
  411.         inportb(Twin_io_base + CLR_TMR2);
  412.  
  413.         /* Now perform the timer's requested function */
  414.         if(tblk->thandler != NULL)
  415.         {
  416.             timer_func = tblk->thandler;
  417.             tblk->thandler = (void (*)())NULL;
  418.             (timer_func)(tblk->targ);
  419.         }
  420.  
  421.       }
  422.  
  423.       intreg = inportb( Twin_io_base + INT_REG);
  424.  
  425.     }
  426.  
  427. #ifdef notdef
  428. /* Dont need this... causewe only got here though an int... */
  429.     restore(i_state);
  430. #endif
  431. }
  432.  
  433.  
  434. /* 
  435.  * External/Status interrupts caused by a receiver abort, 
  436.  * a Transmit UNDERRUN/EOM.   
  437.  * SCC enters hunt mode on  an abort.
  438.  *
  439.  * On a Transmit Underrun, change state and
  440.  * issue a reset command for it, and return.
  441.  */
  442. void        
  443. tsync_xstatisr(dcbp)
  444. register DCB *dcbp;
  445. {
  446.     register uchar     scc_stat,newstat,new_xbits;
  447.  
  448.     /* find out why the external/status interrupt occurred */
  449.      scc_stat = Twin_read_scc(dcbp->zhwmap.ctl,R0);    
  450.  
  451. /* 9/23/91 DGL Try to fix possible race condition */
  452.     /* reset external status latch  to enable future changes to catch us */
  453.  
  454. #ifdef TSYNC_DEBUG
  455.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = RES_EXT_INT)); 
  456. #else
  457.     Twin_write_scc(dcbp->zhwmap.ctl,R0,RES_EXT_INT); 
  458. #endif
  459.  
  460.     new_xbits = scc_stat ^ dcbp->extreg;
  461.  
  462.     /* Check for Tx UNDERRUN/EOM  */
  463.     if(new_xbits & TxEOM ) 
  464.     {
  465.         if(dcbp->dma_flg == TRUE)
  466.         {
  467.             /* Disable this DMA channel */
  468.             outportb(DMAWSMR,dcbp->dma_tx_chan | 0x04);
  469.  
  470.             dcbp->txstate = TX_DONE;
  471.  
  472.             /* update the xmit data tally*/
  473.             dcbp->txbytecnt += dcbp->cur_xbytes;
  474.  
  475.               /* don't allow Underruns to interrupt us */
  476.             Twin_write_scc(dcbp->zhwmap.ctl,R15,(dcbp->wr15 &= ~0x40));
  477.             /* set the TxEOM bit in the image */
  478.             dcbp->extreg |= TxEOM;
  479.  
  480.  
  481.             /* enable the tx empty interrupt... */
  482.             /* so it can catch us if necessary */
  483.             /* This handles condition where the buffer */
  484.             /* goes empty while we're checking... */
  485.             /* Avoid's a race. 9/23/91 */
  486. #ifdef TSYNC_DEBUG
  487.             Twin_write_scc(dcbp->zhwmap.ctl,R1,(dcbp->wr1 = 0xfb));
  488. #else
  489.             Twin_write_scc(dcbp->zhwmap.ctl,R1,0xfb);
  490. #endif
  491.  
  492.             /* Now check to see if the CRC has already cleared */
  493.             /* the SCC's xmit buffer... */
  494.             newstat = Twin_read_scc(dcbp->zhwmap.ctl,R0);    
  495.  
  496.             /* If so, turn off the tx empty interrupt we just enabled */
  497.             /* and process the end of frame condition */
  498.             if(newstat & Tx_BUF_EMP) 
  499.             {
  500.                 /* Rx and Extern ints on : No Tx ints */
  501. #ifdef TSYNC_DEBUG
  502.                 Twin_write_scc(dcbp->zhwmap.ctl,R1,(dcbp->wr1 = 0xf9));  
  503. #else
  504.                 Twin_write_scc(dcbp->zhwmap.ctl,R1,0xf9);  
  505. #endif
  506.  
  507.                 tsync_txisr(dcbp);
  508.             }
  509.  
  510.             /* else... it will happen under interrupt ctl */
  511.             /* when the buffer goes empty */
  512.  
  513.         }
  514.  
  515.         else 
  516.         {
  517.             /* set the TxEOM bit in the image */
  518.             dcbp->extreg |= TxEOM;
  519.  
  520.  
  521.             if((dcbp->txstate == TX_ACTIVE) || (dcbp->txstate == CRCING))
  522.             {
  523.                 dcbp->txstate = TX_DONE;
  524.  
  525.                   /* don't allow Underruns to interrupt us */
  526.                    Twin_write_scc(dcbp->zhwmap.ctl,R15,(dcbp->wr15 &= ~0x40));
  527.  
  528.  
  529.                 /* if unexpected... bump transmit underrun counts */
  530.                 if( dcbp->cur_xbytes > 0 ) 
  531.                 {
  532.                     dcbp->txunderun++;
  533.                 }
  534.  
  535.                 /* enable the tx empty interrupt... */
  536.                 /* so it can catch us if necessary */
  537.                 /* This handles condition where the buffer */
  538.                 /* goes empty while we're checking... */
  539.                 /* Avoid's a race. 9/23/91 */
  540. #ifdef TSYNC_DEBUG
  541.                 Twin_write_scc(dcbp->zhwmap.ctl,R1,(dcbp->wr1 = 0x13));
  542. #else
  543.                 Twin_write_scc(dcbp->zhwmap.ctl,R1,0x13);
  544. #endif
  545.  
  546.                 /* check to see if the CRC has already cleared */
  547.                 /* the SCC's xmit buffer... */
  548.                 newstat = Twin_read_scc(dcbp->zhwmap.ctl,R0);    
  549.  
  550.                 /* If so, turn off the tx empty interrupt we just enabled */
  551.                 /* and process the end of frame condition */
  552.                 if(newstat & Tx_BUF_EMP) 
  553.                 {
  554. #ifdef TSYNC_DEBUG
  555.                     Twin_write_scc(dcbp->zhwmap.ctl,R1,(dcbp->wr1 = 0x11));
  556. #else
  557.                     Twin_write_scc(dcbp->zhwmap.ctl,R1,0x11);
  558. #endif
  559.                     tsync_txisr(dcbp);
  560.                 }
  561.  
  562.                 /* else... it will happen under interrupt ctl */
  563.  
  564.             }
  565.         }
  566.  
  567.     }
  568.  
  569.     /* Receive Mode only
  570.      * This triggers when hunt mode is entered, & since an ABORT
  571.      * automatically enters hunt mode, we use that to clean up
  572.      * any waiting garbage
  573.      */
  574.     if(new_xbits & BRK_ABRT )
  575.     {
  576.         if(scc_stat & BRK_ABRT ) dcbp->extreg |= BRK_ABRT;
  577.         else dcbp->extreg &= ~BRK_ABRT;
  578.         dcbp->rxstate = RXABORT;
  579.         dcbp->rxabortcnt++;       /* bump aborts */
  580.  
  581.         /* No  more Abort interrupts  */
  582. #ifdef notdef
  583.         Twin_write_scc(dcbp->zhwmap.ctl,R15,(dcbp->wr15 &= ~(0x80)));         
  584. #endif
  585.         if(dcbp->dma_flg == TRUE)
  586.         {
  587.             rxprime_dma(dcbp,0);    /* restart for a new frame */ 
  588.         }
  589.         else
  590.         {
  591.             /* reset err latch */
  592. #ifdef TSYNC_DEBUG
  593.             Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = ERR_RES));    
  594. #else
  595.             Twin_write_scc(dcbp->zhwmap.ctl,R0,ERR_RES);    
  596. #endif
  597.             /* read and toss any  data */
  598.             inportb(dcbp->zhwmap.data);
  599.             inportb(dcbp->zhwmap.data);
  600.             inportb(dcbp->zhwmap.data);
  601.             inportb(dcbp->zhwmap.data);
  602.  
  603.             /* make sure dcbp->rxbufp has a data buffer to work with!!! */
  604.             dcbp->rxcurp = dcbp->rxbufp->data;
  605. #ifdef OLD_KA9Q
  606.             dcbp->rxbufp->cnt = sizeof(struct phdr);
  607. #else
  608.             dcbp->rxbufp->cnt = 0;
  609. #endif
  610.             /* resync the receiver... */
  611. #ifdef TSYNC_DEBUG
  612.             Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xf9));         
  613. #else
  614.             Twin_write_scc(dcbp->zhwmap.ctl,R3,0xf9);         
  615. #endif
  616.  
  617.         }
  618.     }
  619.     if(new_xbits & DCD )
  620.     {
  621.         if((scc_stat & DCD) == 0)
  622.         {
  623.             dcbp->extreg &= ~DCD;
  624.             if(dcbp->dma_flg == TRUE)
  625.             {
  626.                 rxprime_dma(dcbp,0);    /* restart for a new frame */
  627.             }
  628.             else
  629.             {
  630.                 /* reset err latch */
  631. #ifdef TSYNC_DEBUG
  632.                 Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0=ERR_RES));    
  633. #else
  634.                 Twin_write_scc(dcbp->zhwmap.ctl,R0,ERR_RES);    
  635. #endif
  636.                 /* read and toss any  data */
  637.                 inportb(dcbp->zhwmap.data);
  638.                 inportb(dcbp->zhwmap.data);
  639.                 inportb(dcbp->zhwmap.data);
  640.                 inportb(dcbp->zhwmap.data);
  641.  
  642.                 /* make sure dcbp->rxbufp has a data buffer to work with!!! */
  643.                 dcbp->rxcurp = dcbp->rxbufp->data;
  644. #ifdef OLD_KA9Q
  645.                 dcbp->rxbufp->cnt = sizeof(struct phdr);
  646. #else
  647.                 dcbp->rxbufp->cnt = 0;
  648. #endif
  649.                 /* resync the receiver... */
  650.                 /* Rx 8 bit/chars, enter hunt mode, CRC enable */
  651. #ifdef TSYNC_DEBUG
  652.                 Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xf9));         
  653. #else
  654.                 Twin_write_scc(dcbp->zhwmap.ctl,R3,0xf9);         
  655. #endif
  656.  
  657.             }
  658.         }
  659.         else    dcbp->extreg |= DCD;
  660.     }
  661.  
  662.     if(new_xbits & CTS )
  663.     {
  664.         if((scc_stat & CTS) == 0)
  665.         {
  666.             dcbp->extreg &= ~CTS;
  667.  
  668.             dcbp->txctslost++;
  669.  
  670.             if((dcbp->txstate == TX_ACTIVE) || (dcbp->txstate == CRCING))
  671.             {
  672.                 dcbp->txstate = TX_DONE;
  673.  
  674.                   /* don't allow Underruns to interrupt us */
  675.                    Twin_write_scc(dcbp->zhwmap.ctl,R15,(dcbp->wr15 &= ~0x40));
  676.  
  677.  
  678.                 /* if unexpected... bump transmit underrun counts */
  679.                 if( dcbp->cur_xbytes > 0 ) 
  680.                 {
  681.                     dcbp->txunderun++;
  682.                 }
  683.  
  684.                 /* Toss the frame being sent, and continue... */
  685.                 tsync_txisr(dcbp);
  686.  
  687.             }
  688.         }
  689.         else    dcbp->extreg |= CTS;
  690.     }
  691.  
  692. #ifdef notdef        /* fix race 9/23/91 */
  693.  
  694.     /* reset external status latch */
  695. #ifdef TSYNC_DEBUG
  696.     Twin_write_scc(dcbp->zhwmap.ctl,R0,(dcbp->wr0 = RES_EXT_INT)); 
  697. #else
  698.     Twin_write_scc(dcbp->zhwmap.ctl,R0,RES_EXT_INT); 
  699. #endif
  700.  
  701. #endif
  702.  
  703.     return;
  704. }
  705. /*
  706.  * end of tsync_xstatisr
  707.  ******************************************************************/
  708.  
  709.  
  710. /*
  711.  * Receive ISR. 
  712.  * The first receive buffer is pre-allocated
  713.  * in the init routine.  Thereafter, it is filled here, queued out, and a
  714.  * new one acquired.  CRC, OVERRUN and TOOBIG errors merely 'rewind' the
  715.  * pointers and reuse the same buffer.
  716.  */
  717. void
  718. tsync_rxisr(dcbp)
  719. register DCB *dcbp;
  720. {
  721.     register int16 ctl;
  722.     int16 data;
  723.     struct mbuf *f_dequeavail();
  724.     void tsync_srcisr();
  725.     void empty_scc();
  726.     unsigned char    vecmsk;
  727.  
  728.     /* If this channel is a DMA channel handle it elsewhere */
  729.     if(dcbp->dma_flg == TRUE)
  730.     {
  731.             tsync_rxdmaisr(dcbp);
  732.             return;
  733.     }
  734.  
  735.     /* speed up access to 8530 regs */
  736.     ctl = dcbp->zhwmap.ctl;
  737.     data = dcbp->zhwmap.data;
  738.  
  739.  
  740.     /* Get interrupt vector info from Channel B RR2 */
  741.       vecmsk = (Twin_read_scc( Twin_io_base+SCCB_CMD,R2) & 0x0E);
  742.  
  743.     /* If this is an SRC interrupt... handle it that way... */
  744.     if((vecmsk == VEC_CHA_SRC) || (vecmsk == VEC_CHB_SRC))
  745.     {
  746.             tsync_srcisr(dcbp);
  747.             return;
  748.     }    
  749.  
  750.  
  751.     /* Check status of receive interrupt */
  752.     if(Twin_read_scc(ctl,R0) & Rx_CH_AV)
  753.     {
  754.  
  755.         /* get char and store it */
  756.         *dcbp->rxcurp++ = inportb(data);    
  757.  
  758.         /* tally data byte received */
  759.         dcbp->rxbytecnt++;
  760.  
  761.         /* Allow aborts to get us after we receive a first char */
  762. #ifdef OLD_KA9Q
  763.         if(dcbp->rxbufp->cnt == sizeof(struct phdr))
  764. #else
  765.         if(dcbp->rxbufp->cnt == 0)
  766. #endif
  767.         {
  768.             /* allow Aborts to interrupt us. */
  769.             Twin_write_scc(ctl,R15,(dcbp->wr15 |= 0x80));         
  770.         }
  771.  
  772.         /* bump count & check for TOOBIG frames... */
  773. #ifdef OLD_KA9Q
  774.         if ((++dcbp->rxbufp->cnt) >= (dcbp->rxbufsize+sizeof(struct phdr))) 
  775. #else
  776.         if ((++dcbp->rxbufp->cnt) >= dcbp->rxbufsize) 
  777. #endif
  778.         {
  779.             /* dump buffer - incoming packet is too big */
  780.             dcbp->rxtruncnt++;
  781.  
  782.             /* read all the data out of the rx fifo... */
  783.             /* and TOSS it.. */
  784.             empty_scc(ctl,data);
  785.  
  786.             /* reset buf "pointers" - dump data */
  787.             dcbp->rxcurp = dcbp->rxbufp->data;
  788. #ifdef OLD_KA9Q
  789.             dcbp->rxbufp->cnt = sizeof(struct phdr);
  790. #else
  791.             dcbp->rxbufp->cnt = 0;
  792. #endif
  793.             /* restart the receiver in HUNT  MODE... */
  794.             /* to resync it... */
  795. #ifdef TSYNC_DEBUG
  796.             Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xf9));         
  797. #else
  798.             Twin_write_scc(dcbp->zhwmap.ctl,R3,0xf9);         
  799. #endif
  800.         }
  801.  
  802.     }
  803.  
  804.     return;
  805. }
  806. /*
  807.  * end of tsync_rxisr
  808.  ****************************************************************/
  809.  
  810.  
  811. /****************************************************************/
  812. /* Special Receive Condition Interrupt Handler... */
  813. /****************************************************************/
  814. void
  815. tsync_srcisr(dcbp)
  816. register DCB *dcbp;
  817. {
  818.     unsigned char rx1stat;
  819.     struct mbuf *tmpbufp;
  820.     struct mbuf *f_dequeavail();
  821.     void empty_scc();
  822.     register int16 ctl;
  823.     int16 data;
  824.  
  825.         /* speed up access to 8530 regs */
  826.         ctl = dcbp->zhwmap.ctl;
  827.         data = dcbp->zhwmap.data;
  828.  
  829.         /* Per ZILOG... only read R1 when R0 says there is */
  830.         /* a char waiting... */
  831.         /* get status byte from R1 */
  832.  
  833.     if(Twin_read_scc(ctl,R0) & Rx_CH_AV)
  834.     {
  835.         rx1stat = Twin_read_scc(ctl,R1); 
  836.  
  837.         /* empty the 2nd CRC char */
  838.         inportb(data);    
  839.  
  840.         /* The End of Frame bit is ALWAYS associated with a character,
  841.          * usually, it is the last CRC char.  Only when EOF is true can
  842.          * we look at the CRC byte to see if we have a valid frame
  843.          */
  844.         dcbp->rxpackcnt++;
  845.  
  846.         /* No  Abort interrupts  */
  847.         Twin_write_scc(ctl,R15,(dcbp->wr15 &= ~(0x80)));         
  848.  
  849.         /* END OF FRAME -- Make sure Rx was active */
  850.         if(rx1stat & END_FR)
  851.         {
  852.             /* got a packet - check for CRC error */
  853.             if ( (rx1stat & CRC_ERR) || 
  854. #ifdef OLD_KA9Q
  855.                  (dcbp->rxbufp->cnt < (sizeof(struct phdr) + 10)) ) 
  856. #else
  857.                  (dcbp->rxbufp->cnt <  10 ) )
  858. #endif
  859.             {
  860.                 /* error occurred; toss frame */
  861.                 if (( rx1stat & CRC_ERR ) && 
  862. #ifdef OLD_KA9Q
  863.                         (dcbp->rxbufp->cnt  >= (sizeof(struct phdr) + 10)))
  864. #else
  865.                         (dcbp->rxbufp->cnt  >= 10) )
  866. #endif
  867.                                 dcbp->rxcrcerrcnt++;    /* bump CRC errs */
  868.  
  869.                 /* read all data out of the rx fifo...*/
  870.                 /* and TOSS it.. */
  871.                 empty_scc(ctl,data);
  872.  
  873.                 /* reusing the old data buffer "dumps" the data */
  874.  
  875.                 /* restart the receiver in HUNT  MODE... */
  876.                 /* to resync it... */
  877. #ifdef TSYNC_DEBUG
  878.                 Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xf9));         
  879. #else
  880.                 Twin_write_scc(dcbp->zhwmap.ctl,R3,0xf9);         
  881. #endif
  882.             }
  883.             else 
  884.             {
  885.                 /* Got a valid packet !! */
  886.  
  887.                 /* get next buffer */ 
  888.                 tmpbufp = f_dequeavail(&dcbp->rxavailq, &dcbp->rxavailcount);
  889.  
  890.                 if ( tmpbufp != NULLBUF )
  891.                 {
  892.  
  893.                     /* dump crc bytes, i.e. '-1' */
  894.                     dcbp->rxbufp->cnt -= 1;           
  895.  
  896.                     /* new for NOS */
  897.                     /* adjust for packet header */
  898. #ifdef OLD_KA9Q
  899.                     dcbp->rxbufp->data -= sizeof(struct phdr);
  900.                     enqueue(&Hopper, dcbp->rxbufp);
  901. #else
  902.                     net_route(dcbp->iface,dcbp->rxbufp);
  903. #endif
  904.                     /* bump packets rreceived */
  905.                     /* successfully */
  906.                     dcbp->rxnqued++;
  907.  
  908.                     dcbp->rxbufp = tmpbufp;
  909.                 }
  910.  
  911.                 /* No buffers available... */
  912.                 /* re-use old buffer - dump data */
  913.                 else dcbp->nobufs++;
  914.  
  915.                 /* signal the process which */
  916.                 /* allocates the rx buffers */
  917.                 psignal(&Twin_bufpp[dcbp->dev],1);
  918.  
  919.             } /* end good packet > 10 long received */
  920.     
  921.         }    /* End of FRAME */
  922.  
  923.         /* Not EOF... check for overrun */
  924.         else if (rx1stat & Rx_OVR) 
  925.         {
  926.             /* Rx overrun - toss buffer */
  927.             /* reset buffer pointers */
  928.             dcbp->rxovercnt++;    /* bump overruns */
  929.  
  930.             /* read all data out of the rx fifo...*/
  931.             /* and TOSS it.. */
  932.             empty_scc(ctl,data);
  933.  
  934.             /* reuse old rx buffer.. */
  935.             /* restart the receiver in HUNT  MODE... */
  936.             /* to resync it... */
  937. #ifdef TSYNC_DEBUG
  938.             Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xf9));         
  939. #else
  940.             Twin_write_scc(dcbp->zhwmap.ctl,R3,0xf9);         
  941. #endif
  942.         }
  943.  
  944.         /* regardless of why we terminating/restarting... */
  945.         /* make sure dcbp->rxbufp has a data buffer!!! */
  946.         dcbp->rxcurp = dcbp->rxbufp->data;
  947. #ifdef OLD_KA9Q
  948.         dcbp->rxbufp->cnt = sizeof(struct phdr);
  949. #else
  950.         dcbp->rxbufp->cnt = 0;
  951. #endif
  952.  
  953.  
  954.         /* reset err latch */
  955. #ifdef TSYNC_DEBUG
  956.         Twin_write_scc(ctl,R0,(dcbp->wr0 = ERR_RES));    
  957. #else
  958.         Twin_write_scc(ctl,R0,ERR_RES);    
  959. #endif
  960.     }
  961. }
  962.  
  963.  
  964.  
  965.  
  966.  
  967. /* read the SCC channel till no more data in receiver... */
  968. void
  969. empty_scc(ctl,data)
  970. int16    ctl,data;
  971. {
  972.  
  973.         while(Twin_read_scc(ctl,R0) & Rx_CH_AV)
  974.         {
  975.             /* get char and toss it */
  976.             inportb(data);    
  977.         }                
  978. }
  979.  
  980.  
  981. /*
  982.  * DMA Receive ISR. 
  983.  * The first receive buffer is pre-allocated
  984.  * in the init routine.  Thereafter, it is filled here, queued out, and a
  985.  * new one acquired.  CRC, OVERRUN and TOOBIG errors merely 'rewind' the
  986.  * pointers and reuse the same buffer.
  987.  */
  988. tsync_rxdmaisr(dcbp)
  989. register DCB *dcbp;
  990. {
  991.     register int16 ctl;
  992.     register int16 dmacnt;
  993.     char rxstat;
  994.     int16    rxbytecnt;
  995.     struct mbuf *f_dequeavail();
  996.     struct mbuf *tmpbufp;
  997.  
  998.     /* mask off this DMA channel */
  999.     outportb(DMAWSMR,(dcbp->dma_rx_chan | 0x04));
  1000.  
  1001.     /* speed up access to 8530 regs */
  1002.     ctl = dcbp->zhwmap.ctl;
  1003.  
  1004.     /* Check status of receive interrupt */
  1005.     rxstat = Twin_read_scc(ctl,R1); /* get status byte from R1 */
  1006.  
  1007.     /* clear the DMA byte ptr FF */
  1008.     outportb(DMAFFCL,00);
  1009.  
  1010.     /* Rx overrun - toss data by reusing the buffer */
  1011.     if (rxstat & Rx_OVR ) dcbp->rxovercnt++;    /* bump overruns */
  1012.  
  1013.     /* The End of Frame bit is ALWAYS associated with a character,
  1014.      * usually, it is the last CRC char.  Only when EOF is true can
  1015.      * we look at the CRC byte to see if we have a valid frame
  1016.      */
  1017.  
  1018.     /* CRC error occurred; toss frame */
  1019.     else if ((rxstat & (CRC_ERR|END_FR)) == (CRC_ERR|END_FR) )
  1020.     {
  1021.         dcbp->rxpackcnt++;
  1022.         dcbp->rxcrcerrcnt++;
  1023.     }
  1024.     else if( rxstat & END_FR ) 
  1025.     {
  1026.         /* Disable further Abort interrupts  */
  1027.         Twin_write_scc(ctl,R15,(dcbp->wr15 &= ~(0x80)));         
  1028.  
  1029.         dcbp->rxpackcnt++;
  1030.  
  1031.         /* calculate # of bytes received less CRC */
  1032.         dmacnt = inportb(dcbp->dma_rx_cnt_reg);    
  1033.         dmacnt += (inportb(dcbp->dma_rx_cnt_reg) << 8);    
  1034.  
  1035.  
  1036.         rxbytecnt = (dcbp->rxbufsize-1) - dmacnt;
  1037.  
  1038.         dcbp->rxbufp->cnt += rxbytecnt;
  1039.  
  1040.         /* # of data bytes received... Not including CRC's */
  1041.         dcbp->rxbytecnt += rxbytecnt-2;
  1042.  
  1043.         /* Make sure Rx was active */
  1044. #ifdef OLD_KA9Q
  1045.         if ( dcbp->rxbufp->cnt > sizeof(struct phdr) )  
  1046. #else
  1047.         if ( dcbp->rxbufp->cnt > 0)
  1048. #endif
  1049.         {    /* then bytes have been received */
  1050.  
  1051. #ifdef OLD_KA9Q
  1052.             if ( dcbp->rxbufp->cnt >= (sizeof(struct phdr)+10) ) 
  1053. #else
  1054.             if ( dcbp->rxbufp->cnt >= 10 ) 
  1055. #endif
  1056.             {
  1057.                 /* Got a valid packet !! */
  1058.  
  1059.                 /* get next buffer */ 
  1060.                 tmpbufp = f_dequeavail(&dcbp->rxavailq, &dcbp->rxavailcount);
  1061.  
  1062.                 if ( tmpbufp != NULLBUF )
  1063.                 {
  1064.  
  1065.                     /* dump crc bytes, i.e. '-2' */
  1066.                     dcbp->rxbufp->cnt -= 2;           
  1067.                     /* new for NOS */
  1068.                     /* adjust for packet header */
  1069. #ifdef OLD_KA9Q
  1070.                     dcbp->rxbufp->data -= sizeof(struct phdr);
  1071.                     enqueue(&Hopper, dcbp->rxbufp);
  1072. #else
  1073.                     net_route(dcbp->iface,dcbp->rxbufp);
  1074. #endif
  1075.                     /* bump packets rreceived */
  1076.                     /* successfully */
  1077.                     dcbp->rxnqued++;
  1078.  
  1079.                     dcbp->rxbufp = tmpbufp;
  1080.                 }
  1081.  
  1082.                 /* No buffers available... */
  1083.                 /* re-use old buffer - dump data */
  1084.                 else dcbp->nobufs++;
  1085.  
  1086.                 /* signal the process which */
  1087.                 /* allocates the rx buffers */
  1088.                 psignal(&Twin_bufpp[dcbp->dev],1);
  1089.  
  1090.             } /* end good packet > 10 long received */
  1091.  
  1092.         }  /* received frame with > 0 chars */
  1093.  
  1094.     } /* end END_FR check */
  1095.  
  1096.     rxprime_dma(dcbp,0);
  1097.  
  1098.     return;
  1099. }
  1100. /*
  1101.  * end of tsync_rxdmaisr
  1102.  ****************************************************************/
  1103.  
  1104.  
  1105. /***********************************************************/
  1106. /* 9/12/92 {dgl} Added "rxinit" arg to allow the caller to */
  1107. /* specify whether or not to "re-enable" the receiver.     */
  1108. /* This fixed loss of back to back packets in hdx dma mode */
  1109. /* See bug description in version history                    */
  1110. /***********************************************************/
  1111. rxprime_dma(dcbp,rxinit)
  1112. register DCB *dcbp;
  1113. int    rxinit;
  1114. {
  1115.     register int16 ctl;
  1116.     ulong realaddr;
  1117.     unsigned page;
  1118.  
  1119.     /* speed up access to 8530 regs */
  1120.     ctl = dcbp->zhwmap.ctl;
  1121.  
  1122.     /* make sure dcbp->rxbufp has data!!! */
  1123.     dcbp->rxcurp = dcbp->rxbufp->data;
  1124. #ifdef OLD_KA9Q
  1125.     dcbp->rxbufp->cnt = sizeof(struct phdr);
  1126. #else
  1127.     dcbp->rxbufp->cnt = 0;
  1128. #endif
  1129.     /* reset any errors... */
  1130. #ifdef TSYNC_DEBUG
  1131.     Twin_write_scc(ctl,R0,(dcbp->wr0 = ERR_RES));    
  1132. #else
  1133.     Twin_write_scc(ctl,R0,ERR_RES);    
  1134. #endif
  1135.     /* Reprime the dma pump... */
  1136.  
  1137.     /* A rendition of an absolute address for the ptr */
  1138.     realaddr = ((ulong)FP_SEG(dcbp->rxcurp) << 4) + 
  1139.                     (ulong)FP_OFF(dcbp->rxcurp);
  1140.  
  1141.     /* DMA page reg for 8237 */
  1142.     page = realaddr >> 16;
  1143.  
  1144.     outportb(dcbp->dma_rx_pagereg,page);    /* setup 64k page */
  1145.  
  1146.  
  1147.     /* mode setup required if we are in HDX operation */
  1148.     if(dcbp->hduplex == TRUE)
  1149.     {
  1150.         outportb(DMAMODE,dcbp->dma_rx_chan |  RX_DMA);
  1151.         outportb(Twin_io_base+DMA_CFG,dcbp->dma_rx_mode);
  1152.     }
  1153.  
  1154.     /* clear the DMA byte ptr FF */
  1155.     outportb(DMAFFCL,00);
  1156.     
  1157.     /* Max xfer count setup */
  1158.     outportb(dcbp->dma_rx_cnt_reg,dcbp->rxbufsize-1);
  1159.     outportb(dcbp->dma_rx_cnt_reg,((dcbp->rxbufsize-1)>>8));
  1160.  
  1161.     /* destination buffer address */
  1162.     outportb(dcbp->dma_rx_addr_reg,(realaddr & 0xff));
  1163.     outportb(dcbp->dma_rx_addr_reg,((realaddr >> 8) & 0xff));
  1164.  
  1165.     /* If we are in DMA mode/Half duplex: Turn on the recvr */    
  1166.     /* Rx 8 bit/chars, enter hunt mode, CRC enable */
  1167.     /* Autoenables... */
  1168.     if((dcbp->hduplex == TRUE) && (rxinit))
  1169. #ifdef TSYNC_DEBUG
  1170.                 Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xf9));         
  1171. #else
  1172.                 Twin_write_scc(dcbp->zhwmap.ctl,R3,0xf9);         
  1173. #endif
  1174.  
  1175.     /* Enable this DMA channel */
  1176.     outportb(DMAWSMR,dcbp->dma_rx_chan);
  1177.     return;
  1178. }
  1179.  
  1180.  
  1181. /* 
  1182.  * PackTen's SCC transmit interrupt service routine
  1183.  */
  1184. void
  1185. tsync_txisr(dcbp)    
  1186. register DCB  *dcbp;
  1187. {
  1188.     register int16 ctl;
  1189.     register struct drvbuf *btemp;
  1190.     char i_state;
  1191.     void    tsync_persist();
  1192.     void    transon();
  1193.     void    txprime_dma();
  1194.     void    time_wait();
  1195.  
  1196. #ifdef TSYNC_DEBUG
  1197.     int    tstbyt_cnt= 0;
  1198. #endif
  1199.  
  1200.     /* This routine MAY be able to run with ints ENABLED later... */
  1201.     /* We need to investigate... milt / {dgl} */
  1202.     /* NEVER NEVER NEVER!!!!!!!!! */
  1203.     i_state = dirps();
  1204.  
  1205.     /* speedup access to 8530 regs */
  1206.     ctl = dcbp->zhwmap.ctl;
  1207.  
  1208.     switch (dcbp->txstate) {
  1209.  
  1210.     case TX_ACTIVE:
  1211.  
  1212.         /* Here we are actively sending a frame */
  1213.         /* We should only hit this case in NON-DMA modes */
  1214.  
  1215.         /* If there are more bytes to send... */
  1216.         if( dcbp->cur_xbytes > 0 )
  1217.         {
  1218.             /* Try to feed the ESCC/SCC as many bytes as we can */
  1219.             while((Twin_read_scc(ctl,R0) & Tx_BUF_EMP) && (dcbp->cur_xbytes > 0))
  1220.             {
  1221.                 /* send next char and bump the pointer */
  1222.                 outportb(dcbp->zhwmap.data,*dcbp->cur_xbufp++);
  1223.  
  1224.                 /* tally data byte sent */
  1225.                 dcbp->txbytecnt++;
  1226.                 dcbp->cur_xbytes--;
  1227. #ifdef TSYNC_DEBUG
  1228.                 tstbyt_cnt++;
  1229. #endif
  1230.             }
  1231.  
  1232. #ifdef TSYNC_DEBUG
  1233.             if(tstbyt_cnt > dcbp->maxtxbytes)dcbp->maxtxbytes = tstbyt_cnt;
  1234. #endif
  1235.             if(dcbp->cur_xbytes <= 0)
  1236.             {
  1237.  
  1238.                 /* turn-off the xmission of Abort on underrun */
  1239.                 /* To allow the CRC to go out */
  1240. #ifdef TSYNC_DEBUG
  1241.                 if(dcbp->nrzi_flg == TRUE) 
  1242.                         Twin_write_scc(ctl,R10,(dcbp->wr10 = 0xa0));
  1243.                 else Twin_write_scc(ctl,R10,(dcbp->wr10 = 0x80));
  1244. #else
  1245.                 if(dcbp->nrzi_flg == TRUE) 
  1246.                         Twin_write_scc(ctl,R10,0xa0);
  1247.                 else Twin_write_scc(ctl,R10,0x80);
  1248. #endif
  1249.                 /* Sent all the data bytes, now send CRCs */
  1250.                 /* CRCING is a tsync_xstatisr state */
  1251. /*                 dcbp->txstate = CRCING;
  1252. */
  1253.  
  1254.             }
  1255.         }
  1256.  
  1257. #ifdef notdef
  1258.         if( dcbp->cur_xbytes > 0 )
  1259.         {
  1260.  
  1261.                 /* send next char and bump the pointer */
  1262.                 outportb(dcbp->zhwmap.data,*dcbp->cur_xbufp++);
  1263.  
  1264.                 /* tally data byte sent */
  1265.                 dcbp->txbytecnt++;
  1266.  
  1267.                 /* sent a byte */
  1268.                 if((--dcbp->cur_xbytes) <= 0)
  1269.                 {
  1270.  
  1271.                     /* turn-off the xmission of Abort on underrun */
  1272.                     /* To allow the CRC to go out */
  1273. #ifdef TSYNC_DEBUG
  1274.                     if(dcbp->nrzi_flg == TRUE) 
  1275.                                 Twin_write_scc(ctl,R10,(dcbp->wr10 = 0xa0));
  1276.                     else Twin_write_scc(ctl,R10,(dcbp->wr10 = 0x80));
  1277. #else
  1278.                     if(dcbp->nrzi_flg == TRUE) 
  1279.                                 Twin_write_scc(ctl,R10,0xa0);
  1280.                     else Twin_write_scc(ctl,R10,0x80);
  1281. #endif
  1282.                     /* Sent all the data bytes, now send CRCs */
  1283.                     /* CRCING is a tsync_xstatisr state */
  1284. /*                     dcbp->txstate = CRCING;
  1285. */
  1286.  
  1287. /* for slow PCs... */
  1288.                 }
  1289.  
  1290.         }
  1291. #endif
  1292.  
  1293.         else
  1294.         {
  1295.  
  1296. #ifdef TSYNC_DEBUG
  1297.             /* reset Tx int pending  to allow the */
  1298.             /* Underrun/EOM to happen */
  1299.             Twin_write_scc(ctl,R0,(dcbp->wr0 = 0x28));         
  1300.  
  1301.             /* disable tx ints... */
  1302.             Twin_write_scc(ctl,R1,(dcbp->wr1 = 0x11));
  1303. #else
  1304.             /* reset Tx int pending  to allow the */
  1305.             /* Underrun/EOM to happen */
  1306.             Twin_write_scc(ctl,R0,0x28);         
  1307.  
  1308.             /* disable tx ints... */
  1309.             Twin_write_scc(ctl,R1,0x11);
  1310. #endif
  1311.  
  1312.             /* Sent all the data bytes, now send CRCs */
  1313.             /* CRCING is a tsync_xstatisr state */
  1314.             dcbp->txstate = CRCING;
  1315.  
  1316.         }
  1317.         break;
  1318.  
  1319.     case CRCING:    
  1320.  
  1321.             /* reset Tx int pending  to allow the */
  1322.             /* Underrun/EOM to happen */
  1323. #ifdef TSYNC_DEBUG
  1324.             Twin_write_scc(ctl,R0,(dcbp->wr0 = 0x28));         
  1325. #else
  1326.             Twin_write_scc(ctl,R0,0x28);         
  1327. #endif
  1328.             break;
  1329.  
  1330.  
  1331.  
  1332.     case TX_DONE:     /* All done sending a packet... */
  1333.  
  1334. tsync_txdone:
  1335.  
  1336.         /* for slow PCs... reenable the timer ints... */
  1337.         if ((Twin_cputype < 2) && (dcbp->baud >= 9600L)) maskon(0);
  1338.  
  1339.         /* sent a packet */
  1340.         dcbp->txpackcnt++;
  1341.  
  1342.         /* reset Tx int pending */
  1343. #ifdef TSYNC_DEBUG
  1344.         Twin_write_scc(ctl,R0,(dcbp->wr0 = 0x28));         
  1345. #else
  1346.         Twin_write_scc(ctl,R0,0x28);
  1347. #endif
  1348.         /* If we were not called by mistake... */
  1349.         /* I.E. by an underrun with no current buffer... */
  1350.         if(dcbp->xmtq != (struct drvbuf *)NULLBUF)
  1351.         {
  1352.  
  1353.             /* done sending message so move on to next one */
  1354.             if ( dcbp->freem == (struct drvbuf *)NULLBUF )
  1355.             {
  1356.                 dcbp->freem = dcbp->xmtq;
  1357.                 dcbp->xmtq = dcbp->xmtq->next;
  1358.                 dcbp->freem->next = (struct drvbuf *)NULLBUF;
  1359.             }
  1360.             else
  1361.             {
  1362.                 btemp = dcbp->xmtq; /* addr of one to free */   
  1363.                 dcbp->xmtq = btemp->next; /* next one TO BE xmitted */
  1364.                 btemp->next = dcbp->freem; /* one to be freed is queued */
  1365.                 dcbp->freem = btemp; /* now set free head ptr */
  1366.             }
  1367.  
  1368.             /* signal the process which is supposed to free the */
  1369.             /* transmitted message */
  1370.             psignal(&Twin_freetxpp[dcbp->dev],1);
  1371.  
  1372.         }
  1373.  
  1374.         /* Check NEW xmtq */
  1375.         if(dcbp->xmtq == (struct drvbuf *)NULLBUF)
  1376.         { 
  1377.         
  1378.             /* no more msgs to send */
  1379.             dcbp->xmtqtail = (struct drvbuf *)NULLBUF;
  1380.  
  1381.             /* take care of SQUELCH DELAY wait for */
  1382.             /* flag byte to go out */
  1383.             dcbp->txstate = TX_KEYDOWN_DELAY;
  1384.  
  1385. #ifdef notdef
  1386. /* shouldn't need this... if we reset the tx ip bit */
  1387.             /* Turn off Tx ints */
  1388.             if(dcbp->dma_flg == FALSE)Twin_write_scc(ctl,R1,(dcbp->wr1 = 0x11));  
  1389.             else Twin_write_scc(ctl,R1,(dcbp->wr1 = 0xf9));  
  1390.  
  1391. #endif
  1392.  
  1393.             transon(dcbp,OFF);
  1394.         }    
  1395.         else
  1396.         {
  1397.             /* immediately start sending the next msg */
  1398.             dcbp->cur_xbufp = &(dcbp->xmtq->buf);
  1399.             dcbp->cur_xbytes = dcbp->xmtq->msgsize;
  1400.             txprime_dma(dcbp);    /* start sending a frame */
  1401.  
  1402.         }
  1403.         break;
  1404.  
  1405.     case IDLE: /* Transmitter idle. Find a frame for transmission */ 
  1406.         if ( dcbp->xmtq == (struct drvbuf *)NULLBUF ) 
  1407.         {
  1408.             /* totally idle dudes */
  1409.  
  1410.             /* reset Tx int pending */
  1411. #ifdef TSYNC_DEBUG
  1412.             Twin_write_scc(ctl,R0,(dcbp->wr0 = 0x28));         
  1413. #else
  1414.             Twin_write_scc(ctl,R0,0x28);         
  1415. #endif
  1416.             break;
  1417.         }
  1418.         else
  1419.         {
  1420.             /* point to the next message to send */
  1421.             dcbp->cur_xbufp = &(dcbp->xmtq->buf);
  1422.             dcbp->cur_xbytes = dcbp->xmtq->msgsize;
  1423.  
  1424.             dcbp->txstate = DEFER; /* AND FALL THROUGH */
  1425.         }
  1426.     case DEFER:        
  1427.  
  1428.         /* If we are in HALF-DUPLEX mode, then we must wait */
  1429.         /* for a free channel, and be polite about it (ppersist) */
  1430.         /* Otherwise just fire up the transmitter... */
  1431.  
  1432.         if(dcbp->hduplex == TRUE)
  1433.         {
  1434.  
  1435.            /* Check DCD so we don't step on a frame being received */
  1436.            /* DCD is ACTIVE LOW on the SCC DCD pin, but the bit in R0 */
  1437.            /* is SET when DCD is ACTIVE!! */
  1438.  
  1439. #ifdef notdef
  1440. /* This was the way it was released originally...  */
  1441. /* I changed it cause I think this is more robust, if we somehow dropped */
  1442. /* an external status event.... We now poll the CD line to determine if  */
  1443. /* we can send, and if needed, then we also will re_sync the extrn stats reg */
  1444.  
  1445.            if(dcbp->extreg & DCD)
  1446. #endif
  1447.            if ( (Twin_read_scc(dcbp->zhwmap.ctl,R0) & DCD) != 0 ) 
  1448.            { 
  1449.  
  1450.                 /* DGL 9/22/91 */
  1451.                 /* sync_up the extreg, if it somehow gets out of sync */
  1452.                    if(!(dcbp->extreg & DCD)) dcbp->extreg |= DCD;
  1453.  
  1454.  
  1455. #ifdef TSYNC_DEBUG_PRT
  1456.     printf("TSYNC_TXISR: Device num %d DEFER state DCD is not right to xmit \n", dcbp->dev);
  1457. #endif
  1458.                psignal(&Twin_kickpp[dcbp->dev],1);
  1459.                break;
  1460.            }
  1461.  
  1462.            /* DCD is down */
  1463.            if ( (dcbp->ioctlparams->persist & 0x00ff) <= (rand() & 0x00ff) )
  1464.            { /* then have to wait, be a less persistent */
  1465.             dcbp->txstate = TX_PERSIST;
  1466.             time_wait(dcbp,dcbp->timer1, dcbp->ioctlparams->slotime, tsync_persist, dcbp);
  1467.             break;
  1468.            }
  1469.  
  1470.         }    /* end of Half duplex carrier handling... */
  1471.  
  1472.         /* Raise RTS and start transmiting */
  1473.         /* txstate is changed by the routine, but when */
  1474.         /* tsync_txisr is called next the state will be KEYED_UP */
  1475.         dcbp->txstate = TX_KEYUP_DELAY;
  1476.         transon(dcbp,ON);   
  1477.         break;
  1478.  
  1479.     case KEYED_UP:    
  1480.         /* RTS is ACTIVE or in radio terms the radio is keyed */
  1481.         /* and transmiting */
  1482.  
  1483.         txprime_dma(dcbp);    /* start sending a frame */
  1484.         /* chars will be going out */
  1485.         break;
  1486.  
  1487.  
  1488.         default:
  1489. #ifdef TSYNC_DEBUG_PRT
  1490.     printf("DEBUG tsync_txisr: invalid txstate, %d \n\r", dcbp->txstate);
  1491. #endif
  1492.  
  1493.                 /* reset Tx int pending */
  1494. #ifdef TSYNC_DEBUG
  1495.             Twin_write_scc(ctl,R0,(dcbp->wr0 = 0x28));         
  1496. #else
  1497.             Twin_write_scc(ctl,R0,0x28);         
  1498. #endif
  1499.             break;
  1500.  
  1501.          /* end switch */
  1502.     }
  1503.  
  1504.     restore(i_state);
  1505.     return;
  1506. }
  1507.  
  1508. void
  1509. txprime_dma(dcbp)
  1510. register DCB *dcbp;
  1511. {
  1512.     register int16 ctl;
  1513.     ulong realaddr;
  1514.     unsigned page;
  1515.  
  1516.     /* speed up access to 8530 regs */
  1517.     ctl = dcbp->zhwmap.ctl;
  1518.  
  1519.     /* if we are NOT DMA tx driven */
  1520.     if(dcbp->dma_flg == FALSE)
  1521.     {
  1522.  
  1523.         /* reset CRC for next frame */
  1524. #ifdef TSYNC_DEBUG
  1525.         Twin_write_scc(ctl,R0,(dcbp->wr0 = RES_Tx_CRC));    
  1526.  
  1527.         /* reset Tx int pending */
  1528.         Twin_write_scc(ctl,R0,(dcbp->wr0 = 0x28));         
  1529. #else
  1530.         Twin_write_scc(ctl,R0,RES_Tx_CRC);    
  1531.  
  1532.         /* reset Tx int pending */
  1533.         Twin_write_scc(ctl,R0,0x28);         
  1534. #endif
  1535.         /* Get First char to send */
  1536.         /* send the transmission char and bump the pointer */
  1537.  
  1538.         outportb(dcbp->zhwmap.data,*dcbp->cur_xbufp++);
  1539.  
  1540.         dcbp->txstate = TX_ACTIVE;    
  1541.  
  1542.         /* sent one byte */
  1543.         dcbp->cur_xbytes--; 
  1544.  
  1545. #ifdef TSYNC_DEBUG
  1546.         /* Rx/Tx and Extern ints on */
  1547.         Twin_write_scc(ctl,R1,(dcbp->wr1 = 0x13));  
  1548.  
  1549.         /* Reset Underrun/EOM latch */
  1550.         Twin_write_scc(ctl,R0,(dcbp->wr0 = 0xc0));
  1551.  
  1552.         /* turn-on the xmission of Abort on underrun */
  1553.         if(dcbp->nrzi_flg == TRUE)Twin_write_scc(ctl,R10,(dcbp->wr10 = 0xa4));
  1554.         else Twin_write_scc(ctl,R10,(dcbp->wr10 = 0x84));
  1555. #else
  1556.         /* Rx/Tx and Extern ints on */
  1557.         Twin_write_scc(ctl,R1,0x13);  
  1558.  
  1559.         /* Reset Underrun/EOM latch */
  1560.         Twin_write_scc(ctl,R0,0xc0);
  1561.  
  1562.         /* turn-on the xmission of Abort on underrun */
  1563.         if(dcbp->nrzi_flg == TRUE)Twin_write_scc(ctl,R10,0xa4);
  1564.         else Twin_write_scc(ctl,R10,0x84);
  1565.  
  1566. #endif
  1567.  
  1568. /* 4/18/91 */
  1569.         /* clear the TxEOM bit in the image */
  1570.         dcbp->extreg &= ~TxEOM;
  1571.  
  1572.         /* allow Underruns to interrupt us */
  1573.         Twin_write_scc(ctl,R15,(dcbp->wr15 |= 0x40));  
  1574.  
  1575.         /* for slow PCs... mask out the timer ints... */
  1576.         /* This will cause the pc to lose time during xmissions... */
  1577.         /* but seems only way to make it work at 9600 */
  1578.         if ((Twin_cputype < 2) && (dcbp->baud >= 9600L)) maskoff(0);
  1579.  
  1580.     }
  1581.     else
  1582.     {
  1583.         
  1584.         /* Reprime the tx dma pump... */
  1585.  
  1586.         /* A rendition of an absolute address for ptr */
  1587.         realaddr = ((ulong)FP_SEG(dcbp->cur_xbufp) << 4)
  1588.                    + (ulong)FP_OFF(dcbp->cur_xbufp);
  1589.  
  1590.         /* Disable this DMA channel */
  1591.         outportb(DMAWSMR,dcbp->dma_tx_chan | 0x04);
  1592.  
  1593.         /* DMA page reg for 8237 */
  1594.         page = realaddr >> 16;
  1595.  
  1596.         /* setup 64k page */
  1597.         outportb(dcbp->dma_tx_pagereg,page);    
  1598.  
  1599.         /* mode setup required if we are in HDX */
  1600.         if(dcbp->hduplex == TRUE)
  1601.         {
  1602.             outportb(DMAMODE,dcbp->dma_tx_chan |  TX_DMA);
  1603.             outportb(Twin_io_base+DMA_CFG,dcbp->dma_tx_mode);
  1604.         }
  1605.  
  1606.         /* clear the DMA byte ptr FF */
  1607.         outportb(DMAFFCL,00);
  1608.  
  1609.         /* Max xfer count setup */
  1610.         outportb(dcbp->dma_tx_cnt_reg,dcbp->cur_xbytes-1);
  1611.         outportb(dcbp->dma_tx_cnt_reg,((dcbp->cur_xbytes-1)>>8));
  1612.  
  1613.         /* destination buffer address */
  1614.         outportb(dcbp->dma_tx_addr_reg,(realaddr & 0xff));
  1615.         outportb(dcbp->dma_tx_addr_reg,((realaddr >> 8) & 0xff));
  1616.  
  1617.         /* reset CRC for next frame */
  1618. #ifdef TSYNC_DEBUG
  1619.         Twin_write_scc(ctl,R0,(dcbp->wr0 = RES_Tx_CRC));    
  1620. #else
  1621.         Twin_write_scc(ctl,R0,RES_Tx_CRC);    
  1622. #endif
  1623.         /* Enable this DMA channel */
  1624.         outportb(DMAWSMR,dcbp->dma_tx_chan);
  1625.         nop;
  1626.         nop;
  1627.  
  1628.         dcbp->txstate = TX_ACTIVE;    
  1629.  
  1630.         /* Reset Underrun/EOM latch */
  1631. #ifdef TSYNC_DEBUG
  1632.         Twin_write_scc(ctl,R0,(dcbp->wr0 = 0xc0));
  1633. #else
  1634.         Twin_write_scc(ctl,R0,0xc0);
  1635. #endif
  1636.         /* allow Underruns to interrupt us */
  1637.         Twin_write_scc(ctl,R15,(dcbp->wr15 |= 0x40));  
  1638.  
  1639.         /* clear the TxEOM bit in the image */
  1640.         dcbp->extreg &= ~TxEOM;
  1641.  
  1642. #ifdef TSYNC_DEBUG
  1643.         /* Rx and Extern ints on : No Tx ints */
  1644.         Twin_write_scc(ctl,R1,(dcbp->wr1 = 0xf9));  
  1645.  
  1646.         /* reset Tx int pending */
  1647.         Twin_write_scc(ctl,R0,(dcbp->wr0 = 0x28));         
  1648. #else
  1649.         /* Rx and Extern ints on : No Tx ints */
  1650.         Twin_write_scc(ctl,R1,0xf9);  
  1651.  
  1652.         /* reset Tx int pending */
  1653.         Twin_write_scc(ctl,R0,0x28);         
  1654. #endif
  1655.                 
  1656.     }
  1657. }
  1658.  
  1659. /* 
  1660.  * Transmit and Receive Control
  1661.  * SET Transmit or Receive Mode
  1662.  * Set RTS (request-to-send) to modem on Transmit
  1663.  */
  1664. void
  1665. transon(dcbp, onoff)
  1666. register DCB *dcbp;
  1667. int16 onoff;
  1668. {
  1669.     register int16    ctl;
  1670.     void    tsync_sqdelay();
  1671.     void    tsync_txondelay();
  1672.     void    time_wait();
  1673.  
  1674.     /* speed-up access to the SCC's control register */
  1675.     ctl = dcbp->zhwmap.ctl;
  1676.  
  1677.     /* Turn on transmitter to send flags */
  1678.     if ( onoff == ON ) 
  1679.     {
  1680.  
  1681.  
  1682.         /* If we are in DMA mode/Half duplex: Turn off the recvr */    
  1683.         /* Rx 8 bit/chars, enter hunt mode, CRC enable */
  1684. #ifdef notdef
  1685. /* NOT needed with autoenables */
  1686.                     Twin_write_scc(dcbp->zhwmap.ctl,R3,(dcbp->wr3 = 0xd8));         
  1687. #endif
  1688.  
  1689.         /* flags during KEYUP cause the other guy to sync up while */
  1690.         /* he sees garbage*/
  1691. #ifdef TSYNC_DEBUG
  1692.         if(dcbp->nrzi_flg == TRUE) Twin_write_scc(ctl,R10,(dcbp->wr10 = 0xa0));
  1693.         else Twin_write_scc(ctl,R10,(dcbp->wr10 = 0x80));
  1694.  
  1695.         /* Effectively just activate RTS */
  1696.         /* Which is used to key the "radio transmitter" */
  1697.         Twin_write_scc(dcbp->zhwmap.ctl,R5,(dcbp->wr5 = 0x6b));
  1698.  
  1699. #else
  1700.         if(dcbp->nrzi_flg == TRUE) Twin_write_scc(ctl,R10,0xa0);
  1701.         else Twin_write_scc(ctl,R10,0x80);
  1702.  
  1703.         /* Effectively just activate RTS */
  1704.         /* Which is used to key the "radio transmitter" */
  1705.         Twin_write_scc(dcbp->zhwmap.ctl,R5,0x6b);
  1706.  
  1707. #endif
  1708.         /*
  1709.          * Transmitter now on 
  1710.          */
  1711.  
  1712.         /* Delay after Tx on */
  1713.  
  1714.         /* Handle the special case of NO keyup delay... */
  1715.         if(dcbp->ioctlparams->xmitdelay == 0)tsync_txondelay(dcbp);
  1716.     
  1717.         /* otherwise set up the keyup timer... */    
  1718.         else
  1719.            time_wait(dcbp,dcbp->timer1, dcbp->ioctlparams->xmitdelay, tsync_txondelay, dcbp);
  1720.  
  1721.  
  1722.     } 
  1723.  
  1724.     else 
  1725.     {    /* Tx OFF and Rx ON */
  1726.  
  1727.         /* delay for squelch tail before enable of Rx */
  1728.  
  1729.         /* Handle the special case of NO keydown delay... */
  1730.         if(dcbp->ioctlparams->squelch == 0)tsync_sqdelay(dcbp);
  1731.  
  1732.         /* otherwise set up the keydown timer... */
  1733.         else
  1734.           time_wait(dcbp,dcbp->timer1, dcbp->ioctlparams->squelch, tsync_sqdelay, dcbp);
  1735.  
  1736.     }
  1737.     return;
  1738. }
  1739. /*
  1740.  * end of transon
  1741.  ********************************************************************/
  1742.  
  1743. /*
  1744.  *  Called by the timer isr at an interrupt level.
  1745.  *  Persist time is up.
  1746.  */
  1747. void tsync_persist(dcbp)
  1748. DCB *dcbp;
  1749. {
  1750.     /* new for NOS */
  1751.  
  1752.     /* persist time is up, have NOS process check for transmit */
  1753.     /* by changing the driver's transmit state */
  1754.     dcbp->txstate = DEFER;
  1755.  
  1756.     
  1757.     /* AND signal the process which is supposed to kick  */
  1758.     /* the transmitter */
  1759.     psignal(&Twin_kickpp[dcbp->dev],1);
  1760.  
  1761.     return;
  1762. }
  1763.  
  1764. /*
  1765.  *  Called by the timer isr at an interrupt level.
  1766.  *  Transmitter on delay is up.
  1767.  */
  1768. void tsync_txondelay(dcbp)
  1769. DCB *dcbp;
  1770. {
  1771.     /* transmiter is ON and can start sending */
  1772.     dcbp->txstate = KEYED_UP;
  1773.     tsync_txisr(dcbp);
  1774.     return;
  1775. }
  1776.  
  1777. /*
  1778.  *  Called by the timer isr at an interrupt level.
  1779.  *  Squelch delay is up.
  1780.  */
  1781. void tsync_sqdelay(dcbp)
  1782. DCB *dcbp;
  1783. {
  1784. register int16    ctl;
  1785.  
  1786.  
  1787.     /* We are going to shut down the "radio" transmitter.    */
  1788.     /* REGARDLESS of whether we now have a new frame to send */
  1789.     /* or not...  Because if we DO have more to send, we     */
  1790.     /* set txstate to DEFER, and let the tsync_recv routine     */
  1791.     /* kick us off again from the start, and if we don't     */
  1792.     /* have more to send we go to IDLE mode.                 */
  1793.  
  1794.     /* speed-up access to the SCC's control register */
  1795.     ctl = dcbp->zhwmap.ctl;
  1796.  
  1797.     /* Send MARK on IDLE to make sure other guy aborts any trailing */
  1798.     /* garbage */
  1799.     /* EXCEPT in NRZI... */
  1800. #ifdef TSYNC_DEBUG
  1801.     if(dcbp->nrzi_flg == TRUE) Twin_write_scc(ctl,R10,(dcbp->wr10 = 0xa0));
  1802.     else Twin_write_scc(ctl,R10,(dcbp->wr10 = 0x88));
  1803.  
  1804.     Twin_write_scc(ctl,R5,(dcbp->wr5 = 0x68));     /* TX off now */
  1805.                                             /* I.E. drop RTS */
  1806. #else
  1807.     if(dcbp->nrzi_flg == TRUE) Twin_write_scc(ctl,R10,0xa0);
  1808.     else Twin_write_scc(ctl,R10,0x88);
  1809.  
  1810.     Twin_write_scc(ctl,R5,0x68);     /* TX off now */
  1811.                                             /* I.E. drop RTS */
  1812. #endif
  1813.     /* re-prime the dma driver if necessary */
  1814.     /* Necessary because we took the SINGLE dma channel away */
  1815.     /* and used it to transmit... now give it back to receiver */
  1816.  
  1817.     if((dcbp->dma_flg == TRUE) && (dcbp->hduplex == TRUE))rxprime_dma(dcbp,1);
  1818.  
  1819.     /* perhaps while waiting for the squelch delay tsync_raw was */
  1820.     /* called and there is a buffer to send */
  1821.  
  1822.     if ( dcbp->xmtq != (struct drvbuf *)NULLBUF )
  1823.     { /* then start the transmit process */
  1824.       /* but not at an interrupt level!! */
  1825.       /* now when tsync_recv is called, tx_isr will run */
  1826.         dcbp->cur_xbufp = &(dcbp->xmtq->buf);
  1827.         dcbp->cur_xbytes = dcbp->xmtq->msgsize;
  1828.     
  1829.         /* new for NOS */
  1830.         /* signal the process which is supposed to kick  */
  1831.         /* the transmitter */
  1832.         dcbp->txstate = DEFER;
  1833.         psignal(&Twin_kickpp[dcbp->dev],1);
  1834.     }
  1835.     else
  1836.     { /* now only when tsync_raw runs will the transmit */
  1837.       /* process go on */
  1838.  
  1839.         dcbp->txstate = IDLE; 
  1840.     }
  1841.  
  1842.     return;
  1843. }
  1844.  
  1845.  
  1846. /* This is the driver timer service.  */
  1847. /* It's resolution is in 1 msec intervals */
  1848.  
  1849. void
  1850. time_wait(dcbp,timer,msecs,timerfunc,arg)
  1851. DCB *dcbp;
  1852. struct drv_timer *timer;
  1853. int16    msecs;
  1854. void (*timerfunc)();
  1855. unsigned long arg;
  1856. {
  1857. int16    hrd_addr;
  1858.  
  1859.     /* calculate the timer counter reg address */
  1860.     hrd_addr = Twin_io_base + TMR_CNT1 + dcbp->dev;
  1861.  
  1862.     timer->thandler = timerfunc;
  1863.     timer->targ = arg;
  1864.  
  1865.     /* start the timer */
  1866.     outportb(hrd_addr,(uchar)(msecs & 0xff));
  1867.     nop;
  1868.     nop;
  1869.     outportb(hrd_addr,(uchar)(msecs >> 8)); 
  1870.     nop;
  1871.     nop;
  1872. }
  1873.  
  1874.  
  1875. /***********************************************************
  1876.  * GRACILIS - processes to manage buffer maintenance for the
  1877.  *            PackeTwin synchronous drivers.  These processes
  1878.  *              are used to insure that buffer maintenance is 
  1879.  *              not performed at interrupt time.
  1880.  ***********************************************************/
  1881.  
  1882. /* This process is used to pre-allocate receive    */
  1883. /* buffers for the 8530 synchronous driver to use. */
  1884. void
  1885. tsync_rxavget(dev, p1, p2)            
  1886. int    dev;            /* device number */
  1887. void    *p1;            /* not used */
  1888. void    *p2;            /* not used */
  1889. {
  1890. register int16 i_state;
  1891. DCB *dcbp;
  1892. int16 cur_rxavail, min_rxavail;
  1893.  
  1894.  
  1895.     /* killself if device is not attached yet */
  1896.     if  (dev > 1)         /* only support 0 through 1 */
  1897.         return;
  1898.     else if (Twin_udcb[dev].attached == FALSE)
  1899.         return;
  1900.  
  1901.     for (;;)
  1902.     {
  1903.  
  1904.         /* wait for the driver to signal it needs */
  1905.         /* a look at its pre-allocated receive buffers */
  1906.         pwait(&Twin_bufpp[dev]);
  1907.  
  1908.         dcbp = (DCB *)Twin_udcb[dev].dcbp;
  1909.  
  1910.         i_state = dirps();
  1911.  
  1912.         cur_rxavail = dcbp->rxavailcount;
  1913.         min_rxavail = dcbp->ioctlparams->rxavailbufs;
  1914.  
  1915.         restore(i_state);
  1916.  
  1917.     
  1918.         /* see if more receive buffers need allocating */
  1919.         if ( cur_rxavail < min_rxavail )
  1920.         {
  1921.             f_getavail(&(dcbp->rxavailq),
  1922.                        (int16)(min_rxavail - cur_rxavail),
  1923.                        dcbp->rxbufsize,
  1924.                    &(dcbp->rxavailcount), 
  1925.                    dcbp->iface, dcbp->dma_flg);
  1926.         }
  1927.     } /* end of for(;;) loop */
  1928.  
  1929. } /* end of tsync_rxavget() */
  1930.  
  1931.  
  1932.  
  1933.  
  1934. /* This process is used to periodically kick */
  1935. /* the PackeTwin synchronous driver whenever */
  1936. /* it is in the DEFERED state  */
  1937. void
  1938. tsync_txkick(dev, p1, p2)            
  1939. int    dev;            /* device number */
  1940. void    *p1;            /* not used */
  1941. void    *p2;            /* not used */
  1942. {
  1943. register DCB *dcbp;
  1944. register bool pwait_null = FALSE;    /* 1st time wait for driver's psignal */
  1945. void tsync_txisr();
  1946.  
  1947.  
  1948.     /* killself if device is not attached yet */
  1949.     if  (dev > 1)         /* only support 0 through 1 */
  1950.         return;
  1951.     else if (Twin_udcb[dev].attached == FALSE)
  1952.         return;
  1953.  
  1954.     for (;;)
  1955.     {
  1956.  
  1957.         /* wait for the driver to signal it needs */
  1958.         /* kick */
  1959.         if ( pwait_null )
  1960.             pwait(NULL);            /* have NOS provide */
  1961.                             /* the delay needed */
  1962.         else
  1963.             pwait(&Twin_kickpp[dev]);
  1964.  
  1965.         /* driver control block */
  1966.         dcbp = (DCB *)Twin_udcb[dev].dcbp;
  1967.  
  1968.         /*  Test for DEFERED transmit state */
  1969.         if (dcbp->txstate == DEFER)
  1970.         {
  1971.             tsync_txisr(dcbp);
  1972.             if ( dcbp->txstate == DEFER )
  1973.                 pwait_null = TRUE;    /* then driver still */
  1974.                             /* needs a kick */
  1975.             else
  1976.                 pwait_null = FALSE;
  1977.         }
  1978.  
  1979.     } /* end of for(;;) loop */
  1980.  
  1981. } /* end of tsync_txkick() */
  1982.  
  1983.  
  1984.  
  1985. /* This process is used to free buffers */
  1986. /* which have been transmitted by the driver. */
  1987. void
  1988. tsync_freetx(dev, p1, p2)            
  1989. int    dev;            /* device number */
  1990. void    *p1;            /* not used */
  1991. void    *p2;            /* not used */
  1992. {
  1993. register int16 i_state;
  1994. register DCB *dcbp;
  1995. register struct drvbuf *xbufp, *btemp;
  1996.  
  1997.  
  1998.     /* killself if device is not attached yet */
  1999.     if  (dev > 4)         /* only support 0 through 4 */
  2000.         return;
  2001.     else if (Twin_udcb[dev].attached == FALSE)
  2002.         return;
  2003.  
  2004.     for (;;)
  2005.     {
  2006.  
  2007.         /* wait for driver to signal that there are transmitted */
  2008.         /* messages to be freed */
  2009.         pwait(&Twin_freetxpp[dev]);
  2010.  
  2011.         /* driver control block */
  2012.         dcbp = (DCB *)Twin_udcb[dev].dcbp;
  2013.  
  2014.         /* Do not do memory free-ups while interrupts are */
  2015.         /* disabled! Here xbufp is a "to be free'd"  */
  2016.         /* queue pointer" */
  2017.  
  2018.         i_state = dirps();
  2019.         xbufp = dcbp->freem;
  2020.         dcbp->freem = NULLBUF;
  2021.         restore(i_state);
  2022.  
  2023.         /* now free memory of all the xmitted messages */
  2024.         while ( xbufp != (struct drvbuf *)NULL )
  2025.         {
  2026.             btemp = xbufp->next;
  2027.             free((char *)xbufp);
  2028.             xbufp = btemp;
  2029.         }
  2030.     } /* end of for(;;) loop */
  2031.  
  2032. } /* end of tsync_freetx() */
  2033.  
  2034.  
  2035.