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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
timer.c
资源名称：SMDK2440.rar　[点击查看]
上传用户：qiulin1960
上传日期：2013-10-16
资源大小：2844k
文件大小：17k
源码类别：

Windows CE

开发平台：

Windows_Unix

timer.c：源码内容
  1. /*++
  2. THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  3. ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  4. THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  5. PARTICULAR PURPOSE.
  6. Copyright (c) 2001. Samsung Electronics, co. ltd  All rights reserved.
  8. Module Name:  
  10. Abstract:
  12.     Platform dependent PCMCIA initialization functions
  14. rev:
  15. 2002.4.11 : RTC function work (Hyojoon KIM, zzartto@samsung.com)
  16. 2002.4.3 : first S3C2410 version (SOC)
  18. 2002.2.5 : timer related bug fixups (kwangyoon LEE, kwangyoon@samsung.com)
  19.   prevent timer round-up
  20. - CPUSetSysTimerCount()
  21. - CPUClearSysTimerIRQ()
  22. - CPUGetSysTimerCountElapsed()
  23. 2002.1.29 : bug fixups (kwangyoon LEE, kwangyoon@samsung.com)
  24. - PerfCountFreq()
  25. - PerfCountSinceTick()
  26. - CPUSetSysTimerCount()
  27. - CPUClearSysTimerIRQ()
  28. - CPUGetSysTimerCountElapsed()
  29. - CPUGetSysTimerCountMax()
  30. 2002.1.28 : CE.NET initial port (kwangyoon LEE, kwangyoon@samsung.com)
  32. Notes: 
  33. --*/
  35. #include <windows.h>
  36. #include <nkintr.h>
  38. #include <S2440.h>
  40. extern DWORD CurMSec;
  41. extern DWORD DiffMSec;
  42. DWORD dwReschedIncrement;
  43. DWORD OEMCount1ms;
  44. static volatile DWORD dwCurReschedIncr;
  45. void EnterSlowMode();
  46. void ExitSlowMode();
  48. extern void MMU_WaitForInterrupt(void);
  50. unsigned __int64 RealTimeBias = 0;  // Number of 100-nanosecond intervals since
  51.                                     // January 1, 1601. 
  52. DWORD AlarmTime = 0;     // Alarm Off at startup
  54. volatile BOOL fInterruptFlag;
  55. volatile BOOL fSlowInterruptFlag;
  56. unsigned int saveREFRESH;
  58. //------------------------------------------------------------------------------
  59. //
  60. // When this is called we will set up GPIO<1> to be a falling edge interrupt  
  61. // InitClock sets up the OS timer to int via match reg 0 on the IRQ level
  62. // an int is requested in 1ms from now.
  63. //
  64. // Interrupts are disable when this is called. check with Thomas.
  65. //
  66. //------------------------------------------------------------------------------
  67. void 
  68. InitClock(void) 
  69. {
  70.     volatile PWMreg *s2440PWM =(PWMreg *)PWM_BASE;
  71.     volatile INTreg *s2440INT = (INTreg *)INT_BASE;  
  72.     DWORD ttmp;  
  75. // Timer4 as OS tick and disable it first.
  76.     s2440INT->rINTMSK |= BIT_TIMER4; // Mask timer4 interrupt.
  77.     s2440INT->rSRCPND = BIT_TIMER4; // Clear pending bit
  78.     s2440INT->rINTPND = BIT_TIMER4;
  80. // Operating clock : PCLK=101500000 (101.5 Mhz)    
  81. // IMPORTANT : MUST CHECK S2440.H DEFINITIONS !!!!
  82. s2440PWM->rTCFG1  = 0x8080; //;;; SHL
  83. s2440PWM->rTCFG0 &= ~(0xff << 8); /* Prescaler 1's Value */
  84. s2440PWM->rTCFG0 |= (PRESCALER << 8); // prescaler value=15
  86. /* Timer4 Divider field clear */
  87. s2440PWM->rTCFG1 = 0x11111; // ;;; SHL
  88. s2440PWM->rTCFG1 &= ~(0xf << 16);
  90. #if( SYS_TIMER_DIVIDER == D2 )
  91.    s2440PWM->rTCFG1  |=  (D1_2   << 16); /* 1/2 */
  92. #elif ( SYS_TIMER_DIVIDER == D4 )
  93. s2440PWM->rTCFG1  |=  (D1_4   << 16); /* 1/4 */
  94. #elif ( SYS_TIMER_DIVIDER == D8 )
  95.    s2440PWM->rTCFG1  |=  (D1_8   << 16); /* 1/8 */
  96. #elif ( SYS_TIMER_DIVIDER == D16 )
  97.    s2440PWM->rTCFG1  |=  (D1_16   << 16); /* 1/16 */
  98. #endif
  99. s2440PWM->rTCNTB4 = RESCHED_INCREMENT; //((RESCHED_PERIOD * OEM_CLOCK_FREQ) / 1000)  
  100. ttmp = s2440PWM->rTCON & (~(0xf << 20));
  102. s2440PWM->rTCON = ttmp | (2 << 20); /* update TCVNTB4, stop */
  103. s2440PWM->rTCON = ttmp | (1 << 20); /* one-shot mode,  start */
  105.     // Number of timer counts for reschedule interval
  106.     dwReschedIncrement = RESCHED_INCREMENT;
  108. // Set OEM timer count for 1 ms
  109.     OEMCount1ms = OEM_COUNT_1MS;
  110.     
  111.     // Set OEM clock frequency
  112.     OEMClockFreq = OEM_CLOCK_FREQ;
  114.     s2440INT->rINTMSK &= ~BIT_TIMER4;
  116.     return;
  117. }
  119. //------------------------------------------------------------------------------
  120. //------------------------------------------------------------------------------
  121. DWORD 
  122. GetTimerPeriod(void) 
  123. {
  124.     return RESCHED_PERIOD;
  125. }
  127. //------------------------------------------------------------------------------
  128. //------------------------------------------------------------------------------
  129. #define FROM_BCD(n) ((((n) >> 4) * 10) + ((n) & 0xf))
  131. // NOTE: The RTC on the SMDK2440 isn't battery-backed so RTC settings will be lost
  132. // when power is removed.
  133. //
  134. BOOL 
  135. OEMGetRealTime(LPSYSTEMTIME lpst) 
  136. {
  137. #if 0
  138. volatile RTCreg *s2440RTC = (RTCreg *)RTC_BASE;
  140. do
  141. {
  142. lpst->wYear = FROM_BCD(s2440RTC->rBCDYEAR) + 2000 ;
  143. lpst->wMonth = FROM_BCD(s2440RTC->rBCDMON   & 0x1f);
  144. lpst->wDay = FROM_BCD(s2440RTC->rBCDDAY   & 0x3f);
  146. lpst->wDayOfWeek = (s2440RTC->rBCDDATE - 1);
  148. lpst->wHour = FROM_BCD(s2440RTC->rBCDHOUR  & 0x3f);
  149. lpst->wMinute = FROM_BCD(s2440RTC->rBCDMIN   & 0x7f);
  150. lpst->wSecond = FROM_BCD(s2440RTC->rBCDSEC   & 0x7f);
  151. lpst->wMilliseconds = 0;
  152. }
  153. while(!(lpst->wSecond));
  155. return(TRUE);
  156. #else
  157. volatile RTCreg *s2440RTC; 
  159. s2440RTC = (RTCreg *)RTC_BASE;
  160.     
  161. //RETAILMSG(1, (_T("OEMGetRealTimern")));
  162.     
  163. // enable RTC control
  164. // s2440RTC->rRTCCON = 0x1;
  165. lpst->wMilliseconds = 0;
  166.     
  167. lpst->wSecond    = FROM_BCD(s2440RTC->rBCDSEC & 0x7f);
  168. lpst->wMinute  = FROM_BCD(s2440RTC->rBCDMIN & 0x7f);
  169. lpst->wHour  = FROM_BCD(s2440RTC->rBCDHOUR& 0x3f);
  170. lpst->wDayOfWeek = (s2440RTC->rBCDDATE - 1);
  171. lpst->wDay  = FROM_BCD(s2440RTC->rBCDDAY & 0x3f);
  172. lpst->wMonth  = FROM_BCD(s2440RTC->rBCDMON & 0x1f);
  173. // lpst->wYear  = (2000 + s2440RTC->rBCDYEAR) ; 
  174. lpst->wYear  = FROM_BCD(s2440RTC->rBCDYEAR) + 2000 ; 
  176. if ( lpst->wSecond == 0 )
  177. {
  178. lpst->wSecond    = FROM_BCD(s2440RTC->rBCDSEC & 0x7f);
  179. lpst->wMinute  = FROM_BCD(s2440RTC->rBCDMIN & 0x7f);
  180. lpst->wHour  = FROM_BCD(s2440RTC->rBCDHOUR& 0x3f);
  181. lpst->wDayOfWeek = (s2440RTC->rBCDDATE - 1);
  182. lpst->wDay  = FROM_BCD(s2440RTC->rBCDDAY & 0x3f);
  183. lpst->wMonth  = FROM_BCD(s2440RTC->rBCDMON & 0x1f);
  184. lpst->wYear = (2000 + s2440RTC->rBCDYEAR) ; 
  185. }
  186. // disable RTC control
  187. // s2440RTC->rRTCCON = 0;
  189. return TRUE;
  190. #endif
  192. }
  194. //------------------------------------------------------------------------------
  195. //------------------------------------------------------------------------------
  196. #define TO_BCD(n) ((((n) / 10) << 4) | ((n) % 10))
  198. // NOTE: The RTC on the SMDK2440 isn't battery-backed so RTC settings will be lost
  199. // when power is removed.
  200. //
  201. BOOL
  202. OEMSetRealTime(LPSYSTEMTIME lpst) 
  203. {
  204. #if 0
  205. volatile RTCreg *s2440RTC = (RTCreg *)RTC_BASE;
  206.  
  207. // Enable RTC control.
  208. //
  209. s2440RTC->rRTCCON |= 1;
  211. s2440RTC->rBCDSEC  = (unsigned char)TO_BCD(lpst->wSecond );
  212. s2440RTC->rBCDMIN  = (unsigned char)TO_BCD(lpst->wMinute );
  213. s2440RTC->rBCDHOUR = (unsigned char)TO_BCD(lpst->wHour   );
  215. s2440RTC->rBCDDATE = (unsigned char)(lpst->wDayOfWeek + 1);
  217. s2440RTC->rBCDDAY  = (unsigned char)TO_BCD(lpst->wDay    );
  218. s2440RTC->rBCDMON  = (unsigned char)TO_BCD(lpst->wMonth  );
  219. s2440RTC->rBCDYEAR = (unsigned char)TO_BCD((lpst->wYear % 100));
  221. RETAILMSG(1,(TEXT("OEMSetRealTime: Year: %x, Month: %x, Day: %x, Hour: %x, Minute: %x, second: %x rcnr=%Xhn"), 
  222.     s2440RTC->rBCDYEAR, s2440RTC->rBCDMON,s2440RTC->rBCDDAY, s2440RTC->rBCDHOUR, s2440RTC->rBCDMIN,s2440RTC->rBCDSEC,s2440RTC->rRTCCON));
  224. // Disable RTC control.
  225. //
  226. s2440RTC->rRTCCON &= ~1;
  228. return(TRUE);
  229. #else
  230. volatile RTCreg *s2440RTC = (RTCreg *)RTC_BASE;
  231.   static int firsttime = 0;
  233. // enable RTC control
  234. s2440RTC->rRTCCON =  0x1;
  236. s2440RTC->rBCDSEC  = (unsigned char)TO_BCD(lpst->wSecond );
  237. s2440RTC->rBCDMIN  = (unsigned char)TO_BCD(lpst->wMinute );
  238. s2440RTC->rBCDHOUR = (unsigned char)TO_BCD(lpst->wHour   );
  240. s2440RTC->rBCDDATE = (unsigned char)(lpst->wDayOfWeek + 1);
  242. if ( firsttime == 0 )
  243. {
  244. lpst->wYear = 2003; lpst->wMonth = 1; lpst->wDay = 1;
  245. firsttime = 1;
  246. }
  248. s2440RTC->rBCDDAY  = (unsigned char)TO_BCD(lpst->wDay    );
  249. s2440RTC->rBCDMON  = (unsigned char)TO_BCD(lpst->wMonth  );
  250. s2440RTC->rBCDYEAR = (unsigned char)TO_BCD((lpst->wYear % 100));
  252. RETAILMSG(1,(TEXT("OEMSetRealTime: Year: %u, Month: %u, Day: %u, Hour: %u, Minute: %u, second: %u rcnr=%Xhn"), lpst->wYear, lpst->wMonth,lpst->wDay, lpst->wHour, lpst->wMinute,lpst->wSecond,s2440RTC->rRTCCON));
  253. RETAILMSG(1,(TEXT("OEMSetRealTime(register): Year: %x, Month: %x, Day: %x, Hour: %x, Minute: %x, second: %x rcnr=%Xhn"), 
  254.     s2440RTC->rBCDYEAR, s2440RTC->rBCDMON,s2440RTC->rBCDDAY, s2440RTC->rBCDHOUR, s2440RTC->rBCDMIN,s2440RTC->rBCDSEC,s2440RTC->rRTCCON));
  256. // disable RTC control
  257. s2440RTC->rRTCCON = 0; //&= ~0x1;
  259. // Just certify heart bit
  260. // timer_cnt = 0;
  262. return TRUE;
  263. #endif
  264. }
  266. //------------------------------------------------------------------------------
  267. //------------------------------------------------------------------------------
  268. BOOL 
  269. OEMSetAlarmTime(LPSYSTEMTIME lpst) 
  270. {
  271. volatile INTreg *s2440INT = (INTreg *)INT_BASE; // for alarm 030818
  272. volatile RTCreg *s2440RTC = (RTCreg *)RTC_BASE;
  274. RETAILMSG(1,(TEXT("OEMSetAlarmTime: Year: %u, Month: %u, Day: %u, Hour: %u, Minute: %u, second: %u rcnr=%Xhn"), 
  275. lpst->wYear, lpst->wMonth,lpst->wDay, lpst->wHour, lpst->wMinute,lpst->wSecond,s2440RTC->rRTCCON));
  277. if ( !lpst || // for alarm 030818
  278. (lpst->wSecond > 59)   ||  // 0 - 59
  279. (lpst->wMinute > 59)   ||  // 0 - 59
  280. (lpst->wHour > 23)     ||  // 0 - 23
  281. (lpst->wDayOfWeek > 6) ||  // 0 - 6, Sun:0, Mon:1, ...
  282. (lpst->wDay > 31)      ||  // 0 - 31
  283. (lpst->wMonth > 12)    ||  // 1 - 12, Jan:1, Feb:2, ...
  284. (lpst->wMonth == 0)    ||
  285. (lpst->wYear < 2000)   ||  // We have a 100 year calander (2 BDC digits) with 
  286. (lpst->wYear > 2099)       // a leap year generator hard-wired to year 2000.
  287. )
  288. return FALSE;    
  290. s2440RTC->rRTCCON = (1 << 0); /* RTC Control Enable  */
  291.     
  292. s2440RTC->rALMSEC  = (unsigned char)TO_BCD(lpst->wSecond );
  293. s2440RTC->rALMMIN  = (unsigned char)TO_BCD(lpst->wMinute );
  294. s2440RTC->rALMHOUR = (unsigned char)TO_BCD(lpst->wHour   );
  296. s2440RTC->rALMDAY  = (unsigned char)TO_BCD(lpst->wDay    );
  297. s2440RTC->rALMMON  = (unsigned char)TO_BCD(lpst->wMonth  );
  298. s2440RTC->rALMYEAR = (unsigned char)TO_BCD((lpst->wYear % 100));
  300. s2440RTC->rRTCALM = 0x7f; // for alarm 030818
  302. s2440RTC->rRTCCON = (0 << 0); /* RTC Control Disable */
  304. // for alarm 030818
  305. s2440INT->rSRCPND  =  BIT_RTC;     /* RTC Alarm Interrupt Clear */
  306. s2440INT->rINTPND  =  BIT_RTC;
  307. s2440INT->rINTMSK &= ~BIT_RTC;     /* RTC Alarm Enable    */
  308.  
  309. return TRUE;
  310. }
  312. //------------------------------------------------------------------------------
  313. //------------------------------------------------------------------------------
  314. DWORD
  315. PerfCountFreq()
  316. {
  317.     return (OEMClockFreq);
  318. }
  322. //------------------------------------------------------------------------------
  323. //------------------------------------------------------------------------------
  324. DWORD
  325. PerfCountSinceTick()
  326. {
  327.     volatile PWMreg *s2440PWM;
  328.     DWORD dwCount;
  330.     s2440PWM = (PWMreg *)PWM_BASE;
  332.     dwCount= ((DWORD)s2440PWM->rTCNTO4);
  333.     
  334.     // Note: if dwCount is negative, the counter went past the match point.  The math
  335. // still works since it accounts for the dwReschedIncr time plus the time past
  336. // the match.
  337.     return dwCurReschedIncr - dwCount;
  338. }
  341. //------------------------------------------------------------------------------
  342. //------------------------------------------------------------------------------
  343. void
  344. CPUSetSysTimerCount(
  345.     DWORD dwCountdownMSec
  346.     )
  347. {
  348. DWORD dwMatch, ttmp;
  349. volatile PWMreg *s2440PWM;
  351.     s2440PWM = (PWMreg *)PWM_BASE;
  353.     dwCurReschedIncr = dwCountdownMSec * OEMCount1ms;
  354.     dwMatch = dwCurReschedIncr;
  356. s2440PWM->rTCNTB4 = dwMatch;
  358. ttmp = s2440PWM->rTCON & (~(0xf << 20));
  360. s2440PWM->rTCON = ttmp | (2 << 20); /* update TCVNTB4, stop */
  361. s2440PWM->rTCON = ttmp | (1 << 20); /* one-shot mode,  start */
  362. }
  365. //------------------------------------------------------------------------------
  366. //------------------------------------------------------------------------------
  367. BOOL
  368. CPUClearSysTimerIRQ(
  369.     void
  370.     )
  371. {
  372. volatile INTreg *s2440INT; 
  373. BOOL fPending;
  374. DWORD intstatus;
  375.     
  376. s2440INT = (INTreg *)INT_BASE;
  378. intstatus = s2440INT->rSRCPND;
  380. if ((intstatus & (BIT_TIMER4)) != 0) {
  381. s2440INT->rSRCPND = BIT_TIMER4;        
  382. s2440INT->rINTPND = BIT_TIMER4;
  383. fPending = TRUE;
  384. } else {
  385. fPending = FALSE;
  386. }
  388.     return fPending;
  389. }
  392. //------------------------------------------------------------------------------
  393. //------------------------------------------------------------------------------
  394. DWORD
  395. CPUGetSysTimerCountElapsed(
  396.     DWORD dwTimerCountdownMSec,
  397.     volatile DWORD *pCurMSec,
  398.     DWORD *pPartialCurMSec,
  399.     volatile ULARGE_INTEGER *pCurTicks
  400.     )
  401. {
  402.     volatile PWMreg *s2440PWM;
  403. DWORD dwTick, dwCount;
  405.     s2440PWM = (PWMreg *)PWM_BASE;
  406.     dwTick = dwTimerCountdownMSec * OEMCount1ms;
  408.     // If timer IRQ pending, a full resched period elapsed
  409.     if (CPUClearSysTimerIRQ( )) {
  410.         *pCurMSec += dwTimerCountdownMSec;
  411.         pCurTicks->QuadPart += dwTick;
  412.         return dwTimerCountdownMSec;
  413.     }
  415.     // No timer IRQ pending, calculate how much time has elapsed
  416. dwCount= ((DWORD)s2440PWM->rTCNTO4);
  418.     if (dwCount > dwTick) {
  419.         // This is an error case.  Recover gracefully.
  420.         dwCount = dwTick;
  421.     } else {
  422.         dwCount = dwTick - dwCount;
  423.     }
  425.     pCurTicks->QuadPart += dwCount;
  427.     dwCount += *pPartialCurMSec;
  428.     *pPartialCurMSec = dwCount % OEMCount1ms;
  429.     *pCurMSec += (dwCount /= OEMCount1ms);
  431.     return dwCount;
  432. }
  434. //------------------------------------------------------------------------------
  435. //------------------------------------------------------------------------------
  436. extern void CPUEnterIdleMode(void);
  438. extern void OEMWriteDebugLED(WORD wIndex, DWORD dwPattern);
  440. void
  441. CPUEnterIdle()
  442. {
  443. static volatile CLKPWRreg * s2440CLKPW = (CLKPWRreg *)CLKPWR_BASE;
  444. static volatile IOPreg    * s2440IOP   = (IOPreg    *)IOP_BASE;
  446. fInterruptFlag = FALSE;
  447. INTERRUPTS_ON();
  449. s2440IOP->rGPFDAT &= ~(1 << 5);
  450. s2440CLKPW->rCLKCON |=  (1 << 2); /* Enter IDLE Mode                              */
  451. while (!fInterruptFlag) {} /* Wait until S3C2440X enters IDLE mode         */
  452. s2440CLKPW->rCLKCON &= ~(1 << 2); /* turn-off IDLE bit.                           */
  453. /* Any interrupt will wake up from IDLE mode    */
  454. s2440IOP->rGPFDAT |= (1 << 5);
  455. }
  458. // Maximum idle is fixed a 1 ms because the PIT has to count down to 0 before reloading
  459. // the new countdown value.
  460. #define IDLE_MAX_MS  100
  461. //------------------------------------------------------------------------------
  462. //------------------------------------------------------------------------------
  463. DWORD
  464. CPUGetSysTimerCountMax(
  465.     DWORD dwIdleMSecRequested
  466.     )
  467. {
  468.     if (dwIdleMSecRequested > IDLE_MAX_MS) {
  469.         return IDLE_MAX_MS;
  470.     }
  471.     return dwIdleMSecRequested;
  472. }
  474. void EnterSlowMode()
  475. {
  476. static volatile CLKPWRreg * s2440CLKPW  = (CLKPWRreg *)CLKPWR_BASE;
  477. static volatile IOPreg    * s2440IOP    = (IOPreg    *)IOP_BASE;
  478. static volatile MEMreg   * s2440MemReg = (MEMreg      *)MEMCTRL_BASE;
  480. //RETAILMSG(1,(TEXT("EnterSlowMode rn")));
  481. fSlowInterruptFlag = TRUE;
  482. s2440IOP->rGPFDAT &= ~(1 << 7);
  484. //FCLK=FIN/1, SLOW mode, MPLL=off, UPLL=off
  485. s2440CLKPW->rCLKSLOW |= (1<<4)|(1<<5)|(1<<7);
  486. saveREFRESH = s2440MemReg->rREFRESH;
  487. s2440MemReg->rREFRESH=(1<<23)|(unsigned int)(2048+1-12*15.6);
  488. //Trp=2clk, Trc=4clk
  489. }
  491. void ExitSlowMode()
  492. {
  493. static volatile CLKPWRreg * s2440CLKPW  = (CLKPWRreg *)CLKPWR_BASE;
  494. static volatile IOPreg    * s2440IOP    = (IOPreg    *)IOP_BASE;
  495. static volatile MEMreg   * s2440MemReg = (MEMreg      *)MEMCTRL_BASE;
  496. // int i;
  498. //RETAILMSG(1,(TEXT("ExitSlowMode rn")));
  499. fSlowInterruptFlag = FALSE;
  501. s2440CLKPW->rCLKSLOW = 0|(1<<4)|(0<<5);// PLL on, MPLL=on
  502. //for ( i = 0; i < 2048; i++); //S/W MPLL lock-time
  503. s2440CLKPW->rCLKSLOW = 0|(0<<4)|(0<<5);// NORMAL mode, PLL=on, MPLL=on
  504. s2440MemReg->rREFRESH = saveREFRESH;
  506. s2440IOP->rGPFDAT |= (1 << 7);
  507. }
  510. void SetSysTimerInterval(DWORD dwTicks)
  511. {
  512.     volatile PWMreg *s2440PWM = (PWMreg *)PWM_BASE;
  513.     volatile INTreg *s2440INT = (INTreg *)INT_BASE;  
  514.     DWORD dwTimerTemp;  
  516. // Mask and clear timer interrupt.
  517. //
  518.     s2440INT->rINTMSK |= BIT_TIMER4;
  519.     s2440INT->rSRCPND  = BIT_TIMER4;
  520.     s2440INT->rINTPND  = BIT_TIMER4;
  522. // Change number of timer ticks in the period.
  523. //
  524. s2440PWM->rTCNTB4 = dwTicks;
  525. dwTimerTemp = s2440PWM->rTCON & (~(0xf << 20));
  527. s2440PWM->rTCON = dwTimerTemp | (2 << 20); // Update TCVNTB4 and stop.
  528. s2440PWM->rTCON = dwTimerTemp | (1 << 20); // One-shot mode and start.
  530. // Unmask the timer interrupt.
  531. //
  532.     s2440INT->rINTMSK &= ~BIT_TIMER4;
  533. }