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

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

Windows CE

开发平台：

Windows_Unix

cfw.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.
  7. --*/
  9. #include "windows.h"
  10. #include "nkintr.h"
  11. #include "oalintr.h"
  12. #include "shx.h"
  13. #include "p2.h"
  14. #include "p2debug.h"
  15. #include "tchaud.h"
  16. #include "drv_glob.h"
  17. #include <memory.h>
  18. #ifdef MODULE_CERTIFY
  19. #include "key1024.c"    // OEMLoadInit/OEMLoadModule implementation and the public key used for module signature verification.
  20. #endif
  21. //#include "timer.h"
  22. #include <S2440.h>
  23. #include <pehdr.h>
  24. #include <romldr.h>
  27. extern const unsigned short ScreenBitmap[];
  29. /*
  30.     @doc    EXTERNAL KERNEL HAL
  32.     @module cfwp2.c - P2 HW Support | 
  33.         OEM support Functions for the Windows CE P2 Platform.
  34.     
  35.     @xref <f OEMInit> <f OEMInterruptEnable> <f OEMInterruptDisable> 
  36.           <f OEMInterruptDone> <l HAL Overview.Windows CE Kernel OEM Interface>
  37.           
  38.     @topic Windows CE Kernel OEM Interface |
  39.           This defines the HAL layer - OEM and platform dependent pieces of
  40.           code which we expect the OEM to deliver to us. There are three pieces
  41.           of OEM deliverable code  - the bootstrap loader & monitor (for 
  42.           debugging), the HAL portions which are interfaces between the kernel
  43.           and the firmware, and the driver interface. This topic covers just 
  44.           the HAL portion.
  46.           The philosophy is to keep the HAL layer as simple as possible.  The 
  47.           HAL should not be confused with the machine or CPU independence. HAL 
  48.           is specific for a particular CPU and platform. It includes interfaces 
  49.           for the following devices:<nl>
  50.           Real Time Clock<nl>
  51.           Interval Timer (used for the scheduler operation) <nl>
  52.           Interrupt handlers and support <nl>
  54.           Note that it does not include abstractions for devices like the DMA 
  55.           controller etc. since the kernel does not use one. Also note that the
  56.           list could change for different CPU's and platforms - for instance, 
  57.           some chips might include a lot of peripheral devices (like the 
  58.           interval timer) on the CPU chip itself, removing the need for a 
  59.           separate interface for them.
  61.           The interfaces for the real time clock and interval timer are still 
  62.           being developed. But they should in general be extremely simple and
  63.           straightforward. For details on the interrupt support model in the 
  64.           kernel look at <l Interrupt Support Overview.Kernel Interrupt Support>
  66.     @xref <l Interrupt Support Overview.Kernel Interrupt Support>
  67.           <f OEMInit> <f OEMInterruptEnable> <f OEMInterruptDisable> 
  68.           <f OEMInterruptDone> <f HookInterrupt>
  69.              
  70.  */
  73. unsigned long OEMClockFreq; // OEM clock frequency is used only in OAL
  75. //
  76. // Kernel global variables used by GetIdleTime( ) to determine CPU utilization
  77. //
  78. extern DWORD idleconv;  // translation constant in 1 ms units
  79. extern DWORD curridlehigh, curridlelow; // 64-bit idle time in ms
  81. extern int P2ISR();
  82. extern void InitClock();
  83. extern void HalCpuInit();
  84. extern void HalTimerInit();
  85. extern void HalSleep(DWORD);
  87. extern void TIMERINIT();
  88. extern void InitDebugEther(void);
  90. static void InitDisplay(void);
  91. static void OEMInitInterrupts(void);
  92. static void InitSDMMC(void);
  94. typedef volatile WORD *PVWORD;    /* pointer to a volatile word */
  95. typedef volatile DWORD *PVDWORD;    /* pointer to a volatile dword */
  98. #define REG(base, id)   (*(PVWORD)((base)+(id)))
  99. #define REG32(base, id)   (*(PVDWORD)((base)+(id)))
  101. #define SDIO_FOR_100BD 0
  102. /*
  103. #if (CE_MAJOR_VER == 0x0003)
  104. //Cedar
  105. // The kernel exports...
  106. #ifdef AddrCurMSec
  107. // Some kernels export a pointer to the CurMSec variable.
  108. static volatile DWORD * pCurMSec  = (volatile DWORD *) AddrCurMSec;
  109. static volatile DWORD * pDiffMSec = (volatile DWORD *) AddrDiffMSec;
  110. #else
  111. extern volatile DWORD CurMSec;
  112. extern volatile DWORD DiffMSec;
  113. static volatile DWORD * pCurMSec = &CurMSec;
  114. static volatile DWORD * pDiffMSec = &DiffMSec;
  115. #endif
  117. extern DWORD dwSleepMin;
  118. extern DWORD dwPartialDiffMSec;
  119. extern DWORD ticksleft;
  121. #else
  122. // dougfir or later
  123. //
  124. #ifdef AddrCurMSec
  125. // Some kernels export a pointer to the CurMSec variable.
  126. static volatile DWORD * pCurMSec  = (volatile DWORD *) AddrCurMSec;
  127. #else
  128. extern volatile DWORD CurMSec;
  129. static volatile DWORD * pCurMSec = &CurMSec;
  130. #endif
  132. extern DWORD dwReschedTime;
  133. #endif
  134. */
  136. // dougfir or later
  137. //
  138. #ifdef AddrCurMSec
  139. // Some kernels export a pointer to the CurMSec variable.
  140. static volatile DWORD * pCurMSec  = (volatile DWORD *) AddrCurMSec;
  141. #else
  142. extern volatile DWORD CurMSec;
  143. static volatile DWORD * pCurMSec = &CurMSec;
  144. #endif
  146. extern DWORD dwReschedTime;
  149. extern BOOL fIntrTime;
  150. extern BOOL bProfileTimerRunning;
  152. volatile ULARGE_INTEGER CurTicks = { 0, 0 };
  153. volatile ULARGE_INTEGER * pCurTicks = &CurTicks;
  155. extern DWORD dwReschedIncrement;
  156. extern DWORD OEMCount1ms;
  157. //extern void Camera_Initialize(void);
  160. #define NOT_FIXEDUP    (DWORD*)-1
  161. DWORD *pdwXIPLoc = NOT_FIXEDUP;
  162. extern  ROMChain_t         *OEMRomChain;
  164. /*
  165.     @func   void | InitRomChain | Collects chain information for all image regions for the kernel.
  166.     @rdesc  N/A.
  167.     @comm    
  168.     @xref   
  169. */
  170. /*
  171. void InitRomChain(void)
  172. {
  173. static ROMChain_t s_pNextRom[MAX_ROM] = {0};
  174. DWORD dwRomCount = 0;
  175.     DWORD       dwChainCount = 0;
  176.     DWORD *pdwCurXIP;
  177.     DWORD       dwNumXIPs;
  178.     PXIPCHAIN_ENTRY pChainEntry = NULL;
  180.     if(pdwXIPLoc == NOT_FIXEDUP)
  181. {
  182.         return;  // no chain or not fixed up properly
  183.     }
  185.     // set the top bit to mark it as a virtual address
  186.     pdwCurXIP = (DWORD*)(((DWORD)pdwXIPLoc) | 0x80000000);
  188.     // first DWORD is number of XIPs
  189.     dwNumXIPs = (*pdwCurXIP);
  191.     if(dwNumXIPs > MAX_ROM)
  192. {
  193.       lpWriteDebugStringFunc(TEXT("ERROR: Number of XIPs exceeds MAXn"));
  194.       return;
  195.     }
  197.     pChainEntry = (PXIPCHAIN_ENTRY)(pdwCurXIP + 1);
  199.     while(dwChainCount < dwNumXIPs)
  200.     {
  201.         if ((pChainEntry->usFlags & ROMXIP_OK_TO_LOAD) &&  // flags indicates valid XIP
  202.             *(LPDWORD)(((DWORD)(pChainEntry->pvAddr)) + ROM_SIGNATURE_OFFSET) == ROM_SIGNATURE)
  203.         {
  204.             s_pNextRom[dwRomCount].pTOC = *(ROMHDR **)(((DWORD)(pChainEntry->pvAddr)) + ROM_SIGNATURE_OFFSET + 4);
  205.             s_pNextRom[dwRomCount].pNext = NULL;
  207.             if (dwRomCount != 0)
  208.             {
  209.                 s_pNextRom[dwRomCount-1].pNext = &s_pNextRom[dwRomCount];
  210.             }
  211.             else
  212.             {
  213.                 OEMRomChain = s_pNextRom;
  214.             }
  215.             dwRomCount++;
  216.         }
  217.         else
  218.         {
  219.             lpWriteDebugStringFunc( _T("Invalid XIP foundn") );
  220.         }
  222.         ++pChainEntry;
  223. dwChainCount++;
  224. }
  225. }
  226. */
  228. #define FROM_BCD(n) ((((n) >> 4) * 10) + ((n) & 0xf))
  231. //------------------------------------------------------------------------------
  232. //
  233. //  @func   void | OEMInit | Initialize Hardware Interfaces
  234. //  @rdesc  none
  235. //  @comm   OEMInit is called by the kernel after it has performed minimal
  236. //          initialization. Interrupts are disabled and the kernel is not
  237. //          ready to handle exceptions. The only kernel service available
  238. //          to this function is <f HookInterrupt>. This should be used to 
  239. //          install ISR's for all the hardware interrupts to be handled by
  240. //          the firmware. Note that ISR's must be installed for any interrupt
  241. //          that is to be routed to a device driver - otherwise the 
  242. //          <f InterruptInitialize> call from the driver will fail.
  243. //  @xref   <l Overview.Windows CE Kernel OEM Interface> <f HookInterrupt>
  244. //          <f InterruptInitialize>
  245. //            
  246. //------------------------------------------------------------------------------
  247. void OEMInit()  
  248. {
  249. volatile IOPreg *s2440IOP = (IOPreg *)IOP_BASE;
  251. // Instead of calling OEMWriteDebugString directly, call through exported
  252. // function pointer.  This will allow these messages to be seen if debug
  253. // message output is redirected to Ethernet or the parallel port.  Otherwise,
  254. // lpWriteDebugStringFunc == OEMWriteDebugString.
  255. lpWriteDebugStringFunc(TEXT("nWindows CE Firmware Initrn"));
  258. #ifdef MODULE_CERTIFY
  259. //
  260. // Set the module signature verification hooks
  261. //
  262. pOEMLoadInit   = OEMLoadInit;
  263. pOEMLoadModule = OEMLoadModule;
  264. //
  265. // Init the signature verification public key
  266. //
  267. InitPubKey(g_bSignPublicKeyBlob,sizeof(g_bSignPublicKeyBlob));
  268. #endif
  270.     //
  271.     // Set up translation constant for GetIdleTime() (1 ms units).
  272.     // Note: Since curridlehigh, curridlelow is counting in ms, and GetIdleTime()
  273.     // reports in ms, the conversion ratio is one.  If curridlehigh, curridlelow
  274.     // were using other units (like ticks), then the conversion would be calculated
  275.     // from the clock frequency.
  276.     //
  277.     idleconv = 1;
  279. // Initialize interrupts.
  280. //
  281.     lpWriteDebugStringFunc(TEXT("INFO: Initializing system interrupts...rn"));
  282. OEMInitInterrupts();
  284. // Initialize the system clock(s).
  285. //
  286.     lpWriteDebugStringFunc(TEXT("INFO: Initializing system clock(s)...rn"));
  287.     InitClock();
  289.     // Initialize driver globals area.
  290. //
  291.     lpWriteDebugStringFunc(TEXT("INFO: Initializing driver globals area...rn"));
  292.     memset((PVOID)DRIVER_GLOBALS_ZEROINIT_START, 0, DRIVER_GLOBALS_ZEROINIT_SIZE);
  293.     
  294.     // Initialize S2440X01 LCD controller
  295. InitDisplay();
  297.     // Initialize debug Ethernet (KITL) connection.
  298.     //
  299. // InitDebugEther();
  300.  
  301. // Initialize GPIO /// ;;; SHL
  302. s2440IOP->rPAD9 = (1<<12) | (0<<11);
  303. //s2440IOP->rGPJCON = 0x016aaaa;
  304. //s2440IOP->rGPJUP  = ~((0<<12) | (1<<11));
  306. s2440IOP->rGPHCON = (s2440IOP->rGPHCON & ~(0xf<<18)) | (1<<20) | (1<<18); // CLKOUT1, CLKOUT0
  308. s2440IOP->rDSC0 = 0x3ff;
  309. s2440IOP->rDSC1 = 0x3fffffff;
  311. // camera
  312. //Camera_Initialize();
  313. //s2440IOP->rGPJCON = 0x2aaaaaa;
  314. //s2440IOP->rGPJUP  = 0x1fff;
  316. InitSDMMC();
  318. // Initialize the ROM chain (multi-region).
  319. //
  320. // InitRomChain();
  321. lpWriteDebugStringFunc(TEXT("OEMInit Done...rn"));
  322. }
  325. //------------------------------------------------------------------------------
  326. //  
  327. //  @func   BOOL | OEMInterruptEnable | Enable a hardware interrupt
  328. //  @rdesc  Returns TRUE if valid interrupt ID or FALSE if invalid ID.
  329. //  @comm   This function is called by the Kernel when a device driver
  330. //          calls <f InterruptInitialize>. The system is not preemptible when this
  331. //          function is called.
  332. //  @xref   <l Overview.Windows CE Kernel OEM Interface> <f InterruptInitialize>
  333. //  
  334. //------------------------------------------------------------------------------
  335. BOOL 
  336. OEMInterruptEnable(DWORD  idInt, // @parm Interrupt ID to be enabled. See <l Interrupt ID's.Interrupt ID's>  for a list of possble values.
  337.    LPVOID pvData, // @parm ptr to data passed in in the <f InterruptInitialize> call
  338.            DWORD  cbData) // @parm Size of data pointed to be <p pvData>
  339. {
  340. volatile INTreg *s2440INT = (INTreg *)INT_BASE;
  341. volatile IOPreg *s2440IOP = (IOPreg *)IOP_BASE;
  342. volatile MMCreg *s2440SDIO = (MMCreg *)MMC_BACE;
  343. BOOL bRet = TRUE;
  345. INTERRUPTS_OFF();
  347. switch (idInt) 
  348. {
  349. case SYSINTR_VMINI: // Vmini.
  350. //return (TRUE);
  351. break;
  353. case SYSINTR_BREAK: // There is no halt button on P2.
  354. //return(FALSE);
  355.         break;
  358.     case SYSINTR_DMA0:
  359.         s2440INT->rINTMSK &= ~BIT_DMA0; // SDIO DMA interrupt
  360. //RETAILMSG(1,(TEXT("::: SYSINTR_DMA0    OEMInterruptDisablern")));
  361.         break;
  363. case SYSINTR_SDMMC:
  364. s2440INT->rINTMSK &= ~BIT_MMC;
  365. //RETAILMSG(1,(TEXT("::: SYSINTR_SDMMC    OEMInterruptDisablern")));
  366. break;        
  368. case SYSINTR_SDMMC_SDIO_INTERRUPT:
  369. s2440INT->rINTMSK &= ~BIT_MMC;
  370. //RETAILMSG(1,(TEXT("::: SYSINTR_SDMMC_SDIO_INTERRUPT    OEMInterruptEnablern")));
  371. break;
  373. case SYSINTR_SDMMC_CARD_DETECT:
  374. #if SDIO_FOR_100BD // for b'd revision 1.00
  375. s2440IOP->rEINTPEND  = (1 << 18);
  376. s2440IOP->rEINTMASK &= ~(1 << 18);
  377. //s2440INT->rSRCPND = BIT_EINT8_23;
  378. // if (s2440INT->rINTPND & BIT_EINT8_23) 
  380. // s2440INT->rINTMSK  &= ~BIT_EINT8_23;
  381. //RETAILMSG(1,(TEXT("::: SYSINTR_SDMMC_CARD_DETECT    OEMInterruptEnablern")));
  382. #else // for b'd revision 0.17
  383. s2440IOP->rEINTPEND  = (1 << 16);
  384. s2440IOP->rEINTMASK &= ~(1 << 16);  
  385. #endif
  386. s2440INT->rSRCPND = BIT_EINT8_23;
  387. s2440INT->rINTPND = BIT_EINT8_23;
  388. s2440INT->rINTMSK &= ~BIT_EINT8_23;
  390. break;     
  392.     case SYSINTR_TOUCH:
  393. //RETAILMSG(0,(TEXT("OEMInterruptEnable:TOUCHnrn")));
  394.         break;
  396.     case SYSINTR_TOUCH_CHANGED:
  397. //RETAILMSG(0,(TEXT("OEMInterruptEnable:TOUCH CHANGEDrnrn")));
  398. s2440INT->rINTMSK &= ~BIT_ADC;
  399. s2440INT->rINTSUBMSK &= ~INTSUB_TC;
  400.         break;
  402. case SYSINTR_KEYBOARD: // Keyboard on EINT1.
  403. /*
  404. s2440INT->rSRCPND  = BIT_EINT1;
  405. // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  406. if (s2440INT->rINTPND & BIT_EINT1) s2440INT->rINTPND = BIT_EINT1;
  407. */
  408. s2440INT->rINTMSK &= ~BIT_EINT1;
  409. break;
  411. case SYSINTR_SERIAL: // Serial port.
  412. s2440INT->rSUBSRCPND  = (INTSUB_RXD0 | INTSUB_TXD0 | INTSUB_ERR0);
  413. s2440INT->rINTSUBMSK &= ~INTSUB_RXD0;
  414. s2440INT->rINTSUBMSK &= ~INTSUB_TXD0;
  415. s2440INT->rINTSUBMSK &= ~INTSUB_ERR0;
  416. s2440INT->rSRCPND     = BIT_UART0;
  417. // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  418. if (s2440INT->rINTPND & BIT_UART0) s2440INT->rINTPND = BIT_UART0;
  419. s2440INT->rINTMSK    &= ~BIT_UART0;
  420. break;
  422. case SYSINTR_IR: // IrDA.
  423. s2440INT->rSUBSRCPND  = (INTSUB_RXD2 | INTSUB_TXD2 | INTSUB_ERR2);
  424. s2440INT->rINTSUBMSK &= ~INTSUB_RXD2;
  425. s2440INT->rINTSUBMSK &= ~INTSUB_TXD2;
  426. s2440INT->rINTSUBMSK &= ~INTSUB_ERR2;
  427. s2440INT->rSRCPND     = BIT_UART2;
  428. // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  429. if (s2440INT->rINTPND & BIT_UART2) s2440INT->rINTPND = BIT_UART2;
  430. s2440INT->rINTMSK    &= ~BIT_UART2;
  431. break;
  433. // update audio old ;;; SHL
  434. // case SYSINTR_AUDIO: // Audio controller (the controller uses both DMA1 and DMA2 interrupts).
  435. // // DMA1 (input).
  436. // //
  437. // s2440INT->rSRCPND  = BIT_DMA1;
  438. // // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  439. // if (s2440INT->rINTPND & BIT_DMA1) s2440INT->rINTPND = BIT_DMA1;
  440. // s2440INT->rINTMSK &= ~BIT_DMA1;
  441. // // DMA2 (output).
  442. // //
  443. // s2440INT->rSRCPND  = BIT_DMA2;
  444. // // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  445. // if (s2440INT->rINTPND & BIT_DMA2) s2440INT->rINTPND = BIT_DMA2;
  446. // s2440INT->rINTMSK &= ~BIT_DMA2;
  447. // break;
  449. // update audio bug.
  450. case SYSINTR_AUDIO: // Audio controller (the controller uses both DMA1 and DMA2 interrupts).
  451. // DMA1 (input).
  452. //
  453. s2440INT->rINTMSK &= ~BIT_DMA1;
  454. // DMA2 (output).
  455. s2440INT->rINTMSK &= ~BIT_DMA2;
  456. break;
  458. case SYSINTR_ADC:
  459. //return(FALSE);
  460. break;
  462. case SYSINTR_PCMCIA_LEVEL: // PCMCIA data on EINT8.
  463. s2440INT->rINTMSK  &= ~BIT_EINT8_23;
  464. //s2440INT->rSRCPND  = BIT_EINT8_23;
  465. //s2440INT->rINTPND  = BIT_EINT8_23;
  466. s2440IOP->rEINTMASK &= ~0x100;
  467. //s2440IOP->rEINTPEND  = 0x100;
  468. //RETAILMSG(1,(TEXT("::: SYSINTR_PCMCIA_LEVEL    OEMInterruptEnablern")));
  469. break;
  471. case SYSINTR_PCMCIA_EDGE:
  472. //return(FALSE);
  473. break;
  475. case SYSINTR_PCMCIA_STATE: // PCMCIA insertion interrupt.
  476. s2440INT->rSRCPND  = BIT_EINT3;  // to clear the previous pending states
  477. // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  478. if (s2440INT->rINTPND & BIT_EINT3) s2440INT->rINTPND = BIT_EINT3;
  479. s2440INT->rINTMSK &= ~BIT_EINT3;
  480. //RETAILMSG(1,(TEXT("::: SYSINTR_PCMCIA_STATE    OEMInterruptEnablern")));
  481. break;
  483. case SYSINTR_TIMING:
  484. //return(FALSE);
  485. break;
  487.     case SYSINTR_ETHER: // Ethernet on EINT9.
  488. s2440IOP->rEINTPEND   = 0x200;
  489. s2440IOP->rEINTMASK  &= ~0x200;
  490. //s2440INT->rSRCPND     = BIT_EINT8_23; // by shim
  491. // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  492. if (s2440INT->rINTPND & BIT_EINT8_23) s2440INT->rINTPND = BIT_EINT8_23;
  493. s2440INT->rINTMSK    &= ~BIT_EINT8_23;
  494. //RETAILMSG(1,(TEXT("::: SYSINTR_ETHER    OEMInterruptEnablern")));
  495.         break;
  497. #if 0
  498. case SYSINTR_USB:
  499.     // USB host interrupt enable bit. by hjcho
  500.     s2440INT->rINTMSK &= ~BIT_USBH;
  501.     break;
  503. case SYSINTR_USBD:
  504.     s2440INT->rINTMSK &= ~BIT_USBD;
  505. //RETAILMSG(1,(TEXT("::: SYSINTR_USBD     OEMInterruptEnablern")));
  506.     break;
  507. #else
  508. case SYSINTR_USB: // USB host.
  509. s2440INT->rSRCPND  = BIT_USBH;
  510. // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  511. if (s2440INT->rINTPND & BIT_USBH) s2440INT->rINTPND = BIT_USBH;
  512. s2440INT->rINTMSK &= ~BIT_USBH;
  513. break;
  515. case SYSINTR_USBD:
  516. s2440INT->rSRCPND  = BIT_USBD;
  517. // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  518. if (s2440INT->rINTPND & BIT_USBD) s2440INT->rINTPND = BIT_USBD;
  519. s2440INT->rINTMSK &= ~BIT_USBD;
  520. RETAILMSG(1, (TEXT("USB enable interrutprn")));
  521. break;
  522. #endif
  524. case SYSINTR_POWER:
  525. s2440INT->rSRCPND  = BIT_EINT0;
  526. // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  527. if (s2440INT->rINTPND & BIT_EINT0) s2440INT->rINTPND = BIT_EINT0;
  528. s2440INT->rINTMSK &= ~BIT_EINT0;
  529. s2440INT->rSRCPND  = BIT_EINT2;
  530. // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  531. if (s2440INT->rINTPND & BIT_EINT2) s2440INT->rINTPND = BIT_EINT2;
  532. s2440INT->rINTMSK &= ~BIT_EINT2;
  533. break;     
  535. case SYSINTR_CAM:
  536. s2440INT->rINTSUBMSK &= ~(BIT_SUB_CAM_P | BIT_SUB_CAM_C);
  537. s2440INT->rINTMSK &= ~BIT_CAM;
  538. break;
  540.     case SYSINTR_IIC:
  541.         s2440INT->rINTMSK &= ~BIT_IIC;
  542.        break;
  544. default:
  545. bRet = FALSE; /* unsupported interrupt value */
  546. //return(FALSE);
  547.         break;
  548. }
  549.     
  550. INTERRUPTS_ON();
  551.     
  552.     return bRet;
  553.     
  554. //return(TRUE);
  555. }
  559. //------------------------------------------------------------------------------
  560. //  
  561. //  @func   BOOL | OEMInterruptDisable | Disable a hardware interrupt
  562. //  @rdesc  none
  563. //  @comm   OEMInterruptDisable is called by the Kernel when a device driver
  564. //          calls <f InterruptDisable>. The system is not preemtible when this
  565. //          function is called.
  566. //  @xref   <l Overview.Windows CE Kernel OEM Interface> <f InterruptDisable>
  567. //  
  568. //------------------------------------------------------------------------------
  569. void 
  570. OEMInterruptDisable(DWORD idInt) // @parm Interrupt ID to be disabled. See <t Interrupt ID's>
  571. // for the list of possible values.
  572. {
  573. volatile INTreg *s2440INT = (INTreg *)INT_BASE;
  574. volatile IOPreg *s2440IOP = (IOPreg *)IOP_BASE;
  575. volatile MMCreg *s2440SDIO = (MMCreg *)MMC_BACE;
  577.     INTERRUPTS_OFF();
  579. switch (idInt) 
  580. {
  581. case SYSINTR_BREAK: // There is no halt button on P2.
  582. break;
  584.     case SYSINTR_DMA0:
  585.         s2440INT->rINTMSK |= BIT_DMA0; // SDIO DMA interrupt
  586. //RETAILMSG(1,(TEXT("::: SYSINTR_DMA0    OEMInterruptDisablern")));
  587. break;
  589. case SYSINTR_SDMMC:
  590. s2440INT->rINTMSK |= BIT_MMC;
  591. //RETAILMSG(1,(TEXT("::: SYSINTR_SDMMC    OEMInterruptDisablern")));
  592. break;
  594. case SYSINTR_SDMMC_SDIO_INTERRUPT:
  595. s2440INT->rINTMSK |= BIT_MMC;
  596. s2440SDIO->rSDIINTMSK &= ~(0x1<<12); // interrupt from SDIO card
  597. //RETAILMSG(1,(TEXT("::: SYSINTR_SDMMC_SDIO_INTERRUPT    OEMInterruptDisablern")));
  598. break;
  600. case SYSINTR_SDMMC_CARD_DETECT:
  601. #if SDIO_FOR_100BD // for b'd revision 1.00
  602. s2440IOP->rEINTMASK |= (1 << 18);
  603. #else // for b'd revision 0.17
  604. s2440IOP->rEINTMASK |= (1 << 16);
  605. #endif
  606. s2440INT->rINTMSK    |= BIT_EINT8_23;
  607. //RETAILMSG(1,(TEXT("::: SYSINTR_SDMMC_CARD_DETECT    OEMInterruptDisablern")));
  608. break;        
  611. case SYSINTR_TOUCH:
  612.     break;
  614. case SYSINTR_TOUCH_CHANGED:
  615. s2440INT->rINTMSK |= BIT_ADC;
  616. s2440INT->rINTSUBMSK |= INTSUB_TC;
  617.     break;
  619. case SYSINTR_KEYBOARD:
  620. s2440INT->rINTMSK |= BIT_EINT1;
  621. break;
  623. case SYSINTR_SERIAL:
  624. s2440INT->rINTMSK    |= BIT_UART0;
  625. s2440INT->rINTSUBMSK |= INTSUB_RXD0;
  626. s2440INT->rINTSUBMSK |= INTSUB_TXD0;
  627. s2440INT->rINTSUBMSK |= INTSUB_ERR0;
  628. break;
  630. case SYSINTR_IR:
  631. s2440INT->rINTMSK    |= BIT_UART2;
  632. s2440INT->rINTSUBMSK |= INTSUB_RXD2;
  633. s2440INT->rINTSUBMSK |= INTSUB_TXD2;
  634. s2440INT->rINTSUBMSK |= INTSUB_ERR2;
  635. break;
  637. case SYSINTR_AUDIO:
  638.         s2440INT->rINTMSK |= BIT_DMA1; // Audio input DMA.
  639. s2440INT->rINTMSK |= BIT_DMA2; // Audio output DMA.
  640. break;
  642. case SYSINTR_ADC:
  643. break;
  645.     case SYSINTR_PCMCIA_LEVEL:
  646. s2440IOP->rEINTMASK |= 0x100;
  647. s2440INT->rINTMSK   |= BIT_EINT8_23;
  648. //RETAILMSG(1,(TEXT("::: SYSINTR_PCMCIA_LEVEL    OEMInterruptDisablern")));
  649.         break;
  651. case SYSINTR_PCMCIA_EDGE:
  652. break;
  654. case SYSINTR_PCMCIA_STATE:
  655. s2440INT->rINTMSK |= BIT_EINT3;
  656. //RETAILMSG(1,(TEXT("::: SYSINTR_PCMCIA_STATE    OEMInterruptDisablern")));
  657. break;
  659.     case SYSINTR_ETHER:
  660. s2440INT->rINTMSK   |= BIT_EINT8_23;
  661. s2440IOP->rEINTMASK |= 0x200;
  662. //RETAILMSG(1,(TEXT("::: SYSINTR_ETHER    OEMInterruptDisablern")));
  663.         break;        
  665. case SYSINTR_USB:
  666. s2440INT->rINTMSK |= BIT_USBH;
  667. break;
  668.         
  669. case SYSINTR_USBD:
  670. s2440INT->rINTMSK |= BIT_USBD;
  671. //RETAILMSG(1,(TEXT("::: SYSINTR_USBD    OEMInterruptDisablern")));
  672. break;
  673.         
  674. case SYSINTR_POWER:
  675. s2440INT->rINTMSK |= BIT_EINT0;
  676. s2440INT->rINTMSK |= BIT_EINT2;
  677. break;        
  679. case SYSINTR_CAM:
  680. s2440INT->rINTMSK |= BIT_CAM;
  681. s2440INT->rINTSUBMSK |= (INTSUB_CAM_P | INTSUB_CAM_C);
  682. break;
  684.     case SYSINTR_IIC:
  685.         s2440INT->rINTMSK |= BIT_IIC;
  686.        break;
  688. default:
  689. break;
  690. }
  691. INTERRUPTS_ON();
  692. }
  695. //------------------------------------------------------------------------------
  696. //  
  697. //  @func   BOOL | OEMInterruptDone | Signal completion of interrupt processing
  698. //  @rdesc  none
  699. //  @comm   OEMInterruptDone is called by the Kernel when a device driver
  700. //          calls <f InterruptDone>. The system is not preemtible when this
  701. //          function is called.
  702. //  @xref   <l Overview.Kernel Interrupt Support> <f InterruptDone>
  703. //  
  704. //------------------------------------------------------------------------------
  705. void 
  706. OEMInterruptDone(DWORD idInt) // @parm Interrupt ID. See <t Interrupt ID's>
  707.                      // for the list of possible values.
  708. {
  709. volatile INTreg *s2440INT = (INTreg *)INT_BASE;
  710. volatile IOPreg *s2440IOP = (IOPreg *)IOP_BASE;    
  712. INTERRUPTS_OFF();
  714. switch (idInt) 
  715. {
  717.     case SYSINTR_DMA0:
  718.         s2440INT->rINTMSK &= ~BIT_DMA0; // SDIO DMA interrupt
  719. //RETAILMSG(1,(TEXT("::: SYSINTR_DMA0    OEMInterruptDonern")));
  720. break;
  722. case SYSINTR_SDMMC:
  723. s2440INT->rINTMSK &= ~BIT_MMC;
  724. //RETAILMSG(1,(TEXT("::: SYSINTR_SDMMC    OEMInterruptDonern")));
  725. break;
  727. case SYSINTR_SDMMC_SDIO_INTERRUPT:
  728. s2440INT->rINTMSK &= ~BIT_MMC;
  729. //RETAILMSG(1,(TEXT("::: SYSINTR_SDMMC_SDIO_INTERRUPT    OEMInterruptDonern")));
  730. break;
  732. case SYSINTR_SDMMC_CARD_DETECT:
  733. #if SDIO_FOR_100BD // for b'd revision 1.00
  734. s2440IOP->rEINTPEND  = (1<<18);
  735. s2440IOP->rEINTMASK &= ~(1 << 18);
  736. //RETAILMSG(1,(TEXT("::: SYSINTR_SDMMC_CARD_DETECT    OEMInterruptDonern")));
  737. #else // for b'd revision 0.17
  738. s2440IOP->rEINTPEND  = (1<<16);
  739. s2440IOP->rEINTMASK &= ~(1 << 16);
  740. #endif
  741. s2440INT->rINTMSK   &= ~BIT_EINT8_23;
  742. break;        
  744.     case SYSINTR_TOUCH:
  745.         /*
  746.          * Nothing has to be done here as interrupts are masked and unmasked by the touch
  747.          * handler in the HAL.
  748.          */
  749. s2440INT->rINTMSK &= ~BIT_TIMER1;
  750.         break;
  752.     case SYSINTR_TOUCH_CHANGED:
  753.         /*
  754.          * Nothing has to be done here as interrupts are masked and unmasked by the touch
  755.          * handler in the HAL.
  756.          */
  757. s2440INT->rINTMSK &= ~BIT_ADC;
  758. s2440INT->rINTSUBMSK &= ~INTSUB_TC;
  759. //RETAILMSG(0,(TEXT("OEMInterruptDone:TOUCH CHANGEDnrn")));
  760.         break;
  762. case SYSINTR_KEYBOARD:
  763. s2440INT->rINTMSK &= ~BIT_EINT1;
  764. break;
  766. case SYSINTR_SERIAL:
  767. s2440INT->rINTMSK    &= ~BIT_UART0;
  768. s2440INT->rINTSUBMSK &= ~INTSUB_RXD0;
  769. break;
  771. case SYSINTR_IR:
  772. s2440INT->rINTMSK    &= ~BIT_UART2;
  773. s2440INT->rINTSUBMSK &= ~INTSUB_RXD2;
  774. break;
  776. case SYSINTR_AUDIO:
  777. // DMA1 is for audio input.
  778. // DMA2 is for audio output.
  779. s2440INT->rSRCPND = (BIT_DMA1 | BIT_DMA2); 
  780. if (s2440INT->rINTPND & BIT_DMA1) s2440INT->rINTPND = BIT_DMA1;
  781. if (s2440INT->rINTPND & BIT_DMA2) s2440INT->rINTPND = BIT_DMA2;
  782.         s2440INT->rINTMSK &= ~BIT_DMA1;
  783.         s2440INT->rINTMSK &= ~BIT_DMA2;
  784. break;
  786. case SYSINTR_ADC:
  787. break;
  789. case SYSINTR_PCMCIA_LEVEL:
  790. s2440INT->rSRCPND = BIT_EINT8_23;
  791. if (s2440INT->rINTPND & BIT_EINT8_23) s2440INT->rINTPND = BIT_EINT8_23; 
  792. s2440INT->rINTMSK   &= ~BIT_EINT8_23;
  793. s2440IOP->rEINTMASK &= ~(1<<8);
  794. //RETAILMSG(1,(TEXT("::: SYSINTR_PCMCIA_LEVEL    OEMInterruptDonern")));
  795. break;
  797. case SYSINTR_PCMCIA_EDGE:
  798. //RETAILMSG(1,(TEXT("::: SYSINTR_PCMCIA_EDGE    OEMInterruptDonern")));
  799. break;
  801. case SYSINTR_PCMCIA_STATE:
  802. s2440INT->rINTMSK &= ~BIT_EINT3;
  803. //RETAILMSG(1,(TEXT("::: SYSINTR_PCMCIA_STATE    OEMInterruptDonern")));
  804. break;
  806. case SYSINTR_ETHER:
  807. s2440INT->rINTMSK   &= ~BIT_EINT8_23;
  808. s2440IOP->rEINTMASK &= ~0x200;
  809. //RETAILMSG(1, (TEXT("::: SYSINTR_USBD OEMInterruptDonern")));
  810. break;
  811.         
  812. case SYSINTR_USB:
  813. s2440INT->rINTMSK &= ~BIT_USBH;
  814. break;
  816. case SYSINTR_USBD:
  817. s2440INT->rINTMSK &= ~BIT_USBD;
  818. //RETAILMSG(1,(TEXT("::: SYSINTR_USBD    OEMInterruptDonern")));
  819. break;
  820.         
  821. case SYSINTR_POWER:
  822. s2440INT->rSRCPND = BIT_EINT0;
  823. // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  824. if (s2440INT->rINTPND & BIT_EINT0) s2440INT->rINTPND = BIT_EINT0;
  825. s2440INT->rINTMSK &= ~BIT_EINT0;
  826. s2440INT->rSRCPND = BIT_EINT2;
  827. // S3C2440X Developer Notice (page 4) warns against writing a 1 to a 0 bit in the INTPND register.
  828. if (s2440INT->rINTPND & BIT_EINT2) s2440INT->rINTPND = BIT_EINT2;
  829. s2440INT->rINTMSK &= ~BIT_EINT2;
  830. break;
  832. case SYSINTR_CAM:
  833. s2440INT->rSUBSRCPND = INTSUB_CAM_P;
  834. s2440INT->rSUBSRCPND = INTSUB_CAM_C;
  835. s2440INT->rSRCPND = BIT_CAM;
  837. if (s2440INT->rINTPND & BIT_CAM)
  838. {
  839. s2440INT->rINTPND = BIT_CAM;
  840. }
  841. s2440INT->rINTSUBMSK &= ~(INTSUB_CAM_P | INTSUB_CAM_C);
  842. s2440INT->rINTMSK &= ~BIT_CAM;
  843. break;
  845.     case SYSINTR_IIC:
  846.         s2440INT->rINTMSK &= ~BIT_IIC;
  847.        break;
  849. }
  850.     INTERRUPTS_ON();
  851. }
  854. //------------------------------------------------------------------------------
  855. //------------------------------------------------------------------------------
  856. BOOL 
  857. OEMGetExtensionDRAM(
  858.     LPDWORD lpMemStart, 
  859.     LPDWORD lpMemLen
  860.     ) 
  861. {
  862.     return FALSE; // no extension DRAM
  863. }
  866. //------------------------------------------------------------------------------
  867. //
  868. //  OEMQueryPerformanceCounter
  869. //  
  870. //      The OEMQueryPerformanceCounter function retrieves the current value of 
  871. //      the high-resolution performance counter, if one exists. 
  872. //  
  873. //  BOOL QueryPerformanceCounter(
  874. //  
  875. //      LARGE_INTEGER  *lpliPerformanceCount    // address of current counter value
  876. //     );   
  877. //  
  878. //  Parameters
  879. //  
  880. //  lpliPerformanceCount
  881. //  
  882. //      Points to a variable that the function sets, in counts, to the current 
  883. //      performance-counter value. If the installed hardware does not support 
  884. //      a high-resolution performance counter, this parameter can be to zero. 
  885. //  
  886. //  Return Value
  887. //  
  888. //      If the installed hardware supports a high-resolution performance 
  889. //      counter, the return value is TRUE.
  890. //      If the installed hardware does not support a high-resolution 
  891. //      performance counter, the return value is FALSE.   
  892. //  
  893. //  If this function is implemented by the OEM, the pointer pQueryPerformanceCounter
  894. //  should be initialized as follows:
  895. //  
  896. //  BOOL (*pQueryPerformanceCounter)(LARGE_INTEGER *lpliPerformanceCount)=OEMQueryPerformanceCounter;
  897. //
  898. //------------------------------------------------------------------------------
  899. BOOL 
  900. OEMQueryPerformanceCounter(
  901.     LARGE_INTEGER *lpliPerformanceCount
  902.     )
  903. {
  904.     extern DWORD PerfCountSinceTick();
  905.     
  906.     ULARGE_INTEGER liBase;
  907.     DWORD dwCurCount;
  909. // Make sure CurTicks is the same before and after read of counter to account for
  910. // possible rollover
  911.     do {
  912.         liBase = CurTicks;
  913.         dwCurCount = PerfCountSinceTick();
  914.     } while  (liBase.LowPart != CurTicks.LowPart) ;  
  916.     lpliPerformanceCount->QuadPart = liBase.QuadPart + dwCurCount;
  917.     
  918.     return TRUE;
  919. }
  923. //------------------------------------------------------------------------------
  924. //
  925. //  OEMQueryPerformanceFrequency
  926. //  
  927. //      The OEMQueryPerformanceFrequency function retrieves the frequency of 
  928. //      the high-resolution performance counter, if one exists. 
  929. //  
  930. //  BOOL OEMQueryPerformanceFrequency(
  931. //  
  932. //      LARGE_INTEGER  *lpliPerformanceFreq     // address of current frequency
  933. //     );   
  934. //  
  935. //  Parameters
  936. //  
  937. //  lpliPerformanceFreq
  938. //  
  939. //      Points to a variable that the function sets, in counts per second, to 
  940. //      the current performance-counter frequency. If the installed hardware 
  941. //      does not support a high-resolution performance counter, this parameter
  942. //      can be to zero. 
  943. //  
  944. //  Return Value
  945. //  
  946. //      If the installed hardware supports a high-resolution performance 
  947. //      counter, the return value is TRUE.
  948. //      If the installed hardware does not support a high-resolution 
  949. //      performance counter, the return value is FALSE.
  950. //  
  951. //  If this function is implemented by the OEM, the pointer pQueryPerformanceFrequency
  952. //  should be initialized as follows:
  953. //  
  954. //  BOOL (*pQueryPerformanceFrequency)(LARGE_INTEGER *lpPerformanceFrequency)=OEMQueryPerformanceFrequency;
  955. //
  956. //------------------------------------------------------------------------------
  957. BOOL 
  958. OEMQueryPerformanceFrequency(
  959.     LARGE_INTEGER *lpliPerformanceFreq
  960.     ) 
  961. {
  962.     extern DWORD PerfCountFreq();
  963.     
  964.     lpliPerformanceFreq->HighPart = 0;
  965.     lpliPerformanceFreq->LowPart  = PerfCountFreq();
  966.     return TRUE;
  967. }
  969. // set pointers to OEM functions
  970. BOOL (*pQueryPerformanceCounter)(LARGE_INTEGER *lpliPerformanceCount)=OEMQueryPerformanceCounter;
  971. BOOL (*pQueryPerformanceFrequency)(LARGE_INTEGER *lpliPerformanceFreq)=OEMQueryPerformanceFrequency;
  974. //
  975. // CPU-specific functions for OEMIdle
  976. //
  977. extern void  CPUEnterIdle(DWORD dwIdleParam);
  978. extern DWORD CPUGetSysTimerCountMax(DWORD dwIdleMSecRequested);
  979. extern void  CPUSetSysTimerCount(DWORD dwIdleMSec);
  980. extern BOOL CPUClearSysTimerIRQ(void);
  983. //
  984. // dougfir or later
  985. //
  986. extern DWORD
  987. CPUGetSysTimerCountElapsed(
  988.     DWORD dwTimerCountdownMSec,
  989.     volatile DWORD *pCurMSec,
  990.     DWORD *pPartialCurMSec,
  991.     volatile ULARGE_INTEGER *pCurTicks
  992.     );
  994. //------------------------------------------------------------------------------
  995. //
  996. //  This routine is called by the kernel when there are no threads ready to
  997. //  run. The CPU should be put into a reduced power mode and halted. It is 
  998. //  important to be able to resume execution quickly upon receiving an interrupt.
  999. //  Note: It is assumed that interrupts are off when OEMIdle is called.  Interrrupts
  1000. //  are turned off when OEMIdle returns.
  1001. //
  1002. //------------------------------------------------------------------------------
  1003. static DWORD dwPartialCurMSec = 0; // Keep CPU-specific sub-millisecond leftover.
  1004. void
  1005. OEMIdle( DWORD dwIdleParam )
  1006. {
  1007. DWORD dwIdleMSec;
  1008. DWORD dwPrevMSec = *pCurMSec;
  1010. // Use for 64-bit math
  1011. ULARGE_INTEGER currIdle = { curridlelow, curridlehigh };
  1013. if ((int) (dwIdleMSec = dwReschedTime - dwPrevMSec) <= 0) 
  1014. {
  1015. return; // already time to wakeup
  1016. }
  1018. // just idle till tick if profiling or running iltiming
  1019. if (bProfileTimerRunning || fIntrTime) // fIntrTime : Interrupt Latency timeing.
  1020. {
  1021. // idle till end of 'tick'
  1022. CPUEnterIdle(dwIdleParam);
  1024. // Update global idle time and return
  1025. currIdle.QuadPart += RESCHED_PERIOD;
  1026. curridlelow = currIdle.LowPart;
  1027. curridlehigh = currIdle.HighPart;
  1028.         
  1029. return;
  1030. }
  1032. //
  1033. // Since OEMIdle( ) is being called in the middle of a normal reschedule
  1034. // period, CurMSec, dwPartialCurMSec, and CurTicks need to be updated accordingly.
  1035. // Once we reach this point, we must re-program the timer (if we ever did) 
  1036. // because dwPartialCurMSec will be modified in the next function call.
  1037. //
  1038. CPUGetSysTimerCountElapsed(RESCHED_PERIOD, pCurMSec, &dwPartialCurMSec, pCurTicks);
  1040. if ((int) (dwIdleMSec -= *pCurMSec - dwPrevMSec) > 0)
  1041. {
  1042. dwPrevMSec = *pCurMSec;
  1044. //
  1045. // The system timer may not be capable of arbitrary timeouts. Get the
  1046. // CPU-specific highest possible timeout available.
  1047. //
  1048. dwIdleMSec = CPUGetSysTimerCountMax(dwIdleMSec);
  1050. //
  1051. // Set the timer to wake up much later than usual, if needed.
  1052. //
  1053. CPUSetSysTimerCount(dwIdleMSec);
  1054. CPUClearSysTimerIRQ( );
  1056. //
  1057. // Enable wakeup on any interrupt, then go to sleep.
  1058. //
  1059. // DEBUGMSG(1, (TEXT("OEMIDle  rn")));
  1060. CPUEnterIdle(dwIdleParam);
  1061. INTERRUPTS_OFF( );
  1062.         
  1063. //
  1064. // We're awake! The wake-up ISR (or any other ISR) has already run.
  1065. //
  1066. if (dwPrevMSec != *pCurMSec)
  1067. {
  1068. //
  1069. // We completed the full period we asked to sleep.  Update the counters.
  1070. //
  1071. *pCurMSec  += (dwIdleMSec - RESCHED_PERIOD); // Subtract resched period, because ISR also incremented.
  1072. CurTicks.QuadPart += (dwIdleMSec - RESCHED_PERIOD) * dwReschedIncrement;
  1074. currIdle.QuadPart += dwIdleMSec;
  1075. } else {
  1076. //
  1077. // Some other interrupt woke us up before the full idle period was
  1078. // complete.  Determine how much time has elapsed.
  1079. //
  1080. currIdle.QuadPart += CPUGetSysTimerCountElapsed(dwIdleMSec, pCurMSec, &dwPartialCurMSec, pCurTicks);
  1081. }
  1082. }
  1084. // Re-arm counters
  1085. CPUSetSysTimerCount(RESCHED_PERIOD);
  1086. CPUClearSysTimerIRQ( );
  1088. // Update global idle time
  1089. curridlelow = currIdle.LowPart;
  1090. curridlehigh = currIdle.HighPart;
  1092. return;
  1093. }
  1095. //------------------------------------------------------------------------------
  1096. //
  1097. //  DWORD GetTickCount(VOID)    Return count of time since boot in milliseconds
  1098. //
  1099. //------------------------------------------------------------------------------
  1100. DWORD 
  1101. SC_GetTickCount(void) 
  1102. {
  1103. DWORD dwInc = 0, dwPartial = dwPartialCurMSec;
  1104. DWORD curReturnMSec;
  1105. ULARGE_INTEGER cdummy = {0, 0};
  1107. curReturnMSec=*pCurMSec;
  1108. CPUGetSysTimerCountElapsed(RESCHED_PERIOD, &dwInc, &dwPartial, &cdummy);
  1110. return (curReturnMSec==*pCurMSec)?curReturnMSec+dwInc:*pCurMSec;
  1111. }
  1114. volatile BOOL fResumeFlag;
  1115. extern void CPUEnterIdleMode(void);
  1117. //------------------------------------------------------------------------------
  1118. // Initialize SDMMC block.. 
  1119. //------------------------------------------------------------------------------
  1120. static void InitSDMMC(void) 
  1121. {
  1122. volatile IOPreg *s2440IOP = (IOPreg *)IOP_BASE;
  1124. // Initialize SDMMC and Configure SDMMC Card Detect
  1125. // GPIO Configure 
  1126. // RETAILMSG(1,(TEXT("SDMMC config current rGPGCON: %xrn"), s2440IOP->rGPGCON));  
  1127. // We must need this PULL-UP routines to inialize.
  1128. // s2440IOP->rGPGUP = 0xF800;   
  1129. #if SDIO_FOR_100BD // for b'd revision 1.00
  1130. // s2440IOP->rGPGUP &= ~(1<<10);
  1131. s2440IOP->rGPGUP = 0xF800;
  1132. s2440IOP->rGPGCON &= ~((0x3 << 20));   
  1133. s2440IOP->rGPGCON |=  ((0x2 << 20)); // External Interrupt #18 Enable
  1134. //RETAILMSG(1,(TEXT("SDMMC config set rGPGCON: %xrn"), s2440IOP->rGPGCON));   
  1135. // s2440IOP->rEXTINT2 &= ~(0x7 << 8); // Configure EINT18 as Both Edge Mode
  1136. // s2440IOP->rEXTINT2 |=  (0x7 << 8);
  1137. #else // for b'd revision 0.17
  1138. s2440IOP->rGPGUP = 0xF800;   
  1139. s2440IOP->rGPGCON &= ~((0x3 << 16));   
  1140. s2440IOP->rGPGCON |=  ((0x0 << 16)); //input /* External Interrupt #16 Enable */
  1141. RETAILMSG(1,(TEXT("SDMMC config set rGPGCON: %xrn"), s2440IOP->rGPGCON));   
  1142. s2440IOP->rEINTPEND  = (1 << 16); //clear
  1143. s2440IOP->rEINTMASK |= (1 << 16); //disable
  1145. // s2440IOP->rEXTINT2 &= ~(0x7 << 0); /* Configure EINT16 as Both Edge Mode */
  1146. // s2440IOP->rEXTINT2 |=  (0x0 << 0); // low level trig
  1147. #endif
  1148. /* Configure SDMMC Write Protect */
  1149. s2440IOP->rGPHUP = 0x0;   
  1150. s2440IOP->rGPHCON &= ~((0x3 << 16));   
  1151. s2440IOP->rGPHCON |=  ((0x0 << 16)); /* GPH8/UCLK Write Protect Pin */
  1152. //RETAILMSG(1,(TEXT("SDMMC config Init Done.rn")));   
  1153. }
  1155. //------------------------------------------------------------------------------
  1156. // Initialize and test the LCD block.. 
  1157. //------------------------------------------------------------------------------
  1159. /*
  1160. // Define some values for TFT 16bpp
  1161. #if(LCDTYPE == TFT16BPP)    // TFT 640*480 / 16bpp
  1162. #define FR_WIDTH            240
  1163. #define FR_HEIGHT           320
  1164. #define PhysicalVmemSize    FR_HEIGHT*FR_WIDTH*LCDTYPE
  1167. struct FrameBuffer {
  1168.    unsigned short pixel[FR_HEIGHT][FR_WIDTH];
  1169. };
  1171. #else if(LCDTYPE == STN8BPP)// STN 320*240 / 8bpp
  1172. #define FR_WIDTH            320
  1173. #define FR_HEIGHT           240
  1174. #define PhysicalVmemSize    FR_HEIGHT*FR_WIDTH
  1176. struct FrameBuffer {
  1177.    unsigned char pixel[FR_HEIGHT][FR_WIDTH];
  1178. };
  1179. #endif
  1180. */
  1182. #if (LCD_TYPE == TFT640_480)
  1183. struct FrameBuffer {
  1184. unsigned short pixel[LCD_YSIZE_TFT][LCD_XSIZE_TFT];
  1185. };
  1186. struct FrameBuffer *FBuf;
  1187. #elif (LCD_TYPE == TFT240_320)
  1188. struct FrameBuffer *FBuf;
  1189. #endif
  1191. static void InitDisplay()
  1192. {
  1193. int i, j;
  1194. volatile IOPreg *s2440IOP;
  1195. volatile LCDreg *s2440LCD;    
  1197. s2440IOP = (IOPreg *)IOP_BASE;
  1198. s2440LCD = (LCDreg *)LCD_BASE; 
  1200. // LCD port initialize.
  1201. s2440IOP->rGPCUP  = 0xFFFFFFFF;
  1202. s2440IOP->rGPCCON = 0xAAAAAAAA;
  1204. s2440IOP->rGPDUP  = 0xFFFFFFFF;
  1205. s2440IOP->rGPDCON = 0xAAAAAAAA;
  1207. s2440IOP->rGPGCON &= ~(3 << 8); // Set LCD_PWREN as output
  1208. s2440IOP->rGPGCON |=  (1 << 8);
  1210. s2440IOP->rGPGDAT |=  (1 << 4); // Backlight ON
  1212. #if (LCD_TYPE == TFT640_480)
  1214. s2440LCD->rLCDCON1   =  (1 << 8) | // VCLK = HCLK / ((CLKVAL + 1) * 2) -> About 7 Mhz  // ;;; SHL
  1215. (0 << 7) | // 0 : Each Frame
  1216. (3 << 5) | // TFT LCD Pannel
  1217. (12<< 1) | // 16bpp Mode
  1218. (0 << 0) ; // Disable LCD Output
  1220. s2440LCD->rLCDCON2   =  (VBPD        << 24) | // VBPD          :   1
  1221. (LINEVAL_TFT << 14) | // Virtical Size : 320 - 1
  1222. (VFPD        <<  6) | // VFPD          :   2
  1223. (VSPW        <<  0) ; // VSPW          :   1
  1225. s2440LCD->rLCDCON3   =  (HBPD        << 19) | // HBPD          :   6
  1226. (HOZVAL_TFT  <<  8) | // HOZVAL_TFT    : 240 - 1
  1227. (HFPD        <<  0) ; // HFPD          :   2
  1230. s2440LCD->rLCDCON4   =  (MVAL        <<  8) | // MVAL          :  13                              */
  1231. (HSPW        <<  0) ; // HSPW          :   4                              */
  1233. s2440LCD->rLCDCON5   =  (0 << 12) | // BPP24BL       : LSB valid
  1234. (1 << 11) | // FRM565 MODE   : 5:6:5 Format
  1235. (0 << 10) | // INVVCLK       : VCLK Falling Edge
  1236. (1 <<  9) | // INVVLINE      : Inverted Polarity
  1237. (1 <<  8) | // INVVFRAME     : Inverted Polarity
  1238. (0 <<  7) | // INVVD         : Normal
  1239. (0 <<  6) | // INVVDEN       : Normal
  1240. (0 <<  5) | // INVPWREN      : Normal
  1241. (0 <<  4) | // INVENDLINE    : Normal
  1242. (0 <<  3) | // PWREN         : Disable PWREN
  1243. (0 <<  2) | // ENLEND        : Disable LEND signal
  1244. (0 <<  1) | // BSWP          : Swap Disable
  1245. (1 <<  0) ; // HWSWP         : Swap Enable
  1247. s2440LCD->rLCDSADDR1 = ((FRAMEBUF_DMA_BASE >> 22) << 21) |
  1248. ((M5D(FRAMEBUF_DMA_BASE >> 1)) <<  0);
  1250. s2440LCD->rLCDSADDR2 = M5D((FRAMEBUF_DMA_BASE + (LCD_XSIZE_TFT * LCD_YSIZE_TFT * 2)) >> 1);
  1252. s2440LCD->rLCDSADDR3 = (((LCD_XSIZE_TFT - LCD_XSIZE_TFT) / 1) << 11) | (LCD_XSIZE_TFT / 1);
  1254. // s2440LCD->rLPCSEL    |= 0x3; // for aiji
  1255. s2440LCD->rLCDINTMSK |= (3);
  1256. s2440LCD->rTCONSEL   &= ~(0x7); // ;;; SHL
  1257. s2440LCD->rTCONSEL   |= 0x2; //240*320
  1258. s2440LCD->rTPAL       = 0x0;
  1259. s2440LCD->rTCONSEL   &= ~((1<<4) | 1); // Disable LCC3600, LCP3600
  1260. s2440IOP->rGPGUP   = s2440IOP->rGPGUP  & (~(1<<4)) | (1<<4); // Pull-up disbale
  1261. s2440IOP->rGPGCON   = s2440IOP->rGPGCON & (~(3<<8)) | (3<<8);
  1262. s2440LCD->rLCDCON5    = s2440LCD->rLCDCON5 & (~(1<<3)) | (1<<3); // PWREN
  1263. s2440LCD->rLCDCON5    = s2440LCD->rLCDCON5 & (~(1<<5)) | (0<<5); // INVPWREN
  1264. s2440LCD->rLCDCON1  |= 1; // Enable LCD output
  1266. #elif (LCD_TYPE == TFT240_320)
  1268. // s2440LCD->rLCDCON1   =  (6           <<  8) |   /* VCLK = HCLK / ((CLKVAL + 1) * 2) -> About 7 Mhz  */
  1269. s2440LCD->rLCDCON1   =  (12           <<  8) |   /* VCLK = HCLK / ((CLKVAL + 1) * 2) -> About 7 Mhz */  // ;;; SHL
  1270. (MVAL_USED   <<  7) |   /* 0 : Each Frame                                   */
  1271. (3           <<  5) |   /* TFT LCD Pannel                                   */
  1272. (12          <<  1) |   /* 16bpp Mode                                       */
  1273. (0           <<  0) ;   /* Disable LCD Output                               */
  1275. s2440LCD->rLCDCON2   =  (VBPD        << 24) |   /* VBPD          :   1                              */
  1276. (LINEVAL_TFT << 14) |   /* Virtical Size : 320 - 1                          */
  1277. (VFPD        <<  6) |   /* VFPD          :   2                              */
  1278. (VSPW        <<  0) ;   /* VSPW          :   1                              */
  1280. s2440LCD->rLCDCON3   =  (HBPD        << 19) |   /* HBPD          :   6                              */
  1281. (HOZVAL_TFT  <<  8) |   /* HOZVAL_TFT    : 240 - 1                          */
  1282. (HFPD        <<  0) ;   /* HFPD          :   2                              */
  1285. s2440LCD->rLCDCON4   =  (MVAL        <<  8) |   /* MVAL          :  13                              */
  1286. (HSPW        <<  0) ;   /* HSPW          :   4                              */
  1288. s2440LCD->rLCDCON5   =  (0           << 12) |   /* BPP24BL       : LSB valid                        */
  1289. (1           << 11) |   /* FRM565 MODE   : 5:6:5 Format                     */
  1290. (0           << 10) |   /* INVVCLK       : VCLK Falling Edge                */
  1291. (1           <<  9) |   /* INVVLINE      : Inverted Polarity                */
  1292. (1           <<  8) |   /* INVVFRAME     : Inverted Polarity                */
  1293. (0           <<  7) |   /* INVVD         : Normal                           */
  1294. (0           <<  6) |   /* INVVDEN       : Normal                           */
  1295. (0           <<  5) |   /* INVPWREN      : Normal                           */
  1296. (0           <<  4) |   /* INVENDLINE    : Normal                           */
  1297. (0           <<  3) |   /* PWREN         : Disable PWREN                    */
  1298. (0           <<  2) |   /* ENLEND        : Disable LEND signal              */
  1299. (0           <<  1) |   /* BSWP          : Swap Disable                     */
  1300. (1           <<  0) ;   /* HWSWP         : Swap Enable                      */
  1302. s2440LCD->rLCDSADDR1 = ((FRAMEBUF_DMA_BASE >> 22)     << 21) |
  1303. ((M5D(FRAMEBUF_DMA_BASE >> 1)) <<  0);
  1305. s2440LCD->rLCDSADDR2 = M5D((FRAMEBUF_DMA_BASE + (LCD_XSIZE_TFT * LCD_YSIZE_TFT * 2)) >> 1);
  1307. s2440LCD->rLCDSADDR3 = (((LCD_XSIZE_TFT - LCD_XSIZE_TFT) / 1) << 11) | (LCD_XSIZE_TFT / 1);
  1309. // s2440LCD->rLPCSEL   |= 0x3; // for aiji
  1310. s2440LCD->rTCONSEL &= ~(0x7); // ;;; SHL
  1311. s2440LCD->rTCONSEL   |= 0x2; //240*320
  1312. s2440LCD->rTCONSEL   &= ~((1<<4) | 1); // Disable LCC3600, LCP3600
  1313. // s2440LCD->rTCONSEL |= (1<<4); // ;;; SHL
  1315. s2440LCD->rTPAL     = 0x0;
  1316. s2440LCD->rLCDCON1 |= 1;
  1317. #endif
  1319. #if (LCD_TYPE == TFT640_480)
  1321. FBuf = (struct FrameBuffer *) (FRAMEBUF_BASE);
  1323. // Test LCD display status with R.G.B and White color.
  1324. for (i=0; i<LCD_YSIZE_TFT/2; i++)
  1325. {
  1326. for (j=0; j<LCD_XSIZE_TFT; j++)
  1327. {
  1328. if (j<LCD_XSIZE_TFT/2)
  1329. #if (LCDTYPE == TFT16BPP)
  1330. FBuf->pixel[i][j]=0xffff;
  1331. #else
  1332. FBuf->pixel[i][j]=0xff;
  1333. #endif
  1334. else
  1335. #if (LCDTYPE == TFT16BPP)
  1336. FBuf->pixel[i][j]=0xf800;
  1337. #else
  1338. FBuf->pixel[i][j]=0xe0;
  1339. #endif
  1340. }
  1341. }
  1343. for (i=LCD_YSIZE_TFT/2; i<LCD_YSIZE_TFT; i++)
  1344. {
  1345. for (j=0; j<LCD_XSIZE_TFT; j++)
  1346. {
  1347. if (j<LCD_XSIZE_TFT/2)
  1348. #if (LCDTYPE == TFT16BPP)
  1349. FBuf->pixel[i][j]=0x07e0;
  1350. #else
  1351. FBuf->pixel[i][j]=0x1c;
  1352. #endif
  1353. else
  1354. #if (LCDTYPE == TFT16BPP)
  1355. FBuf->pixel[i][j]=0x001f;
  1356. #else
  1357. FBuf->pixel[i][j]=0x03;
  1358. #endif
  1359. }
  1360. }
  1362. #elif (LCD_TYPE == TFT240_320)
  1363. memcpy((void *)FRAMEBUF_BASE, ScreenBitmap, ARRAY_SIZE_TFT_16BIT);
  1364. //    rle_express(ScreenBitmap, (unsigned short *)FRAMEBUF_BASE, 0x8a8c / 2);
  1365. #endif
  1366. }
  1368. static void OEMInitInterrupts(void) // for KITL 030828
  1369. {
  1370. volatile INTreg *s2440INT = (INTreg *)INT_BASE;
  1371. volatile IOPreg *s2440IOP = (IOPreg *)IOP_BASE;
  1373. // Configure EINT9 for CS8900 interrupt.
  1374. //
  1375. s2440IOP->rGPGCON  = (s2440IOP->rGPGCON  & ~(0x3 << 0x2)) | (0x2 << 0x2); // GPG1 == EINT9.
  1376. s2440IOP->rGPGUP   = (s2440IOP->rGPGUP   |  (0x1 << 0x1)); // Disable pull-up.
  1377. s2440IOP->rEXTINT1 = (s2440IOP->rEXTINT1 & ~(0xf << 0x4)) | (0x1 << 0x4); // Level-high triggered.
  1379. // Configure EINT8 for PD6710 interrupt.
  1380. //
  1381. s2440IOP->rGPGCON  = (s2440IOP->rGPGCON  & ~(0x3 << 0x0)) | (0x2 << 0x0); // GPG0 == EINT8.
  1382. s2440IOP->rGPGUP   = (s2440IOP->rGPGUP   |  (0x1 << 0x0)); // Disable pull-up.
  1383. s2440IOP->rEXTINT1 = (s2440IOP->rEXTINT1 & ~(0xf << 0x0)) | (0x1 << 0x0); // Level-high triggered.
  1385. // Mask and clear all peripheral interrupts (these come through a second-level "GPIO" interrupt register).
  1386. //
  1387. s2440IOP->rEINTMASK = BIT_ALLMSK; // Mask all EINT interrupts.
  1388. s2440IOP->rEINTPEND = BIT_ALLMSK; // Clear pending EINT interrupts.
  1390. // Mask and clear all interrupts.
  1391. //
  1392. s2440INT->rINTMSK = BIT_ALLMSK; // Mask all interrupts (reset value).
  1393. s2440INT->rINTMSK &= ~BIT_BAT_FLT;
  1394. s2440INT->rSRCPND = BIT_ALLMSK; // Clear pending interrupts.
  1395. s2440INT->rINTPND = s2440INT->rINTPND; // S3C2440X developer notice (page 4) warns against writing a 1 to any
  1396. // 0 bit field in the INTPND register.  Instead we'll write the INTPND value itself.
  1397. }