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

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

Windows CE

开发平台：

Windows_Unix

armint.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. ARM920(S3C2440) interrupt service routine
  14. rev:
  15. 2002.4.3 : first S3C2410 version (SOC)
  17. 2002.2.5 : system tick modification (kwangyoon LEE, kwangyoon@samsung.com)
  18. - one shot timer
  19. 2002.1.29 : bug fixups (kwangyoon LEE, kwangyoon@samsung.com)
  20. - system tick interrupt
  21. 2002.1.28 : CE.NET port (kwangyoon LEE, kwangyoon@samsung.com)
  22. 2002.1.22 : Add USBD interrupt (kwangyoon LEE, kwangyoon@samsung.com)
  24. Notes: 
  25. --*/
  27. #include <windows.h>
  28. #include <nkintr.h>
  29. #include <oalintr.h>
  30. #include "p2.h"
  31. #include "p2debug.h"
  32. #include "drv_glob.h"
  34. #include <S2440.h>
  36. #define SDIO_FOR_100BD 0
  38. extern DWORD CurMSec;
  39. extern DWORD DiffMSec;
  41. #if (CE_MAJOR_VER == 0x0003)
  42. extern DWORD ticksleft, dwSleepMin, dwPreempt;
  43. extern DWORD DiffMSec;
  44. #else
  45. extern DWORD dwReschedTime;
  46. #endif
  48. extern DWORD AlarmTime;
  49. extern volatile LARGE_INTEGER CurTicks;
  50. extern DWORD dwReschedIncrement;
  51. extern int (*PProfileInterrupt)(void);
  53. extern DWORD dwIsrTime1, dwIsrTime2;
  54. extern BOOL fIntrTime, fIntrTimeToggle;
  55. extern WORD wNumInterrupts;    // Reset by a read of the ISR times from the IST
  56. extern DWORD dwIntrTimeCountdown;
  57. extern DWORD dwIntrTimeCountdownRef;
  58. extern DWORD dwSPC;
  59. extern DWORD PerfCountSinceTick();
  60. extern BOOL fInterruptFlag;
  61. extern VOID CPUPowerReset();
  62. extern VOID OEMEmergencyPowerOff();
  65. static USBD_GLOBALS *usbdShMem=&((DRIVER_GLOBALS *)DRIVER_GLOBALS_PHYSICAL_MEMORY_START)->usbd; //:-)
  66. void UsbdClearEir(void);  //:-)
  68. DWORD OEMTranslateIrq(DWORD dwIrq)
  69. {
  70.     return dwIrq;
  71. }
  72. DWORD OEMTranslateSysIntr(DWORD SysIntr)
  73. {
  74.     return (SysIntr<SYSINTR_FIRMWARE?(DWORD)-1:SysIntr);
  75. }
  77. void OEMInterruptHandlerFIQ() 
  78. {
  79. // This FIQ interrupt is from BAT_FLT.
  80. volatile IOPreg *s2440IOP = (IOPreg *)IOP_BASE;
  81. volatile INTreg *s2440INT = (INTreg *)INT_BASE;
  83. s2440IOP->rGPFDAT = ~(0xa << 4);   /* LED Off */
  84. OEMEmergencyPowerOff();
  85. while(1);
  86. // RETAILMSG(1, (TEXT(">>> OEMInterruptHandlerFIQ rn")));
  87. }
  90. int flag = 1;
  91. unsigned int tCnt = 0;
  92. unsigned int ttt = 0;
  96. int OEMInterruptHandler(unsigned int ra) 
  97. {
  98. static BYTE nLED = 0x1;
  99. volatile INTreg *s2440INT = (INTreg *)INT_BASE;
  100. volatile IOPreg *s2440IOP = (IOPreg *)IOP_BASE;
  101. volatile PWMreg *s2440PWM = (PWMreg *)PWM_BASE;
  102. volatile MMCreg *s2440SDIO = (MMCreg *)MMC_BACE;
  104. unsigned int IntPendVal;
  105. unsigned int SubIntPendVal; // for serial
  106. DWORD submask;
  108. // jylee
  109. volatile ADCreg *s2440ADC = (ADCreg *)ADC_BASE;
  111. static DWORD HeartBeatCnt, HeartBeatStat;
  112. static volatile struct udcreg *s2440USBD = (volatile struct udcreg *)(0xB1200140); // 0xB1200140
  113. volatile BYTE usbd_eir = 0, usbd_uir = 0;
  115.     TOUCH_GLOBALS *odo_tsb;  //Sample buffer stuff
  116.     // for this, You MUST modify bsp/inc/drv_glob.h.. check drv_glob.h_jylee
  117.     odo_tsb = &((DRIVER_GLOBALS *)DRIVER_GLOBALS_PHYSICAL_MEMORY_START)->tch;
  119. // Update LEDs.
  120. //
  121. // if (nLED++ > 0xf) nLED = 0;
  122. // OEMWriteDebugLED(0, ~nLED);
  123.     
  124. IntPendVal = s2440INT->rINTOFFSET; // Get pending IRQ mode interrupt in INTPND.
  125.     
  126. // Fake CPUEnterIdle needs to know about interrupt firing.
  127. fInterruptFlag = TRUE;
  129.     if (fIntrTime) {
  130.         //
  131.         // We're doing interrupt timing. Get Time to ISR. We subtract TIMER_COUNTDOWN
  132.         // here because the compare register has not been updated.
  133.         //
  134.         dwIsrTime1 = PerfCountSinceTick() - dwReschedIncrement;
  135.         dwSPC = ra;
  136.         wNumInterrupts++;
  137.     }
  139. //
  140. // Check the timer interrupt.
  141. //
  142. if (IntPendVal == INTSRC_TIMER4) 
  143. {
  144. DWORD ttmp;
  146.         if (++HeartBeatCnt > 10)
  147.         {
  148.             HeartBeatCnt   = 0;
  149.             HeartBeatStat ^= 1;
  151.             if (HeartBeatStat)                        
  152.                 s2440IOP->rGPFDAT &= ~(1 << 4); /* LED 0 On                 */
  153.             else
  154.                 s2440IOP->rGPFDAT |=  (1 << 4); /* LED 0 Off                */
  155.         }
  156.                              
  157. s2440PWM->rTCNTB4 = dwReschedIncrement;
  158.                              
  159. ttmp = s2440PWM->rTCON & (~(0xf << 20));
  160.                              
  161. s2440PWM->rTCON = ttmp | (2 << 20); /* update TCVNTB4, stop */
  162. s2440PWM->rTCON = ttmp | (1 << 20); /* one-shot mode,  start */
  163.                              
  164. // Update the tick counter.
  165. //
  166. CurTicks.QuadPart += dwReschedIncrement;
  167.                                      
  168. // Call the profile ISR if it's enabled.
  169. //
  170.         if (PProfileInterrupt)
  171.         {
  172. DWORD dwRetVal = SYSINTR_NOP;
  174. dwRetVal = PProfileInterrupt();
  175.             if (dwRetVal == SYSINTR_RESCHED)
  176. {
  177. // Update the millisecond counter.
  178. //
  179. CurMSec  += RESCHED_PERIOD;
  180. #if (CE_MAJOR_VER == 0x0003)
  181.                 DiffMSec += RESCHED_PERIOD;
  182. #endif
  183.             }
  185. // Clear the interrupt
  186. //
  187. s2440INT->rSRCPND = BIT_TIMER4;        
  188. if (s2440INT->rINTPND & BIT_TIMER4) s2440INT->rINTPND = BIT_TIMER4;
  190.             // Return whatever we got back from the profiling ISR.
  191. //
  192.             return(dwRetVal);
  193.         }
  195. // Update the millisecond counter.
  196. //
  197. #if (CE_MAJOR_VER == 0x0003)
  198. DiffMSec += RESCHED_PERIOD;
  199. #endif
  200. CurMSec  += RESCHED_PERIOD;
  202. //
  203. // Clear the interrupt
  204. //
  205. s2440INT->rSRCPND = BIT_TIMER4;        
  206. if (s2440INT->rINTPND & BIT_TIMER4) s2440INT->rINTPND = BIT_TIMER4;
  207.                              
  208. if (fIntrTime) 
  209. {
  210. //
  211. // We're doing interrupt timing. Every other tick is a RESCHED.
  212. //
  213. dwIntrTimeCountdown--;
  214.                                                                           
  215. if (dwIntrTimeCountdown == 0) 
  216. {
  217. dwIntrTimeCountdown = dwIntrTimeCountdownRef;
  218. wNumInterrupts = 0;
  219.                                                                               
  220. dwIsrTime2 = PerfCountSinceTick();
  221. return (SYSINTR_TIMING);
  222. } else {
  223. #if (CE_MAJOR_VER == 0x0003)
  224. if (ticksleft || (dwSleepMin && (dwSleepMin <= DiffMSec)) || (dwPreempt && (dwPreempt <= DiffMSec)))
  225. #else
  226. if ((int) (CurMSec - dwReschedTime) >= 0)
  227. #endif
  228. return(SYSINTR_RESCHED);
  229. }    
  230. } else {
  231. #if (CE_MAJOR_VER == 0x0003)
  232. if (ticksleft || (dwSleepMin && (DiffMSec >= dwSleepMin)) || (dwPreempt && (DiffMSec >= dwPreempt)))
  233. #else
  234. if ((int) (CurMSec - dwReschedTime) >= 0)
  235. #endif
  236.                              
  237. {
  238. return(SYSINTR_RESCHED);
  239. }
  240. return(SYSINTR_NOP);
  241. }
  242. } 
  244. else if(IntPendVal == INTSRC_MMC) // SD, MMC
  245. {
  246. s2440INT->rINTMSK |= BIT_MMC;
  247.         s2440INT->rSRCPND = BIT_MMC;        
  248.         if (s2440INT->rINTPND & BIT_MMC) s2440INT->rINTPND = BIT_MMC;
  249. // RETAILMSG(1, (TEXT("ARMINT.C-INT:INTSRC_MMC INTrn")));
  250. if( s2440SDIO->rSDIDATSTA & (0x1<<9) ){
  251. // RETAILMSG(1, (TEXT("INT:SYSINTR_SDMMC_SDIO_INTERRUPT INTrn")));
  252. return SYSINTR_SDMMC_SDIO_INTERRUPT;
  253. }
  254. else {
  255. // RETAILMSG(1, (TEXT("INT:SYSINTR_SDMMC INTrn")));
  256. return SYSINTR_SDMMC;
  257. }
  258. }
  259. else if(IntPendVal == INTSRC_DMA0) // SD DMA interrupt
  260. {
  261. s2440INT->rINTMSK |= BIT_DMA0;
  262. s2440INT->rSRCPND = BIT_DMA0;
  263. if (s2440INT->rINTPND & BIT_DMA0) s2440INT->rINTPND = BIT_DMA0;
  264. return SYSINTR_DMA0;
  265. }
  267. else if (IntPendVal == INTSRC_EINT1) // Keyboard interrupt is connected to EINT1.
  268. { 
  269. s2440INT->rINTMSK |= BIT_EINT1;
  270. s2440INT->rSRCPND  = BIT_EINT1;        
  271. if (s2440INT->rINTPND & BIT_EINT1) s2440INT->rINTPND  = BIT_EINT1;
  273. return(SYSINTR_KEYBOARD);
  275. } 
  277. else if (IntPendVal == INTSRC_EINT2) // EINT2
  278. { 
  279. s2440IOP->rGPBCON &= ~(3<<18);
  280. s2440IOP->rGPBCON |=  (1<<18);
  281. s2440IOP->rGPBUP  |=  (1<<9);
  282. s2440IOP->rGPBDAT &= ~(1<<9);
  284. s2440INT->rINTMSK |= BIT_EINT2;
  285. s2440INT->rSRCPND  = BIT_EINT2; /* Interrupt Clear */
  286. if (s2440INT->rINTPND & BIT_EINT2) s2440INT->rINTPND  = BIT_EINT2;
  287. // RETAILMSG(1, (TEXT(">>> CPUPowerReset rn")));
  288. //RETAILMSG(1,(TEXT(">>> >>> Reset Button Pressed <<< <<< rn")));
  289. CPUPowerReset();
  291. return(SYSINTR_POWER);
  292. }
  293. else if (IntPendVal == INTSRC_EINT3) // PCMCIA interrupt is connected to EINT3. (nINT_P_DEV)
  294. { 
  295.     s2440INT->rINTMSK |= BIT_EINT3;
  296.     s2440INT->rSRCPND  =  BIT_EINT3;        
  297.     if (s2440INT->rINTPND & BIT_EINT3) s2440INT->rINTPND = BIT_EINT3;
  298.                            
  299.     return(SYSINTR_PCMCIA_STATE);
  300. }  
  301. else if (IntPendVal == INTSRC_EINT8_23) // EINT8 ~ 23
  302. { 
  304. ///s2440INT->rINTMSK |= BIT_EINT8_23;
  305. ///submask = s2440IOP->rEINTPEND;
  307. DWORD dwSubMask = s2440IOP->rEINTPEND & (~s2440IOP->rEINTMASK);
  309. ///if ( submask & (1 << 9)) // 0x200 EINT9 : CS8900
  310. if ( dwSubMask & (1 << 9)) // 0x200 EINT9 : CS8900
  311. {
  312. s2440IOP->rEINTMASK |= 0x200;
  313. s2440IOP->rEINTPEND = 0x200;
  315. s2440INT->rSRCPND = BIT_EINT8_23;        
  316. if (s2440INT->rINTPND & BIT_EINT8_23) s2440INT->rINTPND = BIT_EINT8_23;
  318. // RETAILMSG(1, (TEXT("INT:SYSINTR_ETHER INT s2440IOP->rEINTMASK = 0x%8x, s2440IOP->rEINTMASKrn")));
  319. // RETAILMSG(1, (TEXT("INT:SYSINTR_ETHER INT s2440IOP->rEINTPEND = 0x%8x, s2440IOP->rEINTPENDrn")));
  320. return SYSINTR_ETHER;
  321. }
  323. #if SDIO_FOR_100BD // for b'd revision 1.00
  324. ///if ( submask & (1 << 18)) // EINT28 : SDMMC_CARD_DETECT
  325. if ( dwSubMask & (1 << 18)) // EINT28 : SDMMC_CARD_DETECT
  326. {
  327. s2440IOP->rEINTMASK |= (1 << 18);
  328. s2440IOP->rEINTPEND  = (1 << 18);
  329. s2440INT->rSRCPND  = BIT_EINT8_23;
  330. if (s2440INT->rINTPND & BIT_EINT8_23) 
  331. s2440INT->rINTPND = BIT_EINT8_23;
  333. // RETAILMSG(1, (TEXT("ARMINT.C - SYSINTR_SDMMC_CARD_DETECT rEINTMASK = 0x%8x, s2440IOP->rEINTMASKrn")));
  334.  RETAILMSG(1, (TEXT("ARMINT.C - SYSINTR_SDMMC_CARD_DETECT rEINTPEND = 0x%8x, s2440IOP->rEINTPENDrn")));
  335. return SYSINTR_SDMMC_CARD_DETECT;
  336. }
  337. #else // for b'd revision 0.17
  338. if ( s2440IOP->rEINTPEND & (1 << 16)) // SD Card Detect
  339. {
  340. s2440IOP->rEINTMASK |= (1 << 16);
  341. s2440IOP->rEINTPEND  = (1 << 16);
  342. s2440INT->rSRCPND  = BIT_EINT8_23;
  343. if (s2440INT->rINTPND & BIT_EINT8_23) 
  344. s2440INT->rINTPND  = BIT_EINT8_23;
  346. return SYSINTR_SDMMC_CARD_DETECT;
  347. }
  348. #endif
  352. //else if (submask & (1 << 8)) // 0x100 EINT8 : PCMCIA_LEVEL
  353. else if (dwSubMask & (1 << 8)) // 0x100 EINT8 : PCMCIA_LEVEL
  354. {
  355. s2440IOP->rEINTMASK |= 0x100;
  356. s2440IOP->rEINTPEND = 0x100;
  358. s2440INT->rSRCPND = BIT_EINT8_23;        
  359. if (s2440INT->rINTPND & BIT_EINT8_23) s2440INT->rINTPND = BIT_EINT8_23;
  361. //RETAILMSG(1, (TEXT("INT:SYSINTR_PCMCIA_LEVEL INTrn")));
  362. return SYSINTR_PCMCIA_LEVEL;
  363. }
  364. else
  365. {
  366. s2440INT->rSRCPND = BIT_EINT8_23;        
  367. if (s2440INT->rINTPND & BIT_EINT8_23) s2440INT->rINTPND = BIT_EINT8_23;
  369. //RETAILMSG(0, (TEXT("INT:???rn")));
  370. //return SYSINTR_NOP;
  371. }
  372. }
  374. else if (IntPendVal == INTSRC_ADC) // INTSRC_ADC
  375. {
  376.         // Touch Panel Int
  377.         SubIntPendVal = s2440INT->rSUBSRCPND;
  378.        
  379.         if(SubIntPendVal & INTSUB_TC) 
  380. {
  381.         s2440INT->rINTSUBMSK |= INTSUB_TC;
  382.         s2440INT->rSUBSRCPND  = INTSUB_TC;
  383.        
  384.             s2440INT->rINTMSK |= BIT_ADC;
  385.             s2440INT->rSRCPND  = BIT_ADC;        
  386.             if (s2440INT->rINTPND & BIT_ADC) s2440INT->rINTPND = BIT_ADC;
  387.            
  388. if( (s2440ADC->rADCDAT0 & 0x8000) || (s2440ADC->rADCDAT1 & 0x8000) )
  389. {
  390. s2440INT->rINTMSK |= BIT_TIMER1;     // Mask timer1 interrupt.
  391.     s2440INT->rSRCPND = BIT_TIMER1;     // Clear pending bit
  392.     if (s2440INT->rINTPND & BIT_TIMER1) s2440INT->rINTPND = BIT_TIMER1;
  393. //RETAILMSG(0,(TEXT("INT Touch pen up rn")));
  395.                odo_tsb->status = TOUCH_PEN_UP;
  396.        }
  397. else
  398. {
  399. //RETAILMSG(0,(TEXT("INT Touch pen down rn")));
  400.                 odo_tsb->status = TOUCH_PEN_DOWN;
  401. }
  402.        
  403.         return SYSINTR_TOUCH_CHANGED;
  404. }
  405.         else if(SubIntPendVal & INTSUB_ADC)
  406. {
  407.         s2440INT->rINTSUBMSK |= INTSUB_ADC;
  408.         s2440INT->rSUBSRCPND = INTSUB_ADC;
  410.         s2440INT->rINTMSK |= BIT_ADC;
  411.         s2440INT->rSRCPND = BIT_ADC;        
  412.         if (s2440INT->rINTPND & BIT_ADC) s2440INT->rINTPND = BIT_ADC;
  413.             
  414.          s2440INT->rINTMSK &= ~BIT_ADC;
  416.             return SYSINTR_NOP;
  417.         }
  418.         else
  419.         return SYSINTR_NOP;
  420. }
  422. else if (IntPendVal == INTSRC_TIMER1) // INTSRC_TIMER1
  423. {
  424.        // Timer 1 interrupt to get touch point
  425.        s2440INT->rINTMSK |= BIT_TIMER1;
  426.         s2440INT->rSRCPND = BIT_TIMER1;
  427.        if (s2440INT->rINTPND & BIT_TIMER1) s2440INT->rINTPND = BIT_TIMER1;
  429. // charlie, 020620
  430. if( (s2440ADC->rADCDAT0 & 0x8000) || (s2440ADC->rADCDAT1 & 0x8000) )
  431. {
  432. //RETAILMSG(0,(TEXT("INT Touch SYSINTR_TOUCH_CHANGED 1rn")));
  433. odo_tsb->status = TOUCH_PEN_UP;
  434. return SYSINTR_TOUCH_CHANGED;
  435. }
  437.         if(odo_tsb->status == TOUCH_PEN_UP) 
  438. {
  439. //RETAILMSG(0,(TEXT("INT Touch SYSINTR_TOUCH_CHANGED 2 rn")));
  440. odo_tsb->status = TOUCH_PEN_UP;
  441. return SYSINTR_TOUCH_CHANGED;
  442. }
  443.         else 
  444. {
  445. unsigned int TmpTCON;
  447.          odo_tsb->status = TOUCH_PEN_SAMPLE;
  448. TmpTCON = s2440PWM->rTCON; // get TCON value to temp TCON register
  449. TmpTCON &= ~0xf00;      // clear fields of Timer 1 
  450. TmpTCON |= 0x200;      // interval mode(auto reload), update TCVNTB4, stop 
  451. s2440PWM->rTCON = TmpTCON; // put the value to TCON register
  453. TmpTCON = s2440PWM->rTCON; // get TCON value to temp TCON register
  454. TmpTCON &= ~0xf00;      // clear fields of Timer 1 
  455. TmpTCON |= 0x100;      // interval mode, no operation, start for Timer 4 
  456. s2440PWM->rTCON = TmpTCON; // put the value to TCON register
  458. //RETAILMSG(0,(TEXT("INT Touch SYSINTR_TOUCHrn")));
  460.          return SYSINTR_TOUCH;
  461. }
  462. }
  464. else if (IntPendVal == INTSRC_EINT0) // POWER BUTTON
  465. { 
  466. s2440INT->rINTMSK |= BIT_EINT0;
  467. s2440INT->rSRCPND  = BIT_EINT0; // Interrupt Clear
  468. if (s2440INT->rINTPND & BIT_EINT0) s2440INT->rINTPND  = BIT_EINT0;
  470. return(SYSINTR_POWER);
  471. }
  473. else if(IntPendVal == INTSRC_DMA1) // AUDIO DMA input.
  474. {  
  475. s2440INT->rINTMSK |= BIT_DMA1;
  476. s2440INT->rSRCPND  = BIT_DMA1;
  477. if (s2440INT->rINTPND & BIT_DMA1) s2440INT->rINTPND  = BIT_DMA1;
  479. return(SYSINTR_AUDIO);
  480. }
  481. else if(IntPendVal == INTSRC_DMA2) // AUDIO DMA output.
  482. {  
  483. s2440INT->rINTMSK |= BIT_DMA2;
  484. s2440INT->rSRCPND  = BIT_DMA2;
  485. if (s2440INT->rINTPND & BIT_DMA2) s2440INT->rINTPND  = BIT_DMA2;
  487. return(SYSINTR_AUDIO);
  488. }
  490. else if(IntPendVal == INTSRC_USBH)  // USB.
  491. {
  492. s2440INT->rINTMSK |= BIT_USBH;
  493. s2440INT->rSRCPND  = BIT_USBH;        
  494. if (s2440INT->rINTPND & BIT_USBH) s2440INT->rINTPND  = BIT_USBH;
  495. //RETAILMSG(1, (TEXT("INT:SYSINTR_USB INTrn")));
  496. return(SYSINTR_USB);     
  497. } 
  499. else if (IntPendVal == INTSRC_DMA3)
  500. {
  501. s2440INT->rINTMSK |= BIT_USBD; // USBD interrupt should be masked
  502. //s2440INT->rINTMSK |= BIT_DMA3;
  503. s2440INT->rSRCPND = BIT_DMA3;
  504. if (s2440INT->rINTPND & BIT_DMA3) s2440INT->rINTPND = BIT_DMA3;
  505. usbdShMem->usbdDma3Int=1;
  506. return SYSINTR_USBD;  
  507. //Correct. DMA3 interrupt will be connected to USBD interrupt.
  508. //break;
  509. }
  511. else if(IntPendVal == INTSRC_USBD) 
  512. {
  513. s2440INT->rINTMSK |= BIT_USBD;
  514. UsbdClearEir();  //:-)
  515. s2440INT->rSRCPND = BIT_USBD;
  516. if (s2440INT->rINTPND & BIT_USBD) s2440INT->rINTPND = BIT_USBD;
  517. RETAILMSG(0,(TEXT("INT_USBDrn")));
  518. return SYSINTR_USBD;
  519.     }
  521. else if(IntPendVal == INTSRC_UART0) // SERIAL (UART0) (physical COM1: P1 connector).
  522. {  
  523. SubIntPendVal = s2440INT->rSUBSRCPND;
  525. // Note that we only mask the sub source interrupt - the serial driver will clear the
  526. // sub source pending register.
  527. //
  528. if(SubIntPendVal & INTSUB_ERR0) 
  529. {
  530. s2440INT->rINTSUBMSK |= INTSUB_ERR0;
  531. }
  532. else if(SubIntPendVal & INTSUB_RXD0) 
  533. {
  534. s2440INT->rINTSUBMSK |= INTSUB_RXD0;
  535. #if USE_AFC
  536. // by 0212.
  537. s2440IOP->rGPHDAT |= (0x2);  // Deassert nRTS
  538. #endif
  539. }
  540. else if(SubIntPendVal & INTSUB_TXD0) 
  541. {
  542. s2440INT->rINTSUBMSK |= INTSUB_TXD0;
  543. }
  544. else
  545. {
  546. return(SYSINTR_NOP);
  547. }
  549. // NOTE: Don't clear INTSRC:UART0 here - serial driver does that.
  550. //
  551. s2440INT->rINTMSK |= BIT_UART0;
  552. if (s2440INT->rINTPND & BIT_UART0) s2440INT->rINTPND  = BIT_UART0;
  554. return(SYSINTR_SERIAL);
  555. }
  556. else if(IntPendVal == INTSRC_UART2) // IrDA (UART2)
  557. {
  558. SubIntPendVal = s2440INT->rSUBSRCPND;
  560. if(SubIntPendVal & INTSUB_ERR2) 
  561. {
  562. s2440INT->rINTSUBMSK |= INTSUB_ERR2;
  563. }       
  564. else if(SubIntPendVal & INTSUB_RXD2) 
  565. {
  566. s2440INT->rINTSUBMSK |= INTSUB_RXD2;
  567. }       
  568. else if(SubIntPendVal & INTSUB_TXD2) 
  569. {
  570. s2440INT->rINTSUBMSK |= INTSUB_TXD2;
  571. }       
  572. else
  573. {
  574. return(SYSINTR_NOP);
  575. }
  577. // NOTE: Don't clear INTSRC:UART2 here - serial driver does that.
  578. //
  579. s2440INT->rINTMSK |= BIT_UART2;
  580. if (s2440INT->rINTPND & BIT_UART2) s2440INT->rINTPND  = BIT_UART2;
  582. return(SYSINTR_IR);
  583. }
  584. else if (IntPendVal == INTSRC_RTC) // for alarm. 030818
  585. { 
  586. s2440INT->rSRCPND  = BIT_RTC;   // Interrupt Clear
  587. s2440INT->rINTPND  = BIT_RTC;
  588. s2440INT->rINTMSK |= BIT_RTC;   // Alarm Interrupt Disable
  589. return SYSINTR_RTC_ALARM;
  590. }
  591. else if(IntPendVal == INTSRC_CAM) 
  592. {
  593. // RETAILMSG(1,(TEXT("INT:SYSINTR_CAM INT:0x%x,0x%xrn"),s2440INT->rSRCPND,s2440INT->rSUBSRCPND));
  595. if( s2440INT->rSUBSRCPND & (0x1<<11) )
  596. {
  597. s2440INT->rINTSUBMSK |= (0x1<<11);
  598. s2440INT->rINTMSK |= BIT_CAM;
  599. s2440INT->rSUBSRCPND = (0x1<<11);
  600. s2440INT->rSRCPND = BIT_CAM;
  602. if (s2440INT->rINTPND & BIT_CAM) s2440INT->rINTPND = BIT_CAM;
  603. return SYSINTR_CAM;
  604. }
  605. else if (s2440INT->rSUBSRCPND & BIT_SUB_CAM_P)
  606. {
  607. s2440INT->rINTSUBMSK |= (0x2<<11);
  608. s2440INT->rINTMSK |= BIT_CAM;
  609. s2440INT->rSUBSRCPND = (0x2<<11);
  610. s2440INT->rSRCPND = BIT_CAM;
  612. if (s2440INT->rINTPND & BIT_CAM) s2440INT->rINTPND = BIT_CAM;
  614. return SYSINTR_CAM;
  615. }
  617. s2440INT->rINTSUBMSK |= (BIT_SUB_CAM_C | BIT_SUB_CAM_P);
  618. s2440INT->rINTMSK |= BIT_CAM;
  619. s2440INT->rSUBSRCPND = (BIT_SUB_CAM_C | BIT_SUB_CAM_P);
  620. s2440INT->rSRCPND = BIT_CAM;
  622. if (s2440INT->rINTPND & BIT_CAM)
  623. {
  624. s2440INT->rINTPND = BIT_CAM;
  625. }
  627. return SYSINTR_NOP;
  628. }
  629. else if(IntPendVal == INTSRC_IIC) 
  630. {
  631. s2440INT->rINTMSK |= BIT_IIC;
  632. s2440INT->rSRCPND = BIT_IIC;
  633. if (s2440INT->rINTPND & BIT_IIC) s2440INT->rINTPND = BIT_IIC;
  634. // RETAILMSG(1,(TEXT("IIC Interruptrn")));
  635. return SYSINTR_IIC;
  636. }
  638. return(SYSINTR_NOP);
  639. }
  641. void UsbdClearEir(void)
  642. {
  643. static volatile struct udcreg *s2440USBD = (volatile struct udcreg *)(0xB1200140);
  645. usbdShMem->usbdEir|=*(volatile BYTE *)&s2440USBD->EIR;
  646. usbdShMem->usbdUir|=*(volatile BYTE *)&s2440USBD->UIR;
  647. *(volatile BYTE *)&s2440USBD->EIR=usbdShMem->usbdEir;
  648. *(volatile BYTE *)&s2440USBD->UIR=usbdShMem->usbdUir;
  650. }