z8030Serial.c
上传用户:luoyougen
上传日期:2008-05-12
资源大小:23136k
文件大小:14k
源码类别:

VxWorks

开发平台:

C/C++

  1. /* z8530Serial.c - Z8530 SCC (Serial Communications Controller) tty driver*/
  2. /* Copyright 1984-1993 Wind River Systems, Inc. */
  3. #include "copyright_wrs.h"
  4. /*
  5. modification history
  6. --------------------
  7. 01a,23feb93,eve  started from version 01n of z8530Serial.c.
  8. */
  9. /*
  10. DESCRIPTION
  11. This is the driver for the Z8030 SCC (Serial Communications Controller).
  12. It uses the SCCs in asynchronous mode only.
  13. USER-CALLABLE ROUTINES
  14. Most of the routines in this driver are accessible only through the I/O
  15. system.  Two routines, however, must be called directly: tyCoDrv() to
  16. initialize the driver, and tyCoDevCreate() to create devices.
  17. Before the driver can be used, it must be initialized by calling tyCoDrv().
  18. This routine should be called exactly once, before any reads, writes, or
  19. calls to tyCoDevCreate().  Normally, it is called by usrRoot() in usrConfig.c.
  20. Before a terminal can be used, it must be created using tyCoDevCreate().
  21. Each port to be used should have exactly one device associated with it by
  22. calling this routine.
  23. IOCTL FUNCTIONS
  24. This driver responds to the same ioctl() codes as a normal tty driver; for
  25. more information, see the manual entry for tyLib.  Available baud rates
  26. range from 50 to 38400.
  27. SEE ALSO
  28. tyLib
  29. */
  30. #include "vxWorks.h"
  31. #include "iv.h"
  32. #include "ioLib.h"
  33. #include "iosLib.h"
  34. #include "tyLib.h"
  35. #include "intLib.h"
  36. #include "errnoLib.h"
  37. #include "drv/serial/z8030.h"
  38. #define DEFAULT_BAUD 9600
  39. IMPORT TY_CO_DEV tyCoDv []; /* device descriptors */
  40. LOCAL int tyCoDrvNum; /* driver number assigned to this driver */
  41. /* forward declarations */
  42. LOCAL void   tyCoStartup ();
  43. LOCAL int    tyCoOpen ();
  44. LOCAL STATUS tyCoIoctl ();
  45. LOCAL void   tyCoHrdInit ();
  46. LOCAL void   tyCoInitChannel ();
  47. LOCAL void   tyCoResetChannel ();
  48. LOCAL void   delayRegAccess();
  49. /*******************************************************************************
  50. *
  51. * tyCoDrv - initialize the tty driver
  52. *
  53. * This routine initializes the serial driver, sets up interrupt vectors, and
  54. * performs hardware initialization of the serial ports.
  55. *
  56. * This routine should be called exactly once, before any reads, writes, or
  57. * calls to tyCoDevCreate().  Normally, it is called by usrRoot() in
  58. * usrConfig.c.
  59. *
  60. * RETURNS: OK, or ERROR if the driver cannot be installed.
  61. *
  62. * SEE ALSO: tyCoDevCreate()
  63. */
  64. STATUS tyCoDrv (void)
  65.     {
  66.     /* check if driver already installed */
  67.     
  68.     if (tyCoDrvNum > 0)
  69. return (OK);
  70.     tyCoHrdInit ();
  71.     tyCoDrvNum = iosDrvInstall (tyCoOpen, (FUNCPTR) NULL, tyCoOpen,
  72. (FUNCPTR) NULL, tyRead, tyWrite, tyCoIoctl);
  73.     return (tyCoDrvNum == ERROR ? ERROR : OK);
  74.     }
  75. /*******************************************************************************
  76. *
  77. * tyCoDevCreate - create a device for an on-board serial port
  78. *
  79. * This routine creates a device on a specified serial port.  Each port
  80. * to be used should have exactly one device associated with it by calling
  81. * this routine.
  82. *
  83. * For instance, to create the device "/tyCo/0", with buffer sizes of 512 bytes,
  84. * the proper call would be:
  85. * .CS
  86. *     tyCoDevCreate ("/tyCo/0", 0, 512, 512);
  87. * .CE
  88. *
  89. * RETURNS: OK, or ERROR if the driver is not installed, the channel is
  90. * invalid, or the device already exists.
  91. *
  92. * SEE ALSO: tyCoDrv()
  93. */
  94. STATUS tyCoDevCreate
  95.     (
  96.     char *      name,           /* name to use for this device      */
  97.     FAST int    channel,        /* physical channel for this device */
  98.     int         rdBufSize,      /* read buffer size, in bytes       */
  99.     int         wrtBufSize      /* write buffer size, in bytes      */
  100.     )
  101.     {
  102.     FAST TY_CO_DEV *pTyCoDv;
  103.     if (tyCoDrvNum <= 0)
  104. {
  105. errnoSet (S_ioLib_NO_DRIVER);
  106. return (ERROR);
  107. }
  108.     /* if this doesn't represent a valid channel, don't do it */
  109.     if (channel < 0 || channel >= tyCoDv [0].numChannels)
  110. return (ERROR);
  111.     pTyCoDv = &tyCoDv [channel];
  112.     /* if there is a device already on this channel, don't do it */
  113.     if (pTyCoDv->created)
  114. return (ERROR);
  115.     /* initialize the ty descriptor */
  116.     if (tyDevInit (&pTyCoDv->tyDev, rdBufSize, wrtBufSize,
  117.    (FUNCPTR) tyCoStartup) != OK)
  118. {
  119. return (ERROR);
  120. }
  121.     /* initialize the channel hardware */
  122.     tyCoInitChannel (channel);
  123.     /* mark the device as created, and add the device to the I/O system */
  124.     pTyCoDv->created = TRUE;
  125.     return (iosDevAdd (&pTyCoDv->tyDev.devHdr, name, tyCoDrvNum));
  126.     }
  127. /*******************************************************************************
  128. *
  129. * tyCoHrdInit - initialize the USART
  130. */
  131. LOCAL void tyCoHrdInit (void)
  132.     {
  133.     FAST int   oldlevel; /* current interrupt level mask */
  134.     int        ix;
  135.     oldlevel = intLock (); /* disable interrupts during init */
  136.     for (ix=0; ix < tyCoDv [0].numChannels; ix++)
  137. tyCoResetChannel (ix); /* reset channel */
  138.     intUnlock (oldlevel);
  139.     }
  140. /********************************************************************************
  141. *
  142. * tyCoResetChannel - reset a single channel
  143. */
  144. LOCAL void tyCoResetChannel
  145.     (
  146.     int channel
  147.     )
  148.     {
  149.     volatile char *cr = tyCoDv [channel].cr;        /* SCC control reg adr */
  150.     int delay;
  151.     *Z8030_WR0(cr) = SCC_WR0_ERR_RST  ;
  152.     delayRegAccess();
  153.     *Z8030_WR0(cr) = SCC_WR0_RST_INT  ;
  154.      
  155.     if ( (delay = channel % 2 ) == 0 )
  156. *Z8030_WR9(cr) = SCC_WR9_CH_A_RST;
  157.     else
  158.         *Z8030_WR9(cr) = SCC_WR9_CH_B_RST; 
  159.     for (delay = 0; delay < 1000; delay++)
  160. ;     /* spin wheels for a moment */
  161.     }
  162. /*******************************************************************************
  163. *
  164. * tyCoInitChannel - initialize a single channel
  165. */
  166. LOCAL void tyCoInitChannel
  167.     (
  168.     int channel
  169.     )
  170.     {
  171.     FAST TY_CO_DEV *pTyCoDv = &tyCoDv [channel];
  172.     volatile char  *cr = pTyCoDv->cr; /* SCC control reg adr */
  173.     FAST int        baudConstant;
  174.     FAST int        oldlevel; /* current interrupt level mask */
  175.     int             zero = 0;
  176.     oldlevel = intLock (); /* disable interrupts during init */
  177.     /* initialize registers */
  178.     *Z8030_WR4(cr) = SCC_WR4_1_STOP | SCC_WR4_16_CLOCK;
  179.     delayRegAccess();
  180.     *Z8030_WR1(cr) = SCC_WR1_INT_ALL_RX | SCC_WR1_TX_INT_EN;
  181.     delayRegAccess();
  182.     *Z8030_WR3(cr) = SCC_WR3_RX_8_BITS;
  183.     delayRegAccess();
  184.     *Z8030_WR5(cr) = SCC_WR5_TX_8_BITS | SCC_WR5_DTR | SCC_WR5_RTS;
  185.     delayRegAccess();
  186.     *Z8030_WR10(cr)= zero; /* clear sync, loop, poll */
  187.     delayRegAccess();
  188.     *Z8030_WR11(cr) = pTyCoDv->clockModeWR11;
  189.     delayRegAccess();
  190.     *Z8030_WR15(cr) = zero;
  191.     /* Calculate the baud rate constant for the default baud rate
  192.      * from the input clock frequency.  This assumes that the
  193.      * divide-by-16 bit is set (done in WR4 above).
  194.      */
  195.     baudConstant = ((pTyCoDv->baudFreq / 32) / DEFAULT_BAUD) - 2;
  196.     *Z8030_WR12(cr) = (char) baudConstant ; /* write LSB */
  197.     delayRegAccess();
  198.     *Z8030_WR13(cr) = (char) (baudConstant >> 8); /* write MSB */
  199.     delayRegAccess();
  200.     *Z8030_WR14(cr) = pTyCoDv->clockModeWR14;
  201.     delayRegAccess();
  202.     *Z8030_WR15(cr) = zero;
  203.     /* reset external interrupts */
  204.     delayRegAccess();
  205.     *Z8030_WR0(cr) = SCC_WR0_RST_INT  ;
  206.     /* reset errors */
  207.     delayRegAccess();
  208.     *Z8030_WR0(cr) = SCC_WR0_ERR_RST  ;  
  209.     delayRegAccess();
  210.     *Z8030_WR3(cr) = SCC_WR3_RX_8_BITS | SCC_WR3_RX_EN;
  211.     delayRegAccess();
  212.     *Z8030_WR5(cr) = SCC_WR5_TX_8_BITS | SCC_WR5_TX_EN |
  213.                      SCC_WR5_DTR       | SCC_WR5_RTS;
  214.     delayRegAccess();
  215.     *Z8030_WR2(cr) = pTyCoDv->intVec;
  216.     delayRegAccess();
  217.     *Z8030_WR1(cr) = SCC_WR1_INT_ALL_RX | SCC_WR1_TX_INT_EN;
  218.     /* enable interrupts */
  219.     delayRegAccess();
  220.     *Z8030_WR9(cr) = SCC_WR9_MIE | pTyCoDv->intType;
  221.     delayRegAccess();
  222.     *Z8030_WR0(cr) = SCC_WR0_RST_TX_CRC  ;
  223.     delayRegAccess();
  224.     *Z8030_WR0(cr) = SCC_WR0_RST_INT  ;
  225.     delayRegAccess();
  226.     *Z8030_WR0(cr) = SCC_WR0_RST_INT  ;
  227.     delayRegAccess();
  228.     *Z8030_WR0(cr) = 0  ;
  229.     intUnlock (oldlevel);
  230.     }
  231. /*******************************************************************************
  232. *
  233. * tyCoOpen - open file to USART
  234. */
  235. LOCAL int tyCoOpen
  236.     (
  237.     TY_CO_DEV *pTyCoDv,
  238.     char      *name,
  239.     int        mode
  240.     )
  241.     {
  242.     return ((int) pTyCoDv);
  243.     }
  244. /*******************************************************************************
  245. *
  246. * tyCoIoctl - special device control
  247. *
  248. * This routine handles FIOBAUDRATE requests and passes all others to tyIoctl().
  249. *
  250. * RETURNS: OK, or ERROR if invalid baud rate, or whatever tyIoctl() returns.
  251. */
  252. LOCAL STATUS tyCoIoctl
  253.     (
  254.     TY_CO_DEV *pTyCoDv, /* device to control */
  255.     int        request, /* request code */
  256.     int        arg /* some argument */
  257.     )
  258.     {
  259.     FAST int     oldlevel; /* current interrupt level mask */
  260.     FAST int     baudConstant;
  261.     FAST STATUS  status;
  262.     volatile char *cr; /* SCC control reg adr */
  263.     switch (request)
  264. {
  265. case FIOBAUDRATE:
  266.     if (arg < 50 || arg > 38400)
  267.         {
  268. status = ERROR; /* baud rate out of range */
  269. break;
  270.         }
  271.     /* Calculate the baud rate constant for the new baud rate
  272.      * from the input clock frequency.  This assumes that the
  273.      * divide-by-16 bit is set in the Z8530 WR4 register (done
  274.      * in tyCoInitChannel).
  275.      */
  276.     baudConstant = ((pTyCoDv->baudFreq / 32) / arg) - 2;
  277.     cr = pTyCoDv->cr;
  278.     /* disable interrupts during chip access */
  279.     oldlevel = intLock ();
  280.     *Z8030_WR12(cr) = (char)baudConstant; /* write LSB */
  281.             delayRegAccess();
  282.     *Z8030_WR13(cr) = (char)(baudConstant >> 8); /* write MSB */
  283.     intUnlock (oldlevel);
  284.     status = OK;
  285.     break;
  286. default:
  287.     status = tyIoctl (&pTyCoDv->tyDev, request, arg);
  288.     break;
  289. }
  290.     return (status);
  291.     }
  292. /*******************************************************************************
  293. *
  294. * tyCoIntWr - interrupt level processing
  295. *
  296. * This routine handles write interrupts from the SCC.
  297. *
  298. * RETURNS: N/A
  299. *
  300. * NOMANUAL
  301. */
  302. void tyCoIntWr
  303.     (
  304.     int channel /* interrupting serial channel */
  305.     )
  306.     {
  307.     char            outChar;
  308.     FAST TY_CO_DEV *pTyCoDv = &tyCoDv [channel];
  309.     volatile char  *cr = pTyCoDv->cr;
  310.     if (pTyCoDv->created && tyITx (&pTyCoDv->tyDev, &outChar) == OK)
  311. {
  312. *pTyCoDv->dr = outChar;
  313. }
  314.     else
  315. {
  316. /* no more chars to xmit now.  reset the tx int,
  317.  * so the SCC does not keep interrupting.
  318.  */
  319. *Z8030_WR0(cr)= SCC_WR0_RST_TX_INT  ;
  320. }
  321.     /* end the interrupt acknowledge */
  322.     delayRegAccess();
  323.     *Z8030_WR0(cr)= SCC_WR0_RST_HI_IUS  ;
  324.     }
  325. /*****************************************************************************
  326. *
  327. * tyCoIntRd - interrupt level input processing
  328. *
  329. * This routine handles read interrupts from the SCC
  330. *
  331. * RETURNS: N/A
  332. *
  333. * NOMANUAL
  334. */
  335. void tyCoIntRd
  336.     (
  337.     int channel /* interrupting serial channel */
  338.     )
  339.     {
  340.     FAST TY_CO_DEV *pTyCoDv = &tyCoDv [channel];
  341.     volatile char  *cr = pTyCoDv->cr;
  342.     char            inchar;
  343.     inchar = *pTyCoDv->dr;
  344.     if (pTyCoDv->created)
  345. tyIRd (&pTyCoDv->tyDev, inchar);
  346.     /* reset the interrupt in the Z8530 */
  347.     *Z8030_WR0(cr) = SCC_WR0_RST_HI_IUS  ;
  348.     delayRegAccess(); 
  349.     }
  350. /**********************************************************************
  351. *
  352. * tyCoIntEx - miscellaneous interrupt processing
  353. *
  354. * This routine handles miscellaneous interrupts on the SCC
  355. *
  356. * RETURNS: N/A
  357. *
  358. * NOMANUAL
  359. */
  360. void tyCoIntEx
  361.     (
  362.     int channel /* interrupting serial channel */
  363.     )
  364.     {
  365.     FAST TY_CO_DEV *pTyCoDv = &tyCoDv [channel];
  366.     volatile char  *cr = pTyCoDv->cr;
  367.    /* reset the interrupt in the Z8530 */
  368.     *Z8030_WR0(cr) = SCC_WR0_ERR_RST  ;   
  369.     delayRegAccess();
  370.     *Z8030_WR0(cr) = SCC_WR0_RST_INT  ;   
  371.     delayRegAccess();
  372.     *Z8030_WR0(cr) = SCC_WR0_RST_HI_IUS  ;
  373.     }
  374. /********************************************************************************
  375. *
  376. * tyCoInt - interrupt level processing
  377. *
  378. * This routine handles interrupts from both of the SCCs.
  379. * We determine from the parameter which SCC interrupted, then look at
  380. * the code to find out which channel and what kind of interrupt.
  381. * NOMANUAL
  382. */
  383. void tyCoInt
  384.     (
  385.     int sccNum
  386.     )
  387.     {
  388.     volatile char   *cr;
  389.     FAST char        intStatus;
  390.     FAST TY_CO_DEV  *pTyCoDv;
  391.     char             outChar;
  392.     /* We need to find out which channel interrupted.  We need to read
  393.      * the B channel of the interrupting SCC to find out which channel
  394.      * really interrupted.  Note that things are set up so that the A
  395.      * channel is channel 0, even though on the chip it is the one with
  396.      * the higher address
  397.      */  
  398.     pTyCoDv = &tyCoDv [(sccNum * 2) + 1];
  399.     cr = pTyCoDv->cr;
  400.     intStatus = *Z8030_WR2(cr);
  401.     if ((intStatus & 0x08) != 0)
  402.         {                               /* the A channel interrupted */
  403.         --pTyCoDv;
  404.         cr = pTyCoDv->cr;
  405.         }
  406.     switch (intStatus & 0x06)
  407.         {
  408.         case 0x00:                      /* Tx Buffer Empty */
  409.             if (pTyCoDv->created && (tyITx (&pTyCoDv->tyDev, &outChar) == OK))
  410.                 *pTyCoDv->dr = outChar;
  411.             else
  412.                 {
  413.                 /* no more chars to xmit now.  reset the tx int,
  414.                  * so the SCC doesn't keep interrupting us.
  415.  */
  416.  
  417.                 *Z8030_WR0(cr) = SCC_WR0_RST_TX_INT  ;
  418.                 }
  419.             break;
  420.  
  421.         case 0x04:                      /* RxChar Avail */
  422.             if (pTyCoDv->created)
  423.                 tyIRd (&pTyCoDv->tyDev, *pTyCoDv->dr);
  424.             break;
  425.  
  426.         case 0x02:                      /* External Status Change */
  427.             *Z8030_WR0(cr) = SCC_WR0_ERR_RST  ;
  428.             outChar = *pTyCoDv->dr;          /* throw away char */
  429.             break;
  430.  
  431.         case 0x06:                      /* Special receive condition */
  432.             *Z8030_WR0(cr) = SCC_WR0_ERR_RST  ;
  433.             break;                      /* ignore */
  434.  
  435.         }
  436.     /* Reset the interrupt in the Z8530 */
  437.     delayRegAccess();
  438.     *Z8030_WR0(cr) = SCC_WR0_RST_HI_IUS  ;
  439.     }
  440. /*******************************************************************************
  441. *
  442. * tyCoStartup - transmitter startup routine
  443. *
  444. * Call interrupt level character output routine.
  445. */
  446. LOCAL void tyCoStartup
  447.     (
  448.     TY_CO_DEV *pTyCoDv  /* ty device to start up */
  449.     )
  450.     {
  451.     char outChar;
  452.     if (tyITx (&pTyCoDv->tyDev, &outChar) == OK)
  453.         {
  454. *pTyCoDv->dr = outChar;
  455.         delayRegAccess();
  456.         }
  457.     }
  458. /*******************************************************************************
  459. *
  460. * delayRegAccess - delay routine for register access.
  461. *
  462. */
  463. LOCAL void delayRegAccess(void)
  464.     {
  465.     int delay;
  466.     for (delay = 0; delay < 2; delay++);
  467.     }