开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
CIOTimer.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：18k
源码类别：

VxWorks

开发平台：

C/C++

CIOTimer.c：源码内容
  1. /* CIOTimer.c - Cyclone CVME964 Z8536 CIO timer routines */
  3. /* Copyright 1984-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01e,03jan97,wlf  doc: more cleanup.
  10. 01d,14jun96,wlf  doc: cleanup.
  11. 01c,17apr96,myz  lock and unlock ints at the chip level 
  12. 01b,10jan96,myz  Modified sysCIOInt, sysClkRateSet and sysAuxClkRateSet 
  13. 01a,17dec93,snc  Created as a result of partitioning/ANSIfying per vxWorks
  14.                  porting guide
  15. */
  17. /*
  18. DESCRIPTION
  19. This library contains routines to manipulate and use the Zilog Z85C36 CIO
  20. which serves as the System Clock and Auxiliary Clock source on the Cyclone
  21. CVME964.
  23. SEE ALSO:
  24. .iB "Cyclone CVME964 User's Manual"
  25. .iB "Intel 80960CA User's Manual"
  26. */
  28. #include "vxWorks.h"
  29. #include "vxLib.h"
  30. #include "sysLib.h"
  31. #include "intLib.h"
  32. #include "config.h"
  33. #include "drv/timer/z8536.h"
  36. /* forward declarations */
  38. void sysCioInt ();
  39. void  sysClkInt ();
  40. void    sysAuxClkInt ();
  42. /* globals */
  44. int     sysClkTicksPerSecond    = 60;
  45. int     sysClkRunning           = FALSE;
  46. FUNCPTR sysClkRoutine           = NULL;
  47. int     sysClkArg               = NULL;
  48. BOOL sysClkConnected = FALSE;
  49. int     sysAuxClkTicksPerSecond = 60;
  50. int     sysAuxClkRunning        = FALSE;
  51. FUNCPTR sysAuxClkRoutine        = NULL;
  52. int     sysAuxClkArg            = NULL;
  54. /*******************************************************************************
  55. *
  56. * sysCioInt - handle a system CIO interrupt
  57. *
  58. * This routine acknowledges a system CIO interrupt
  59. * and determines which CIO subsection caused it.
  60. *
  61. * EXAMPLE: An interrupt results from the expiration of a timer:
  62. *
  63. *     CIO Timer 1 - system tick clock
  64. *     CIO Timer 2 - system auxiliary clock
  65. *     CIO Timer 3 - serial EEPROM accesses
  66. *
  67. * If the interrupt resulted from the expiration of the system clock timer
  68. * (Timer 1), the system clock service routine is called.  If the interrupt
  69. * is the result of an expired auxiliary clock timer (Timer 2), the system
  70. * auxiliary clock service routine is called.
  71. *
  72. * NOTE: During CIO accesses that are required by various code segments,
  73. * CIO interrupts are masked to ensure that their servicing 
  74. * by this routine does not affect the CIO register access state machine.
  75. *
  76. * NOMANUAL
  77. */
  79. void sysCioInt (void)
  80.     {
  81.     volatile UINT8 stat;
  82.     int intHandling;
  84.     /*
  85.      * This do loop is needed to prevent edge triggered interrupt from lockup
  86.      */
  87.     do
  88.         {
  89.         intHandling = FALSE;
  91.         CIO->ctrl = ZCIO_CT1CS;
  92.         stat = CIO->ctrl;           /* get Counter/Timer1 status */
  94.         if (stat & ZCIO_CS_IP)              /* System Clock Tick */
  95.     {
  96.     intHandling = TRUE;
  97.             sysClkInt ();
  98.             }
  100.         CIO->ctrl = ZCIO_CT2CS;
  101.         stat = CIO->ctrl;           /* get Counter/Timer2 status */
  103.         if (stat & ZCIO_CS_IP)
  104.     {
  105.     intHandling = TRUE;
  106.             sysAuxClkInt ();
  107.             }
  109.         /* check  counter/timer 3  */
  111.         CIO->ctrl = ZCIO_CT3CS;
  112.         stat    = CIO->ctrl;
  114.         if (stat & ZCIO_CS_IP )
  115.             {
  116.             intHandling = TRUE;
  117.             
  118.             /* should not get a interrupt from timer 3 */
  119.             /*  simply acknowledge the clock interrupt */
  121.             CIO->ctrl = ZCIO_CT3CS;             /* C/T 3 Command and Status */
  122.             CIO->ctrl = ZCIO_CS_CLIPIUS         /* Clear IP and IUS */
  123.                         | ZCIO_CS_GCB;            /* Gate Command Bit */
  125.             }
  126.             
  127.         } while(intHandling == TRUE);
  129.     }
  131. /*******************************************************************************
  132. *
  133. * sysClkInt - handle a system clock interrupt
  134. *
  135. * This routine handles a system clock interrupt.
  136. *
  137. * The system clock is driven by CIO Counter/Timer 1.
  138. * It calls the routine installed by sysClkConnect().
  139. *
  140. * RETURNS: N/A
  141. *
  142. * SEE ALSO: sysClkConnect()
  143. *
  144. * NOMANUAL
  145. */
  147. void sysClkInt (void)
  149.     {
  150.     /* reset IUS and IP, don't gate */
  152.     CIO->ctrl = ZCIO_CT1CS;
  153.     CIO->ctrl = ZCIO_CS_CLIPIUS | ZCIO_CS_GCB;
  155.     if (sysClkRoutine != NULL)
  156. (*sysClkRoutine) (sysClkArg);
  157.     }
  159. /*******************************************************************************
  160. *
  161. * sysClkConnect - connect a routine to the system clock interrupt
  162. *
  163. * This routine specifies the interrupt service routine to be called at each
  164. * clock interrupt.  It does not enable system clock interrupts.  Normally,
  165. * it is called from usrRoot() in usrConfig.c to connect usrClock() to the
  166. * system clock interrupt.  It also specifies the interrupt service routines
  167. * for the NMI and parity interrupts and enables the parity interrupt.
  168. *
  169. * RETURNS: OK, or ERROR if the routine cannot be connected to the interrupt.
  170. *
  171. * SEE ALSO: intConnect(), usrClock(), sysClkEnable()
  172. */
  174. STATUS sysClkConnect 
  175.     (
  176.     FUNCPTR routine, /* routine called at each system clock interrupt */
  177.     int arg  /* argument with which to call routine           */
  178.     )
  180.     {
  181.     /* if the system clock interrupt is being connected for the first
  182.      * time, connected the CIO handler.
  183.      */
  185.     intConnect ((void *)VECTOR_CIO, sysCioInt, 0);
  187.     sysClkRoutine   = routine;
  188.     sysClkArg       = arg;
  190.     sysClkConnected = TRUE;
  192.     sysHwInit2();
  194.     return (OK);
  195.     }
  196. /*******************************************************************************
  197. *
  198. * sysClkDisable - turn off system clock interrupts
  199. *
  200. * This routine disables system clock interrupts.
  201. *
  202. * RETURNS: N/A
  203. *
  204. * SEE ALSO: sysClkEnable()
  205. */
  207. void sysClkDisable (void)
  209.     {
  210.     volatile unsigned char junk;
  212.     if (!sysClkRunning)
  213. return;
  215.     /* mask CIO interrupts to ensure that the CIO access state machine
  216.        is not corrupted */
  217.     
  218.     CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control     */
  219.     junk      =  CIO->ctrl;
  220.     CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control     */
  221.     CIO->ctrl =  (~ZCIO_MIC_MIE) & junk;   /* Master Interrupt Disable      */
  224.     /* Disable Timer 1 interrupts from the CIO */
  225.     junk = CIO->ctrl; /* reset the CIO state machine */
  226.     CIO->ctrl = ZCIO_CT1CS;
  227.     CIO->ctrl = ZCIO_CS_CLIE; /* clear Interrupt Enable
  228.    Gate Counter */
  230.     sysClkRunning = FALSE;
  232.     /* don't unmask the CIO interrupt if no system clocks are running */
  234.     if (sysClkRunning || sysAuxClkRunning)
  235.          {
  236.          CIO->ctrl =  ZCIO_MIC;            /* Master Interrupt Control     */
  237.          junk      =  CIO->ctrl;
  238.          CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control   */
  239.          CIO->ctrl =  ZCIO_MIC_MIE | junk;   /* Master Interrupt Enable     */
  240.          }
  241.     }
  243. /*******************************************************************************
  244. *
  245. * sysClkEnable - turn on system clock interrupts
  246. *
  247. * This routine enables system clock interrupts.
  248. *
  249. * NOTE: To calculate the time constant of the CIO Timer 1, use the following
  250. * formula:
  251. * .CS
  252. * "CIO_CLK" PCLK ticks   1 timer tick     1 sec
  253. * -------------------- x ------------ x --------------------
  254. *        1 sec           2 PCLK ticks   sysClkTicksPerSecond
  255. * .CE
  256. * The result is the number of timer ticks it takes to achieve the desired
  257. * number of ticks/sec.  This number is calculated as a long, however, the
  258. * CIO uses a 16-bit time constant.  If the result is greater than 65535, the
  259. * time constant is set to 65535.  A time constant of 65535 is almost 32
  260. * milliseconds (31.47 ticks/sec.).
  261. *
  262. * CIO_CLK is defined in ep960jx.h.
  263. *
  264. * NOTE: Timers are clocked at a rate of 1/2 of PCLK.  
  265. * 
  266. * RETURNS: N/A
  267. *
  268. * SEE ALSO: sysClkConnect(), sysClkDisable(), sysClkRateSet(),
  269. * .I "Zilog Z8536 CIO Counter/Timer Technical Manual"
  270. */
  272. void sysClkEnable (void)
  274.     {
  275.     long num_ticks = 0; /* number of ticks needed */
  276.     volatile unsigned char junk;
  278.     /* don't do it if already enabled */
  279.     if (sysClkRunning)
  280. return;
  282.     /* mask CIO interrupts to ensure that the CIO access state machine
  283.        is not corrupted */
  285.     CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control     */
  286.     junk      =  CIO->ctrl;
  287.     CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control     */
  288.     CIO->ctrl =  (~ZCIO_MIC_MIE) & junk;   /* Master Interrupt Disable   */
  290.     /* Disable Timer 1 interrupts from the CIO */
  291.     junk = CIO->ctrl; /* reset the CIO state machine */
  292.     CIO->ctrl = ZCIO_CT1CS;
  293.     CIO->ctrl = ZCIO_CS_CLIE; /* clear Interrupt Enable
  294.    Gate Counter */
  296.     /* set up the CIO Time Constant registers based on the value
  297.        of sysClkTicksPerSecond */
  299.     if (sysClkTicksPerSecond < SYS_CLK_RATE_MIN)
  300. num_ticks = 0x0ffff;
  302.     else if (sysClkTicksPerSecond > SYS_CLK_RATE_MAX)
  303. num_ticks = 0x01;
  305.     else
  306.     num_ticks = (long) (CIO_CLK / (2 * sysClkTicksPerSecond));
  308.     /* Set up Counter/Timer 1 Mode */
  309.     CIO->ctrl = ZCIO_CT1MS;
  310.     CIO->ctrl = ZCIO_CTMS_CSC; /* continuous cycle
  311.    no external signals used
  312.    pulse output */
  314.     /* Load time constant into Counter/timer 1's TC registers */
  315.     CIO->ctrl = ZCIO_CT1TCMSB; /* Timer 1 time constant MSB */
  316.     CIO->ctrl = (num_ticks >> 8) & 0x0ff;
  317.     CIO->ctrl = ZCIO_CT1TCLSB; /* Timer 1 time constant LSB */
  318.     CIO->ctrl = num_ticks & 0x0ff;
  320.     CIO->ctrl = ZCIO_CT1CS;
  321.     CIO->ctrl = ZCIO_CS_CLIPIUS; /* clear IP and IUS, gate */
  323.     CIO->ctrl = ZCIO_MCC;
  324.     junk = CIO->ctrl;
  325.     CIO->ctrl = ZCIO_MCC;
  326.     CIO->ctrl = junk | 0x40; /* enable Timer 1 */
  328.     CIO->ctrl = ZCIO_CT1CS;
  329.     CIO->ctrl = ZCIO_CS_SIE |
  330.                 ZCIO_CS_GCB |
  331. ZCIO_CS_TCB; /* enable int.
  332.    no gate
  333.    trigger (load) */
  335.     sysClkRunning = TRUE;
  337.     /* don't unmask the CIO interrupt if no system clocks are running */
  339.     if (sysClkRunning || sysAuxClkRunning)
  340.         {
  341.         CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control  */ 
  342.         junk      =  CIO->ctrl;
  343.         CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control  */
  344.         CIO->ctrl =  ZCIO_MIC_MIE | junk;   /* Master Interrupt Enable    */
  345.         }
  347.     }
  349. /*******************************************************************************
  350. *
  351. * sysClkRateGet - get the system clock rate
  352. *
  353. * This routine returns the system clock rate.
  354. *
  355. * RETURNS: The number of ticks per second of the system clock.
  356. *
  357. * SEE ALSO: sysClkEnable(), sysClkRateSet()
  358. */
  360. int sysClkRateGet (void)
  362.     {
  363.     return (sysClkTicksPerSecond);
  364.     }
  366. /*******************************************************************************
  367. *
  368. * sysClkRateSet - set the system clock rate
  369. *
  370. * This routine sets the interrupt rate of the system clock.
  371. * It is called by usrRoot() in usrConfig.c.
  372. *
  373. * NOTE: Since the CIO contains only a 16-bit counter, if the time constant 
  374. * exceeds 65535, the counter uses 32 ticks/sec.  A value less than 32 ticks/sec.
  375. * does not increase the tick period beyond 32ms.
  376. *
  377. * RETURNS: OK, or ERROR if the tick rate is invalid.
  378. *
  379. * SEE ALSO: sysClkEnable(), sysClkRateGet()
  380. */
  382. STATUS sysClkRateSet 
  383.     (
  384.     int ticksPerSecond  /* number of clock interrupts per second */
  385.     )
  387.     {
  388.     if (ticksPerSecond < SYS_CLK_RATE_MIN || ticksPerSecond > SYS_CLK_RATE_MAX)
  389.         return (ERROR);
  391.     sysClkTicksPerSecond = ticksPerSecond;
  392.     if (sysClkRunning)
  393.         {
  394. sysClkDisable ();
  395. sysClkEnable ();
  396. }
  397.    
  398.     return (OK);
  399.     }
  401. /*******************************************************************************
  402. *
  403. * sysAuxClkInt - handle an auxiliary clock interrupt
  404. *
  405. * This routine handles auxiliary clock interrupts by calling
  406. * the routine installed by sysClkConnect().
  407. *
  408. * The auxiliary clock is driven by Counter/Timer 2 of the CIO.
  409. *
  410. * RETURNS: N/A
  411. *
  412. * SEE ALSO: sysAuxClkConnect()
  413. *
  414. * NOMANUAL
  415. */
  417. void sysAuxClkInt (void)
  419.     {
  420.     /* reset IUS and IP, don't gate */
  422.     CIO->ctrl = ZCIO_CT2CS;
  423.     CIO->ctrl = ZCIO_CS_CLIPIUS | ZCIO_CS_GCB;
  424.  
  425.     /* call auxiliary clock service routine */
  427.     if (sysAuxClkRoutine != NULL)
  428.      (*sysAuxClkRoutine) (sysAuxClkArg);
  429.     }
  431. /*******************************************************************************
  432. *
  433. * sysAuxClkConnect - connect a routine to the auxiliary clock interrupt
  434. *
  435. * This routine specifies the interrupt service routine to be called at each
  436. * auxiliary clock interrupt.  It does not enable auxiliary clock
  437. * interrupts.
  438. *
  439. * RETURNS: OK, always. 
  440. *
  441. * SEE ALSO: intConnect(), sysAuxClkEnable(), sysAuxClkDisconnect(),
  442. *      sysAuxClkInt()
  443. */
  445. STATUS sysAuxClkConnect 
  446.     (
  447.     FUNCPTR routine,    /* routine called at each aux. clock interrupt */
  448.     int     arg         /* argument with which to call routine         */
  449.     )
  451.     {
  452.     /*
  453.      * Assumes that the interrupt from the CIO has already been
  454.      * connected.
  455.      */
  457.     sysAuxClkRoutine = routine;
  458.     sysAuxClkArg = arg;
  459.     return (OK);
  460.     }
  462. /*******************************************************************************
  463. *
  464. * sysAuxClkDisable - turn off auxiliary clock interrupts
  465. *
  466. * This routine disables auxiliary clock interrupts.
  467. *
  468. * RETURNS: N/A
  469. *
  470. * SEE ALSO: sysAuxClkEnable()
  471. */
  473. void sysAuxClkDisable (void)
  475.     {
  476.     volatile unsigned char junk;
  478.     if (!sysAuxClkRunning)
  479. return;
  481.     /* mask CIO interrupts to ensure that the CIO access state machine
  482.     is not corrupted */
  484.     CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control     */
  485.     junk      =  CIO->ctrl;
  486.     CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control     */
  487.     CIO->ctrl =  (~ZCIO_MIC_MIE) & junk;   /* Master Interrupt Disable   */
  489.     /* Disable Timer 2 interrupts from the CIO */
  490.     junk = CIO->ctrl; /* reset the CIO state machine */
  491.     CIO->ctrl = ZCIO_CT2CS;
  492.     CIO->ctrl = ZCIO_CS_CLIE;   /* clear Interrupt Enable
  493.    Gate Counter */
  495.     sysAuxClkRunning = FALSE;
  497.     /* don't unmask the CIO interrupt if no system clocks are running */
  499.     if (sysClkRunning || sysAuxClkRunning)
  500.         {
  501.         CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control  */
  502.         junk      =  CIO->ctrl;
  503.         CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control */
  504.         CIO->ctrl =  ZCIO_MIC_MIE | junk;   /* Master Interrupt Enable   */
  505.         }
  507.     }
  509. /*******************************************************************************
  510. *
  511. * sysAuxClkEnable - turn on auxiliary clock interrupts
  512. *
  513. * This routine enables auxiliary clock interrupts.
  514. *
  515. * NOTE: To calculate the time constant of the CIO Timer 1, use the following
  516. * formula:
  517. * .CS
  518. * "CIO_CLK" PCLK ticks   1 timer tick     1 sec
  519. * -------------------- x ------------ x --------------------
  520. *        1 sec           2 PCLK ticks   sysClkTicksPerSecond
  521. * .CE
  522. * The result is the number of timer ticks it takes to achieve the desired
  523. * number of ticks/sec.  This number is calculated as a long integer,
  524. * however, the CIO uses a 16-bit time constant.  If the result is greater
  525. * than 65535, the time constant is set to 65535.  A time constant of 65535
  526. * is almost 32 milliseconds (31.47 ticks/sec.).
  527. *
  528. * CIO_CLK is defined in ep960jx.h.
  529. *
  530. * NOTE: Timers are clocked at a rate of 1/2 of PCLK.  
  531. *
  532. * RETURNS: N/A
  533. *
  534. * SEE ALSO: sysAuxClkConnect(), sysAuxClkDisable(), sysAuxClkRateSet(),
  535. * .I "Zilog Z8536 CIO Counter/Timer Technical Manual"
  536. */
  538. void sysAuxClkEnable (void)
  540.     {
  541.     long num_ticks = 0; /* number of ticks needed */
  542.     volatile unsigned char junk;
  544.     if (sysAuxClkRunning)
  545. return;
  547.     /* mask CIO interrupts to ensure that the CIO access state machine
  548.     is not corrupted */
  550.     CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control     */
  551.     junk      =  CIO->ctrl;
  552.     CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control     */
  553.     CIO->ctrl =  (~ZCIO_MIC_MIE) & junk;   /* Master Interrupt Disable   */
  555.     /* Disable Timer 2 interrupts from the CIO */
  556.     junk = CIO->ctrl; /* reset the CIO state machine */
  557.     CIO->ctrl = ZCIO_CT2CS;
  558.     CIO->ctrl = ZCIO_CS_CLIE; /* clear Interrupt Enable
  559.    Gate Counter */
  561.     /* set up the CIO Time Constant registers based on the value
  562.        of sysAuxClkTicksPerSecond */
  564.     if (sysAuxClkTicksPerSecond < AUX_CLK_RATE_MIN) 
  565.         num_ticks = 0x0ffff; 
  566.  
  567.     else if (sysAuxClkTicksPerSecond > AUX_CLK_RATE_MAX) 
  568.         num_ticks = 0x01; 
  569.  
  570.     else 
  571.         num_ticks = (long) (CIO_CLK / (2 * sysAuxClkTicksPerSecond));
  573.     /* Set up Counter/Timer 2 Mode */
  574.     CIO->ctrl = ZCIO_CT2MS;
  575.     CIO->ctrl = ZCIO_CTMS_CSC; /* continuous cycle
  576.    no external signals used
  577.    pulse output */
  579.     /* Load time constant into Counter/timer 2's TC registers */
  580.     CIO->ctrl = ZCIO_CT2TCMSB; /* Timer 2 time constant MSB */
  581.     CIO->ctrl = (num_ticks >> 8) & 0x0ff;
  582.     CIO->ctrl = ZCIO_CT2TCLSB; /* Timer 2 time constant LSB */
  583.     CIO->ctrl = num_ticks & 0x0ff;
  585.     CIO->ctrl = ZCIO_CT2CS;
  586.     CIO->ctrl = ZCIO_CS_CLIPIUS; /* clear IP and IUS, gate */
  588.     CIO->ctrl = ZCIO_MCC;
  589.     junk = CIO->ctrl;
  590.     CIO->ctrl = ZCIO_MCC;
  591.     CIO->ctrl = junk | 0x20;        /* enable Timer 2 */
  592.  
  593.     CIO->ctrl = ZCIO_CT2CS;
  594.     CIO->ctrl = ZCIO_CS_SIE |
  595.                 ZCIO_CS_GCB |
  596.         ZCIO_CS_TCB; /* enable int.
  597.    no gate
  598.    trigger (load) */
  600.     sysAuxClkRunning = TRUE;
  602.     /* don't unmask the CIO interrupt if no system clocks are running */
  604.     if (sysClkRunning || sysAuxClkRunning)
  605.         {
  606.         CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control */
  607.         junk      =  CIO->ctrl;
  608.         CIO->ctrl =  ZCIO_MIC;               /* Master Interrupt Control */
  609.         CIO->ctrl =  ZCIO_MIC_MIE | junk;    /* Master Interrupt Disable */
  610.         }
  612.     }
  614. /*******************************************************************************
  615. *
  616. * sysAuxClkRateGet - get the auxiliary clock rate
  617. *
  618. * This routine returns the interrupt rate of the auxiliary clock.
  619. *
  620. * RETURNS: Number of ticks per second of the auxiliary clock.
  621. *
  622. * SEE ALSO: sysAuxClkEnable(), sysAuxClkRateSet()
  623. */
  625. int sysAuxClkRateGet (void)
  626.     {
  627.     return (sysAuxClkTicksPerSecond);
  628.     }
  630. /*******************************************************************************
  631. *
  632. * sysAuxClkRateSet - set the auxiliary clock rate
  633. *
  634. * This routine sets the interrupt rate of the auxiliary clock.  It does not
  635. * enable auxiliary clock interrupts.  
  636. *
  637. * RETURNS: OK, or ERROR if the tick rate is invalid.
  638. *
  639. * SEE ALSO: sysAuxClkEnable(), sysAuxClkRateGet()
  640. */
  642. STATUS sysAuxClkRateSet 
  643.     (
  644.     int ticksPerSecond  /* number of clock interrupts per second */
  645.     )
  647.     {
  648.     if (ticksPerSecond < AUX_CLK_RATE_MIN || ticksPerSecond > AUX_CLK_RATE_MAX)
  649.         return (ERROR);
  651.     sysAuxClkTicksPerSecond = ticksPerSecond;
  653.     if (sysAuxClkRunning)
  654. {
  655. sysAuxClkDisable ();
  656. sysAuxClkEnable ();
  657. }
  659.     return (OK);
  660.     }