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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
m85xxTimer.c
资源名称：mpc8548.rar　[点击查看]
上传用户：dqzhongke1
上传日期：2022-06-26
资源大小：667k
文件大小：31k
源码类别：

VxWorks

开发平台：

C/C++

m85xxTimer.c：源码内容
  1. /* m85xxTimer.c - PowerPC Book E timer library */
  3. /*
  4. ****************************************************************************
  5.    This source and object code has been made available to you by IBM on an
  6.    AS-IS basis.
  8.    IT IS PROVIDED WITHOUT WARRANTY OF ANY KIND, INCLUDING THE WARRANTIES OF
  9.    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE OR OF NONINFRINGEMENT
  10.    OF THIRD PARTY RIGHTS.  IN NO EVENT SHALL IBM OR ITS LICENSORS BE LIABLE
  11.    FOR INCIDENTAL, CONSEQUENTIAL OR PUNITIVE DAMAGES.  IBMS OR ITS LICENSORS
  12.    DAMAGES FOR ANY CAUSE OF ACTION, WHETHER IN CONTRACT OR IN TORT, AT LAW OR
  13.    AT EQUITY, SHALL BE LIMITED TO A MAXIMUM OF $1,000 PER LICENSE.  No license
  14.    under IBM patents or patent applications is to be implied by the copyright
  15.    license.
  17.    Any user of this software should understand that neither IBM nor its
  18.    licensors will be responsible for any consequences resulting from the use
  19.    of this software.
  21.    Any person who transfers this source code or any derivative work must
  22.    include the IBM copyright notice, this paragraph, and the preceding two
  23.    paragraphs in the transferred software.
  25.    Any person who transfers this object code or any derivative work must
  26.    include the IBM copyright notice in the transferred software.
  28.    COPYRIGHT   I B M   CORPORATION 2000
  29.    LICENSED MATERIAL  -  PROGRAM PROPERTY OF  I B M"
  31. ****************************************************************************
  32. NOMANUAL
  33. */
  35. /* Copyright 1984-2004 Wind River Systems, Inc. */
  37. /*
  38. modification history
  39. --------------------
  40. 01f,22oct04,dtr  Remove gnu compiler warning.
  41. 01e,01sep04,pch  fix masks in wdtTable
  42. 01d,31aug04,mdo  Documentation fixes for apigen
  43. 01c,05dec01,mcg  remove #include of ppc403Timer.c, used ppc440.h instead
  44. 01b,08nov01,jtp  TSR fields now cleared correctly
  45. 01a,24oct01,jtp  checked in. mcg ported this from ppc405Timer.c version 01h
  46. */
  48. /*
  49. DESCRIPTION
  50. This library provides PowerPC Book E Timer routines. This library handles
  51. the system clock, the auxiliary clock and timestamp functions. To
  52. include the timestamp timer facility, the macro INCLUDE_TIMESTAMP must
  53. be defined.
  55. The macros SYS_CLK_RATE_MIN, SYS_CLK_RATE_MAX, AUX_CLK_RATE_MIN, and
  56. AUX_CLK_RATE_MAX must be defined to provide parameter checking for
  57. sysClkRateSet().
  59. The BSP is responsible for connecting the interrupt handlers,
  60. sysClkInt(), and sysAuxClkInt(), to the appropriate vectors.
  62. The BSP must also initialize a global variable sysTimerClkFreq prior to using
  63. this driver to indicate what frequency the timebase is running.  This value
  64. is often calculated at run time, especially when an internal timer clock source
  65. is being used.
  67. INCLUDE FILES:
  69. SEE ALSO:
  70. .pG "Configuration"
  71. */
  73. /* includes */
  74. #include "vxWorks.h"
  75. #include "vxLib.h"
  76. #include "intLib.h"
  77. #include "drv/timer/timestampDev.h"
  79. /* local defines */
  81. /* extern declarations */
  83. IMPORT UINT32 sysTimerClkFreq;
  85. /* typedefs */
  87. typedef struct
  88.     {
  89.     unsigned long long fitPeriod;         /* Fixed Interval Timer periods */
  90.     UINT32   fpMask;                      /* corresponding TCR mask       */
  91.     } FIT_PERIOD;
  93. typedef struct
  94.     {
  95.     unsigned long long wdtPeriod;         /* Watchdog Timer periods       */
  96.     UINT32   fpMask;                      /* corresponding TCR mask       */
  97.     } WDT_PERIOD;
  99. /* Locals */
  101. LOCAL FIT_PERIOD fitTable[] =                   /* available FIT periods */
  102.     {
  103. { ((unsigned long long) 1 << 0), 0x0301e000 }, /* TBL[63] */
  104. { ((unsigned long long) 1 << 1), 0x0201e000 }, /* TBL[62] */
  105. { ((unsigned long long) 1 << 2), 0x0101e000 }, /* TBL[61] */
  106. { ((unsigned long long) 1 << 3), 0x0001e000 }, /* TBL[60] */
  107. { ((unsigned long long) 1 << 4), 0x0301c000 }, /* TBL[59] */
  108. { ((unsigned long long) 1 << 5), 0x0201c000 }, /* TBL[58] */
  109. { ((unsigned long long) 1 << 6), 0x0101c000 }, /* TBL[57] */
  110. { ((unsigned long long) 1 << 7), 0x0001c000 }, /* TBL[56] */
  111. { ((unsigned long long) 1 << 8), 0x0301a000 }, /* TBL[55] */
  112. { ((unsigned long long) 1 << 9), 0x0201a000 }, /* TBL[54] */
  113. { ((unsigned long long) 1 << 10), 0x0101a000 }, /* TBL[53] */
  114. { ((unsigned long long) 1 << 11), 0x0001a000 }, /* TBL[52] */
  115. { ((unsigned long long) 1 << 12), 0x03018000 }, /* TBL[51] */
  116. { ((unsigned long long) 1 << 13), 0x02018000 }, /* TBL[50] */
  117. { ((unsigned long long) 1 << 14), 0x01018000 }, /* TBL[49] */
  118. { ((unsigned long long) 1 << 15), 0x00018000 }, /* TBL[48] */
  119. { ((unsigned long long) 1 << 16), 0x03016000 }, /* TBL[47] */
  120. { ((unsigned long long) 1 << 17), 0x02016000 }, /* TBL[46] */
  121. { ((unsigned long long) 1 << 18), 0x01016000 }, /* TBL[45] */
  122. { ((unsigned long long) 1 << 19), 0x00016000 }, /* TBL[44] */
  123. { ((unsigned long long) 1 << 20), 0x03014000 }, /* TBL[43] */
  124. { ((unsigned long long) 1 << 21), 0x02014000 }, /* TBL[42] */
  125. { ((unsigned long long) 1 << 22), 0x01014000 }, /* TBL[41] */
  126. { ((unsigned long long) 1 << 23), 0x00014000 }, /* TBL[40] */
  127. { ((unsigned long long) 1 << 24), 0x03012000 }, /* TBL[39] */
  128. { ((unsigned long long) 1 << 25), 0x02012000 }, /* TBL[38] */
  129. { ((unsigned long long) 1 << 26), 0x01012000 }, /* TBL[37] */
  130. { ((unsigned long long) 1 << 27), 0x00012000 }, /* TBL[36] */
  131. { ((unsigned long long) 1 << 28), 0x03010000 }, /* TBL[35] */
  132. { ((unsigned long long) 1 << 29), 0x02010000 }, /* TBL[34] */
  133. { ((unsigned long long) 1 << 30), 0x01010000 }, /* TBL[33] */
  134. { ((unsigned long long) 1 << 31), 0x00010000 }, /* TBL[32] */
  135. { ((unsigned long long) 1 << 32), 0x0300e000 }, /* TBU[31] */
  136. { ((unsigned long long) 1 << 33), 0x0200e000 }, /* TBU[30] */
  137. { ((unsigned long long) 1 << 34), 0x0100e000 }, /* TBU[29] */
  138. { ((unsigned long long) 1 << 35), 0x0000e000 }, /* TBU[28] */
  139. { ((unsigned long long) 1 << 36), 0x0300c000 }, /* TBU[27] */
  140. { ((unsigned long long) 1 << 37), 0x0200c000 }, /* TBU[26] */
  141. { ((unsigned long long) 1 << 38), 0x0100c000 }, /* TBU[25] */
  142. { ((unsigned long long) 1 << 39), 0x0000c000 }, /* TBU[24] */
  143. { ((unsigned long long) 1 << 40), 0x0300a000 }, /* TBU[23] */
  144. { ((unsigned long long) 1 << 41), 0x0200a000 }, /* TBU[22] */
  145. { ((unsigned long long) 1 << 42), 0x0100a000 }, /* TBU[21] */
  146. { ((unsigned long long) 1 << 43), 0x0000a000 }, /* TBU[20] */
  147. { ((unsigned long long) 1 << 44), 0x03008000 }, /* TBU[19] */
  148. { ((unsigned long long) 1 << 45), 0x02008000 }, /* TBU[18] */
  149. { ((unsigned long long) 1 << 46), 0x01008000 }, /* TBU[17] */
  150. { ((unsigned long long) 1 << 47), 0x00008000 }, /* TBU[16] */
  151. { ((unsigned long long) 1 << 48), 0x03006000 }, /* TBU[15] */
  152. { ((unsigned long long) 1 << 49), 0x02006000 }, /* TBU[14] */
  153. { ((unsigned long long) 1 << 50), 0x01006000 }, /* TBU[13] */
  154. { ((unsigned long long) 1 << 51), 0x00006000 }, /* TBU[12] */
  155. { ((unsigned long long) 1 << 52), 0x03004000 }, /* TBU[11] */
  156. { ((unsigned long long) 1 << 53), 0x02004000 }, /* TBU[10] */
  157. { ((unsigned long long) 1 << 54), 0x01004000 }, /* TBU[9] */
  158. { ((unsigned long long) 1 << 55), 0x00004000 }, /* TBU[8] */
  159. { ((unsigned long long) 1 << 56), 0x03002000 }, /* TBU[7] */
  160. { ((unsigned long long) 1 << 57), 0x02002000 }, /* TBU[6] */
  161. { ((unsigned long long) 1 << 58), 0x01002000 }, /* TBU[5] */
  162. { ((unsigned long long) 1 << 59), 0x00002000 }, /* TBU[4] */
  163. { ((unsigned long long) 1 << 60), 0x03000000 }, /* TBU[3] */
  164. { ((unsigned long long) 1 << 61), 0x02000000 }, /* TBU[2] */
  165. { ((unsigned long long) 1 << 62), 0x01000000 }, /* TBU[1] */
  166. { ((unsigned long long) 1 << 63), 0x00000000 } /* TBU[0] */
  167.     };
  169. LOCAL WDT_PERIOD wdtTable[] =                   /* available WDT periods */
  170.     {
  171. { ((unsigned long long) 1 << 0),  0xc01e0000 }, /* TBL[63] */
  172. { ((unsigned long long) 1 << 1),  0x801e0000 }, /* TBL[62] */
  173. { ((unsigned long long) 1 << 2),  0x401e0000 }, /* TBL[61] */
  174. { ((unsigned long long) 1 << 3),  0x001e0000 }, /* TBL[60] */
  175. { ((unsigned long long) 1 << 4),  0xc01c0000 }, /* TBL[59] */
  176. { ((unsigned long long) 1 << 5),  0x801c0000 }, /* TBL[58] */
  177. { ((unsigned long long) 1 << 6),  0x401c0000 }, /* TBL[57] */
  178. { ((unsigned long long) 1 << 7),  0x001c0000 }, /* TBL[56] */
  179. { ((unsigned long long) 1 << 8),  0xc01a0000 }, /* TBL[55] */
  180. { ((unsigned long long) 1 << 9),  0x801a0000 }, /* TBL[54] */
  181. { ((unsigned long long) 1 << 10), 0x401a0000 }, /* TBL[53] */
  182. { ((unsigned long long) 1 << 11), 0x001a0000 }, /* TBL[52] */
  183. { ((unsigned long long) 1 << 12), 0xc0180000 }, /* TBL[51] */
  184. { ((unsigned long long) 1 << 13), 0x80180000 }, /* TBL[50] */
  185. { ((unsigned long long) 1 << 14), 0x40180000 }, /* TBL[49] */
  186. { ((unsigned long long) 1 << 15), 0x00180000 }, /* TBL[48] */
  187. { ((unsigned long long) 1 << 16), 0xc0160000 }, /* TBL[47] */
  188. { ((unsigned long long) 1 << 17), 0x80160000 }, /* TBL[46] */
  189. { ((unsigned long long) 1 << 18), 0x40160000 }, /* TBL[45] */
  190. { ((unsigned long long) 1 << 19), 0x00160000 }, /* TBL[44] */
  191. { ((unsigned long long) 1 << 20), 0xc0140000 }, /* TBL[43] */
  192. { ((unsigned long long) 1 << 21), 0x80140000 }, /* TBL[42] */
  193. { ((unsigned long long) 1 << 22), 0x40140000 }, /* TBL[41] */
  194. { ((unsigned long long) 1 << 23), 0x00140000 }, /* TBL[40] */
  195. { ((unsigned long long) 1 << 24), 0xc0120000 }, /* TBL[39] */
  196. { ((unsigned long long) 1 << 25), 0x80120000 }, /* TBL[38] */
  197. { ((unsigned long long) 1 << 26), 0x40120000 }, /* TBL[37] */
  198. { ((unsigned long long) 1 << 27), 0x00120000 }, /* TBL[36] */
  199. { ((unsigned long long) 1 << 28), 0xc0100000 }, /* TBL[35] */
  200. { ((unsigned long long) 1 << 29), 0x80100000 }, /* TBL[34] */
  201. { ((unsigned long long) 1 << 30), 0x40100000 }, /* TBL[33] */
  202. { ((unsigned long long) 1 << 31), 0x00100000 }, /* TBL[32] */
  203. { ((unsigned long long) 1 << 32), 0xc00e0000 }, /* TBU[31] */
  204. { ((unsigned long long) 1 << 33), 0x800e0000 }, /* TBU[30] */
  205. { ((unsigned long long) 1 << 34), 0x400e0000 }, /* TBU[29] */
  206. { ((unsigned long long) 1 << 35), 0x000e0000 }, /* TBU[28] */
  207. { ((unsigned long long) 1 << 36), 0xc00c0000 }, /* TBU[27] */
  208. { ((unsigned long long) 1 << 37), 0x800c0000 }, /* TBU[26] */
  209. { ((unsigned long long) 1 << 38), 0x400c0000 }, /* TBU[25] */
  210. { ((unsigned long long) 1 << 39), 0x000c0000 }, /* TBU[24] */
  211. { ((unsigned long long) 1 << 40), 0xc00a0000 }, /* TBU[23] */
  212. { ((unsigned long long) 1 << 41), 0x800a0000 }, /* TBU[22] */
  213. { ((unsigned long long) 1 << 42), 0x400a0000 }, /* TBU[21] */
  214. { ((unsigned long long) 1 << 43), 0x000a0000 }, /* TBU[20] */
  215. { ((unsigned long long) 1 << 44), 0xc0080000 }, /* TBU[19] */
  216. { ((unsigned long long) 1 << 45), 0x80080000 }, /* TBU[18] */
  217. { ((unsigned long long) 1 << 46), 0x40080000 }, /* TBU[17] */
  218. { ((unsigned long long) 1 << 47), 0x00080000 }, /* TBU[16] */
  219. { ((unsigned long long) 1 << 48), 0xc0060000 }, /* TBU[15] */
  220. { ((unsigned long long) 1 << 49), 0x80060000 }, /* TBU[14] */
  221. { ((unsigned long long) 1 << 50), 0x40060000 }, /* TBU[13] */
  222. { ((unsigned long long) 1 << 51), 0x00060000 }, /* TBU[12] */
  223. { ((unsigned long long) 1 << 52), 0xc0040000 }, /* TBU[11] */
  224. { ((unsigned long long) 1 << 53), 0x80040000 }, /* TBU[10] */
  225. { ((unsigned long long) 1 << 54), 0x40040000 }, /* TBU[9]  */
  226. { ((unsigned long long) 1 << 55), 0x00040000 }, /* TBU[8]  */
  227. { ((unsigned long long) 1 << 56), 0xc0020000 }, /* TBU[7]  */
  228. { ((unsigned long long) 1 << 57), 0x80020000 }, /* TBU[6]  */
  229. { ((unsigned long long) 1 << 58), 0x40020000 }, /* TBU[5]  */
  230. { ((unsigned long long) 1 << 59), 0x00020000 }, /* TBU[4]  */
  231. { ((unsigned long long) 1 << 60), 0xc0000000 }, /* TBU[3]  */
  232. { ((unsigned long long) 1 << 61), 0x80000000 }, /* TBU[2]  */
  233. { ((unsigned long long) 1 << 62), 0x40000000 }, /* TBU[1]  */
  234. { ((unsigned long long) 1 << 63), 0x00000000 } /* TBU[0] */
  235.     };
  237. LOCAL int       sysClkTicksPerSecond    = 60;   /* default ticks/second */
  238. LOCAL FUNCPTR   sysClkRoutine           = NULL;
  239. LOCAL int       sysClkArg               = (int)NULL;
  240. LOCAL BOOL      sysClkConnectFirstTime  = TRUE;
  241. LOCAL BOOL      sysClkRunning           = FALSE;
  243. LOCAL int       sysAuxClkTicksPerSecond = 0;
  244. LOCAL FUNCPTR   sysAuxClkRoutine        = NULL;
  245. LOCAL int       sysAuxClkArg            = (int)NULL;
  246. LOCAL BOOL      sysAuxClkRunning        = FALSE;
  248. LOCAL int       sysWdtTicksPerSecond    = 0;
  249. LOCAL FUNCPTR   sysWdtRoutine           = NULL;
  250. LOCAL int       sysWdtArg               = (int)NULL;
  251. LOCAL BOOL      sysWdtRunning           = FALSE;
  253. LOCAL UINT32    decCountVal;                    /* DEC counter value */
  254. LOCAL UINT32    fitPeriodMask = 0x00000000;     /* used to set TCR[FP]      */
  255. LOCAL UINT32    wdtPeriodMask = 0x00000000;     /* used to set TCR[WP]      */
  257. #ifdef  INCLUDE_TIMESTAMP
  258. LOCAL BOOL      sysTimestampRunning = FALSE;    /* timestamp running flag */
  259. #endif  /* INCLUDE_TIMESTAMP */
  262. #define TCR_WP          (_PPC_TCR_WP_U    << 16)
  263. #define TCR_WP_EXT      (0x001e  << 16)
  264. #define TCR_WRC         (_PPC_TCR_WRC_U   << 16)
  265. #define TCR_WIE         (_PPC_TCR_WIE_U   << 16)
  266. #define TCR_DIE         (_PPC_TCR_DIE)
  267. #define TCR_FP          (_PPC_TCR_FP_U    << 16)
  268. #define TCR_FP_EXT      (0x0001e000)
  269. #define TCR_FIE         (_PPC_TCR_FIE_U   << 16)
  270. #define TCR_ARE         (_PPC_TCR_ARE_U   << 16)
  272. #define TSR_ENW         (_PPC_TSR_ENW_U   << 16)
  273. #define TSR_WIS         (_PPC_TSR_WIS_U   << 16)
  274. #define TSR_WRS         (_PPC_TSR_WRS_U   << 16)
  275. #define TSR_DIS         (_PPC_TSR_DIS)
  276. #define TSR_FIS         (_PPC_TSR_FIS_U   << 16)
  279. /***************************************************************************
  280. *
  281. * sysClkInt - clock interrupt handler
  282. *
  283. * This routine handles the clock interrupt on the PowerPC Book E
  284. * architecture. It is attached to the Programmable Interval Timer vector
  285. * by the routine sysClkConnect().
  286. *
  287. * RETURNS : N/A
  288. */
  290. LOCAL void sysClkInt (void)
  291.     {
  292.     /* Acknowledge DEC interrupt */
  294.     vxDecIntAck ();
  296.     /* The DEC reloads itself automatically from DECAR */
  298.     /* Execute the system clock routine */
  300.     if (sysClkRoutine != NULL)
  301.         (*(FUNCPTR) sysClkRoutine) (sysClkArg);
  303.     }
  305. /***************************************************************************
  306. *
  307. * sysClkConnect - connect a routine to the system clock interrupt
  308. *
  309. * This routine specifies the interrupt service routine to be called at
  310. * each clock interrupt. Normally, it is called from usrRoot() in
  311. * usrConfig.c to connect usrClock() to the system clock interrupt. It
  312. * also connects the clock error interrupt service routine.
  313. *
  314. * RETURNS: OK, or ERROR if the routine cannot be connected to the
  315. * interrupt.
  316. *
  317. * SEE ALSO: usrClock(), sysClkEnable()
  318. */
  320. STATUS sysClkConnect
  321.     (
  322.     FUNCPTR     routine,        /* routine to connect */
  323.     int         arg             /* argument with which to call the routine */
  324.     )
  325.     {
  327.     if (sysClkConnectFirstTime)
  328.         {
  329.         sysHwInit2();
  330.         sysClkConnectFirstTime = FALSE;
  331.         }
  333.     sysClkRoutine       = routine;
  334.     sysClkArg           = arg;
  336.     return (OK);
  337.     }
  339. /***************************************************************************
  340. *
  341. * sysClkEnable - turn on system clock interrupts
  342. *
  343. * This routine enables system clock interrupts.
  344. *
  345. * RETURNS: N/A
  346. *
  347. * SEE ALSO: sysClkConnect(), sysClkDisable(), sysClkRateSet()
  348. */
  350. void sysClkEnable (void)
  351.     {
  352.     if (!sysClkRunning)
  353.         {
  354.         /* clear the pending DEC interrupt */
  355.         vxTsrSet (TSR_DIS);
  357.         /* load the DEC counter and DECAR with interval value */
  358.         vxDecarSet (decCountVal);
  359.         vxDecSet (decCountVal);
  361.         /* Enable the DEC interrupt & enable autoreload */
  362.         vxTcrSet (vxTcrGet() | TCR_DIE | TCR_ARE);
  364. /* Enable the TBEN in HID0 */
  365. vxHid0Set (vxHid0Get() | _PPC_HID0_TBEN);
  367.         /* set the running flag */
  369.         sysClkRunning = TRUE;
  370.         }
  371.     }
  373. /***************************************************************************
  374. *
  375. * sysClkDisable - turn off system clock interrupts
  376. *
  377. * This routine disables system clock interrupts.
  378. *
  379. * RETURNS: N/A
  380. *
  381. * SEE ALSO: sysClkEnable()
  382. */
  384. void sysClkDisable (void)
  385.     {
  386.     if (sysClkRunning)
  387.         {
  388.         /* disable the DEC interrupt and auto-reload capability */
  390.         vxTcrSet (vxTcrGet() & ~ (TCR_DIE | TCR_ARE));
  392.         /* clear the DEC counter and DECAR */
  394.         vxDecSet (0);
  396.         /* clear the pending DEC interrupt */
  398.         vxTsrSet (TSR_DIS);
  400.         /* reset the running flag */
  402.         sysClkRunning = FALSE;
  403.         }
  404.     }
  406. /***************************************************************************
  407. *
  408. * sysClkRateGet - get the system clock rate
  409. *
  410. * This routine returns the system clock rate.
  411. *
  412. * RETURNS: The number of ticks per second of the system clock.
  413. *
  414. * SEE ALSO: sysClkEnable(), sysClkRateSet()
  415. */
  417. int sysClkRateGet (void)
  418.     {
  419.     return (sysClkTicksPerSecond);
  420.     }
  422. /***************************************************************************
  423. *
  424. * sysClkRateSet - set the system clock rate
  425. *
  426. * This routine sets the interrupt rate of the system clock. It does not
  427. * enable system clock interrupts. It is called by usrRoot() in
  428. * usrConfig.c.
  429. *
  430. * RETURNS: OK, or ERROR if the tick rate is invalid or the timer cannot
  431. * be set.
  432. *
  433. * SEE ALSO: sysClkEnable(), sysClkRateGet()
  434. */
  436. STATUS sysClkRateSet
  437.     (
  438.     int         ticksPerSecond  /* number of clock interrupts per second */
  439.     )
  440.     {
  441.     if (ticksPerSecond < SYS_CLK_RATE_MIN || ticksPerSecond > SYS_CLK_RATE_MAX)
  442.         return (ERROR);
  444.     /* save the clock speed */
  446.     sysClkTicksPerSecond = ticksPerSecond;
  448.     /*
  449.      * compute the value to load in the decrementer. The new value will
  450.      * be loaded into the decrementer after the end of the current period
  451.      */
  453.     decCountVal = sysTimerClkFreq / ticksPerSecond;
  455.     /* Update the DEC interval  FIX 11/27/00 */
  457.     vxDecarSet (decCountVal);
  458.     vxDecSet (decCountVal);
  460.     return (OK);
  461.     }
  463. /***************************************************************************
  464. *
  465. * sysAuxClkInt - auxiliary clock interrupt handler
  466. *
  467. * This routine handles the auxiliary clock interrupt on the PowerPC Book E
  468. * architecture. It is attached to the Fix Interval Timer vector by the
  469. * routine sysAuxClkConnect().
  470. *
  471. * RETURNS : N/A
  472. */
  474. void sysAuxClkInt (void)
  475.     {
  476.     vxFitIntAck ();             /* acknowledge FIT interrupt */
  478.     /* program TCR with the FIT period */
  480.     vxTcrSet ((vxTcrGet() & ~(TCR_FP|TCR_FP_EXT)) | fitPeriodMask);
  482.     /* execute the system clock routine */
  484.     if (sysAuxClkRoutine != NULL)
  485.         (*(FUNCPTR) sysAuxClkRoutine) (sysAuxClkArg);
  487.     }
  488. /***************************************************************************
  489. *
  490. * sysAuxClkConnect - connect a routine to the auxiliary clock interrupt
  491. *
  492. * This routine specifies the interrupt service routine to be called at
  493. * each auxiliary clock interrupt. It does not enable auxiliary clock
  494. * interrupts.
  495. *
  496. * RETURNS: OK, or ERROR if the routine cannot be connected to the
  497. * interrupt.
  498. *
  499. * SEE ALSO: excIntConnectTimer(), sysAuxClkEnable()
  500. */
  502. STATUS sysAuxClkConnect
  503.     (
  504.     FUNCPTR     routine, /* routine called at each aux. clock interrupt */
  505.     int         arg      /* argument to auxiliary clock interrupt */
  506.     )
  507.     {
  509.     sysAuxClkRoutine    = routine;
  510.     sysAuxClkArg        = arg;
  512.     return (OK);
  513.     }
  515. /***************************************************************************
  516. *
  517. * sysAuxClkEnable - turn on auxiliary clock interrupts
  518. *
  519. * This routine enables auxiliary clock interrupts.
  520. *
  521. * RETURNS: N/A
  522. *
  523. * SEE ALSO: sysAuxClkConnect(), sysAuxClkDisable(), sysAuxClkRateSet()
  524. */
  526. void sysAuxClkEnable (void)
  527.     {
  528.     if (!sysAuxClkRunning)
  529.         {
  530.         /* clear the pending FIT interrupt */
  532.         vxTsrSet (TSR_FIS);
  534.         /* program TCR with the FIT period */
  536.         vxTcrSet ((vxTcrGet() & ~(TCR_FP|TCR_FP_EXT)) | fitPeriodMask);
  538.         /* Enable the FIT interrupt */
  540.         vxTcrSet (vxTcrGet() | TCR_FIE);
  542.         /* set the running flag */
  544.         sysAuxClkRunning = TRUE;
  545.         }
  546.     }
  548. /***************************************************************************
  549. *
  550. * sysAuxClkDisable - turn off auxiliary clock interrupts
  551. *
  552. * This routine disables auxiliary clock interrupts.
  553. *
  554. *
  555. * RETURNS: N/A
  556. *
  557. * SEE ALSO: sysAuxClkEnable()
  558. */
  560. void sysAuxClkDisable (void)
  561.     {
  562.     if (sysAuxClkRunning)
  563.         {
  564.         /* disable the FIT interrupt */
  566.         vxTcrSet (vxTcrGet() & (~TCR_FIE));
  568.         /* clear the pending FIT interrupt */
  570.         vxTsrSet (TSR_FIS);
  572.         /* reset the running flag */
  574.         sysAuxClkRunning = FALSE;
  575.         }
  576.     }
  578. /***************************************************************************
  579. *
  580. * sysAuxClkRateGet - get the auxiliary clock rate
  581. *
  582. * This routine returns the interrupt rate of the auxiliary clock.
  583. *
  584. * RETURNS: The number of ticks per second of the auxiliary clock.
  585. *
  586. * SEE ALSO: sysAuxClkEnable(), sysAuxClkRateSet()
  587. */
  589. int sysAuxClkRateGet (void)
  590.     {
  591.     return (sysAuxClkTicksPerSecond);
  592.     }
  594. /***************************************************************************
  595. *
  596. * sysAuxClkRateSet - set the auxiliary clock rate
  597. *
  598. * This routine sets the interrupt rate of the auxiliary clock. It does
  599. * not enable auxiliary clock interrupts.
  600. *
  601. * RETURNS: OK, or ERROR if the tick rate is invalid or the timer cannot
  602. * be set.
  603. *
  604. * SEE ALSO: sysAuxClkEnable(), sysAuxClkRateGet()
  605. */
  607. STATUS sysAuxClkRateSet
  608.     (
  609.     int         ticksPerSecond  /* number of clock interrupts per second */
  610.     )
  611.     {
  612.     int ix;
  613.     int jx = 0;
  614.     unsigned long long fitPeriod;
  616.     /*
  617.      * compute the FIT period.  The closest value to <ticksPerSecond>
  618.      * is being used.
  619.      */
  621.     if (ticksPerSecond < AUX_CLK_RATE_MIN || ticksPerSecond > AUX_CLK_RATE_MAX)
  622.         return (ERROR);
  624.     fitPeriod = (sysTimerClkFreq >> 1) / ticksPerSecond;
  626.     /* get the closest value to ticksPerSecond supported by the FIT */
  628.     for (ix = 0; ix < (int) NELEMENTS (fitTable); ix++)
  629.         {
  630.         if (fitPeriod <= fitTable [ix].fitPeriod)
  631.             {
  632.             if (ix != 0)
  633.                 if ( fitPeriod <
  634.                      ((fitTable [ix].fitPeriod + fitTable [ix-1].fitPeriod)/2))
  635.                     jx = ix-1;
  636.                 else
  637.                     jx = ix;
  638.             else
  639.                 jx = ix;
  640.             break;
  641.             }
  642.         if (ix == NELEMENTS (fitTable) - 1)
  643.             jx = ix;
  644.         }
  645.     fitPeriod = fitTable [jx].fitPeriod;        /* actual period of the FIT */
  646.     fitPeriodMask = fitTable [jx].fpMask;       /* Mask to program TCR with */
  648.     /* save the clock speed */
  650.     sysAuxClkTicksPerSecond = (sysTimerClkFreq >> 1) / fitPeriod;
  652.     return (OK);
  653.     }
  655. /***************************************************************************
  656. *
  657. * sysWdtInt - watchdog interrupt handler.
  658. *
  659. * This routine handles the watchdog interrupt on the PowerPC Book E
  660. * architecture. It is attached to the watchdog timer vector by the
  661. * routine sysWdtConnect().
  662. *
  663. * RETURNS : N/A
  664. */
  666. LOCAL void sysWdtInt (void)
  667.     {
  668.     /* acknowledge WDT interrupt */
  670.     vxTsrSet (TSR_WIS);
  672.     /* execute the watchdog  clock routine */
  674.     if (sysWdtRoutine != NULL)
  675.         (*(FUNCPTR) sysWdtRoutine) (sysWdtArg);
  677.     }
  679. /***************************************************************************
  680. *
  681. * sysWdtConnect - connect a routine to the watchdog interrupt
  682. *
  683. * This routine specifies the interrupt service routine to be called at
  684. * each watchdog interrupt. It does not enable watchdog interrupts.
  685. *
  686. * RETURNS: OK, or ERROR if the routine cannot be connected to the
  687. * watchdog
  688. * interrupt.
  689. *
  690. * SEE ALSO: excIntCrtConnect(), sysWdtEnable()
  691. */
  693. STATUS sysWdtConnect
  694.     (
  695.     FUNCPTR     routine, /* routine called at each watchdog interrupt */
  696.     int         arg      /* argument with which to call routine        */
  697.     )
  698.     {
  699.     /* connect the routine to the WDT vector */
  701.     excIntCrtConnect ((VOIDFUNCPTR *) _EXC_OFF_WD, (VOIDFUNCPTR) sysWdtInt);
  703.     sysWdtRoutine    = routine;
  704.     sysWdtArg        = arg;
  706.     return (OK);
  707.     }
  709. /***************************************************************************
  710. *
  711. * sysWdtEnable - turn on watchdog interrupts
  712. *
  713. * This routine enables watchdog interrupts.
  714. *
  715. * RETURNS: N/A
  716. *
  717. * SEE ALSO: sysWdtConnect(), sysWdtDisable(), sysWdtRateSet()
  718. */
  720. void sysWdtEnable (void)
  721.     {
  722.     if (!sysWdtRunning)
  723.         {
  724.         /* clear the pending WDT interrupt */
  726.         vxTsrSet (TSR_WIS);
  728.         /* program TCR with the WDT period */
  730.         vxTcrSet ((vxTcrGet() & ~(TCR_WP|TCR_WP_EXT)) | wdtPeriodMask);
  732.         /* Enable the WDT interrupt */
  734.         vxTcrSet (vxTcrGet() | TCR_WIE);
  736.         /* Enable critical interrupt */
  738.         vxMsrSet (vxMsrGet() | _PPC_MSR_CE);
  740.         /* set the running flag */
  742.         sysWdtRunning = TRUE;
  743.         }
  744.     }
  746. /***************************************************************************
  747. *
  748. * sysWdtDisable - turn off watchdog interrupts
  749. *
  750. * This routine disables watchdog interrupts. This routine does not
  751. * disable critical interrupts.
  752. *
  753. * RETURNS: N/A
  754. *
  755. * SEE ALSO: sysWdtEnable()
  756. */
  758. void sysWdtDisable (void)
  759.     {
  760.     if (sysWdtRunning)
  761.         {
  762.         /* disable the WDT interrupt */
  764.         vxTcrSet (vxTcrGet() & ~ (TCR_WIE));
  766.         /* clear the pending WDT interrupt */
  768.         vxTsrSet (TSR_WIS);
  770.         /* reset the running flag */
  772.         sysWdtRunning = FALSE;
  773.         }
  774.     }
  776. /***************************************************************************
  777. *
  778. * sysWdtRateGet - get the watchdog timer rate
  779. *
  780. * This routine returns the interrupt rate of the watchdog timer.
  781. *
  782. * RETURNS: The number of watchdog interrupts per second.
  783. *
  784. * SEE ALSO: sysWdtEnable(), sysWdtRateSet()
  785. */
  787. int sysWdtRateGet (void)
  788.     {
  789.     return (sysWdtTicksPerSecond);
  790.     }
  792. /***************************************************************************
  793. *
  794. * sysWdtRateSet - set the watchdog timer rate
  795. *
  796. * This routine sets the interrupt rate of the watchdog timer. It does
  797. * not enable watchdog interrupts.
  798. *
  799. * RETURNS: OK, or ERROR if the tick rate is invalid or the timer cannot
  800. * be set.
  801. *
  802. * SEE ALSO: sysWdtEnable(), sysWdtRateGet()
  803. */
  805. STATUS sysWdtRateSet
  806.     (
  807.     int         ticksPerSecond  /* number of clock interrupts per second */
  808.     )
  809.     {
  810.     int ix;
  811.     int jx = 0;
  812.     unsigned long long wdtPeriod;
  814.     /*
  815.      * compute the WDT period.
  816.      * only 4 values are possible (cf wdtTable[]). The closest value to
  817.      * <ticksPerSecond> is being used.
  818.      */
  820.     if ((ticksPerSecond < (int) WDT_RATE_MIN) ||
  821.         (ticksPerSecond > (int) WDT_RATE_MAX))
  822.         return (ERROR);
  824.     wdtPeriod = (sysTimerClkFreq >> 1) / ticksPerSecond;
  826.     /* get the closest value to ticksPerSecond supported by the WDT */
  828.     for (ix = 0; ix < (int) NELEMENTS (wdtTable); ix++)
  829.         {
  830.         if (wdtPeriod <= wdtTable [ix].wdtPeriod)
  831.             {
  832.             if (ix != 0)
  833.                 if ( wdtPeriod <
  834.                      ((wdtTable [ix].wdtPeriod + wdtTable [ix-1].wdtPeriod)/2))
  835.                     jx = ix-1;
  836.                 else
  837.                     jx = ix;
  838.             else
  839.                 jx = ix;
  840.             break;
  841.             }
  842.         if (ix == NELEMENTS (wdtTable) - 1)
  843.             jx = ix;
  844.         }
  845.     wdtPeriod = wdtTable [jx].wdtPeriod;        /* actual period of the WDT */
  846.     wdtPeriodMask = wdtTable [jx].fpMask;       /* Mask to program TCR with */
  848.     /* save the clock speed */
  850.     sysWdtTicksPerSecond = (sysTimerClkFreq >> 1) / wdtPeriod;
  852.     return (OK);
  853.     }
  856. #ifdef  INCLUDE_TIMESTAMP
  858. /***************************************************************************
  859. *
  860. * sysTimestampConnect - connect a user routine to a timestamp timer interrupt
  861. *
  862. * This routine specifies the user interrupt routine to be called at each
  863. * timestamp timer interrupt. In this case, however, the timestamp timer
  864. * interrupt is not used since the on-chip timer is also used by the
  865. * system clock.
  866. *
  867. * RETURNS: OK, or ERROR if sysTimestampInt() interrupt handler is not
  868. * used.
  869. */
  871. STATUS sysTimestampConnect
  872.     (
  873.     FUNCPTR     routine, /* routine called at each timestamp timer interrupt */
  874.     int         arg      /* argument with which to call routine */
  875.     )
  876.     {
  877.     return (ERROR);
  878.     }
  880. /***************************************************************************
  881. *
  882. * sysTimestampEnable - initialize and enable a timestamp timer
  883. *
  884. * This routine disables the timestamp timer interrupt and initializes
  885. * the counter registers. If the timestamp timer is already running, this
  886. * routine merely resets the timer counter.
  887. *
  888. * This routine does not initialize the timer rate. The rate of the
  889. * timestamp timer should be set explicitly in the BSP by sysHwInit().
  890. *
  891. * RETURNS: OK, or ERROR if the timestamp timer cannot be enabled.
  892. */
  894. STATUS sysTimestampEnable (void)
  895.    {
  896.    if (sysTimestampRunning)
  897.       {
  898.       return (OK);
  899.       }
  901.    if (!sysClkRunning)
  902.       return (ERROR);
  904.    sysTimestampRunning = TRUE;
  906.    return (OK);
  907.    }
  909. /*******************************************************************************
  910. *
  911. * sysTimestampDisable - disable a timestamp timer
  912. *
  913. * This routine disables the timestamp timer. Interrupts are not
  914. * disabled; however, because the tick counter does not increment after
  915. * the timestamp timer is disabled, interrupts no longer are generated.
  916. *
  917. * RETURNS: OK, or ERROR if the timestamp timer cannot be disabled.
  918. */
  920. STATUS sysTimestampDisable (void)
  921.     {
  922.     if (sysTimestampRunning)
  923.         sysTimestampRunning = FALSE;
  925.     return (OK);
  926.     }
  928. /*******************************************************************************
  929. *
  930. * sysTimestampPeriod - get a timestamp timer period
  931. *
  932. * This routine specifies the period of the timestamp timer, in ticks.
  933. * The period, or terminal count, is the number of ticks to which the
  934. * timestamp timer counts before rolling over and restarting the counting
  935. * process.
  936. *
  937. * RETURNS: The period of the timestamp timer in counter ticks.
  938. */
  940. UINT32 sysTimestampPeriod (void)
  941.     {
  942.     /*
  943.      * The period of the timestamp depends on the clock rate of the
  944.      * on-chip timer (ie the Decrementer reload value).
  945.      */
  947.     return (decCountVal);
  948.     }
  950. /*******************************************************************************
  951. *
  952. * sysTimestampFreq - get a timestamp timer clock frequency
  953. *
  954. * This routine specifies the frequency of the timer clock, in ticks per
  955. * second. The rate of the timestamp timer should be set explicitly in
  956. * the BSP by sysHwInit().
  957. *
  958. * RETURNS: The timestamp timer clock frequency, in ticks per second.
  959. */
  961. UINT32 sysTimestampFreq (void)
  962.     {
  963.     return (sysTimerClkFreq);
  964.     }
  966. /*******************************************************************************
  967. *
  968. * sysTimestamp - get a timestamp timer tick count
  969. *
  970. * This routine returns the current value of the timestamp timer tick
  971. * counter. The tick count can be converted to seconds by dividing by the
  972. * return of sysTimestampFreq().
  973. *
  974. * This routine should be called with interrupts locked. If interrupts
  975. * are not locked, sysTimestampLock() should be used instead.
  976. *
  977. * RETURNS: The current timestamp timer tick count.
  978. *
  979. * SEE ALSO: sysTimestampFreq(), sysTimestampLock()
  980. */
  982. UINT32 sysTimestamp (void)
  983.     {
  984.     return (decCountVal - (UINT32) vxDecGet());
  985.     }
  987. /***************************************************************************
  988. *
  989. * sysTimestampLock - lock an interrupt and get a timestamp timer tick count
  990. *
  991. * This routine locks interrupts when stop the tick counter must be
  992. * stopped in order to read it or when two independent counters must be
  993. * read. It then returns the current value of the timestamp timer tick
  994. * counter.
  995. *
  996. * The tick count can be converted to seconds by dividing by the return
  997. * of sysTimestampFreq().
  998. *
  999. * If interrupts are already locked, sysTimestamp() should be used
  1000. * instead.
  1001. *
  1002. * RETURNS: The current timestamp timer tick count.
  1003. *
  1004. * SEE ALSO: sysTimestamp()
  1005. */
  1007. UINT32 sysTimestampLock (void)
  1008.     {
  1009.     UINT32 currentDecValue;
  1010.     int oldLevel;
  1012.     oldLevel = intLock ();                              /* LOCK INTERRUPT */
  1013.     currentDecValue = vxDecGet();
  1014.     intUnlock (oldLevel);                               /* UNLOCK INTERRUPT */
  1016.     return (decCountVal - currentDecValue);
  1017.     }
  1019. #endif  /* INCLUDE_TIMESTAMP */