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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
Uart0.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：32k
源码类别：

uCOS

开发平台：

C/C++

Uart0.c：源码内容
  1. //====================================================================
  2. // File Name : uart0.c
  3. // Function  : S3C2440 UART-0 test code
  4. // Program   : Shin, On Pil (SOP)
  5. // Date      : May 30, 2002
  6. // Version   : 0.0
  7. // History
  8. // -2410
  9. //   0.0 : Programming start (February 20,2002) -> SOP
  10. //   1.0 (20020530) : First release for customer
  11. //   1.1 (20020801) : Strata NOR Flash Added and etc. -> SOP
  12. // -2440
  13. //   R0.0 (20030421): Modified for 2440. -> Junon
  14. //====================================================================
  16. #include <string.h>
  17. #include <stdlib.h>
  18. #include "def.h"
  19. #include "2440addr.h"
  20. #include "2440lib.h"
  21. #include "uart0.h"
  23. void Uart_Port_Set(void);
  24. void Uart_Port_Return(void);
  26. void __irq Uart0_TxInt(void);
  27. void __irq Uart0_RxIntOrErr(void);
  28. void __irq Uart0_TxDmaDone(void);
  29. void __irq Uart0_RxDmaDone(void);
  30. void __irq Uart0_RxDmaOrErr(void);
  31. void __irq Uart0_TxFifo(void);
  32. void __irq Uart0_RxFifoOrErr(void);
  33. void __irq Uart0_AfcTx(void);
  34. void __irq Uart0_AfcRxOrErr(void);
  35. void __irq Uart0_RxOverrunErr(void);
  37. void __sub_Uart0_RxInt(void);
  38. void __sub_Uart0_RxFifo(void);
  39. void __sub_Uart0_RxAfc(void);
  40. void __sub_Uart0_RxErrInt(void);
  42. void Uart_Fclkn_Dis(void); // for 2440A
  45. volatile U16 rx_dncs;
  46. volatile U32 rx_point,rx_isdone,rx_filesize,rx_checksum;
  47. volatile U32 isDone,isTxInt,isRxInt,tx_cnt,tx_end,rx_cnt,rx_end,afc_err;
  48. volatile U8 *txdataPt;
  49. volatile U8 *txdataFl;
  50. volatile U8 *rxdataPt;
  51. volatile U8 *rxdataCk;
  52. volatile U32 *dbg_data;
  53. U8 temp_exit;
  56. volatile U32 save_rGPHCON,save_rGPHDAT,save_rGPHUP;
  57. volatile U32 save_ULCON0,save_UCON0,save_UFCON0,save_UMCON0,save_UBRDIV0;
  58. volatile U32 save_ULCON1,save_UCON1,save_UFCON1,save_UMCON1,save_UBRDIV1;
  59. volatile U32 save_ULCON2,save_UCON2,save_UFCON2,save_UMCON2,save_UBRDIV2;
  61. volatile static char *uart0TxStr;
  62. volatile static char *uart0RxStr;
  64. volatile static char *uart2TxStr;
  65. volatile static char *uart2RxStr;
  67. extern U32 Fclk, Pclk;
  70. void Uart_Port_Set(void)
  71. {
  72.     //Push UART GPIO port configuration
  73.     save_rGPHCON=rGPHCON; 
  74.     save_rGPHDAT=rGPHDAT;
  75.     save_rGPHUP=rGPHUP;
  76.     //Configure UART port
  77.     rGPHCON&=0x3c0000;
  78.     rGPHCON|=0x2aaaa; // enable all uart channel
  79.     rGPHUP|=0x1ff; //Uart port pull-up disable
  80. rGPGCON|=(0xf<<18); // nRTS1, nCTS1
  81. rGPGUP|=(0x3<<9);
  82.     //rINTSUBMSK=0x7ff;   //SUBINT ALL MASK
  83.     //Push Uart control registers 
  84.     save_ULCON0=rULCON0;   
  85.     save_UCON0=rUCON0;    
  86.     save_UFCON0=rUFCON0;   
  87.     save_UMCON0=rUMCON0;   
  88.     save_ULCON1=rULCON1;
  89.     save_UCON1 =rUCON1;
  90.     save_UFCON1=rUFCON1;
  91.     save_UMCON1=rUMCON1;
  92.     save_ULCON2=rULCON2;
  93.     save_UCON2 =rUCON2;
  94.     save_UFCON2=rUFCON2;
  95.     save_UMCON2=rUMCON2;
  96. save_UBRDIV0=rUBRDIV0;
  97. save_UBRDIV1=rUBRDIV1;
  98. save_UBRDIV2=rUBRDIV2;
  99.     //Initialize UART1,2 port
  100. }       
  101.         
  102. void Uart_Port_Return(void)
  103. {       
  104.     //Pop UART GPIO port configuration
  105.     rGPHCON=save_rGPHCON;
  106.     rGPHDAT=save_rGPHDAT;
  107.     rGPHUP=save_rGPHUP;
  108.     //Pop Uart control registers 
  109.     rULCON0=save_ULCON0;   
  110.     rUCON0 =save_UCON0;   
  111.     rUFCON0=save_UFCON0;   
  112.     rUMCON0=save_UMCON0;   
  113.     rULCON1=save_ULCON1;
  114.     rUCON1 =save_UCON1;
  115.     rUFCON1=save_UFCON1;
  116.     rUMCON1=save_UMCON1;
  117.     rULCON2=save_ULCON2;
  118.     rUCON2 =save_UCON2;
  119.     rUFCON2=save_UFCON2;
  120.     rUMCON2=save_UMCON2;
  121. rUBRDIV0=save_UBRDIV0;
  122. rUBRDIV1=save_UBRDIV1;
  123. rUBRDIV2=save_UBRDIV2;
  124. Uart_Fclkn_Dis();
  125. }
  127. // 2440X usage enable
  128. void Uart_Uextclk_En(int ch,int baud, int clock)
  129. {
  130.     if(ch == 0) {
  131.     rUCON0  = rUCON0 & ~(1<<11) |(1<<10); // Select UEXTCLK
  132.       rUBRDIV0=( (int)(clock/16./baud) -1 ); //Baud rate divisior register
  133.     }
  134.     else if(ch==1){
  135.     rUCON1  = rUCON1 & ~(1<<11) |(1<<10); // Select UEXTCLK
  136.      rUBRDIV1=( (int)(clock/16./baud) -1 ); //Baud rate divisior register
  137.     }
  138.     else {
  139.     rUCON2  = rUCON2 & ~(1<<11) |(1<<10); // Select UEXTCLK
  140.        rUBRDIV2=( (int)(clock/16./baud) -1 ); //Baud rate divisior register
  141.     }
  142. }
  144. //2440X usage enable
  145. void Uart_Pclk_En(int ch, int baud)
  146. {
  147.     if(ch == 0) {
  148.      rUCON0 &= ~(3<<10); // Select PCLK
  149. rUBRDIV0=( (int)(Pclk/16./baud+0.5) -1 ); //Baud rate divisior register
  150.    }
  151.     else if(ch==1){
  152.      rUCON1 &= ~(3<<10); // Select PCLK
  153. rUBRDIV1=( (int)(Pclk/16./baud+0.5) -1 ); //Baud rate divisior register
  154.    }
  155.     else {
  156.      rUCON2 &= ~(3<<10); // Select PCLK
  157.     rUBRDIV2=( (int)(Pclk/16./baud+0.5) -1 ); //Baud rate divisior register
  158.    }
  159. }
  161. void Uart_Fclkn_En(int ch, int baud) // for 2440A
  162. {
  163. int clock = PCLK;//Pclk;
  165. Uart_Printf("Current FCLK is %dn", Fclk);
  166. #if 1
  167. // input clock divider setting.
  168. if ( (Fclk>290000000) && (Fclk<300000000) ) // for 296MHz
  169. {
  170. rUCON0 = (rUCON0 & ~(0xf<<12)) | (0xe<<12);  // FCLK divider 14(n=20), for max 921.6kbps
  171. rUCON1 &= ~(0xf<<12); // 0 setting
  172. rUCON2 &= ~(0xf<<12); // 0 setting
  173. clock = Fclk / 20;
  174. Uart_Printf("1 : %dn", clock);
  175. }
  176. else if ( (Fclk>395000000) && (Fclk<405000000) ) // for 399MHz
  177. {
  178. rUCON1 = (rUCON1 & ~(0xf<<12)) | (0x6<<12);  // FCLK divider 6(n=27), for max 921.6kbps
  179. rUCON0 &= ~(0xf<<12); // 0 setting
  180. rUCON2 &= ~(0xf<<12); // 0 setting
  181. clock = Fclk / 27;
  182. Uart_Printf("2 : %dn", clock);
  183. }
  184. else if ( (Fclk>525000000) && (Fclk<535000000) ) // for 530MHz
  185. {
  186. rUCON1 |= (0xf<<12);  // FCLK divider 15(n=36), for max. 921.6kbps
  187. rUCON0 &= ~(0xf<<12); // 0 setting
  188. rUCON2 &= ~(0xf<<12); // 0 setting
  189. clock = Fclk / 36;
  190. Uart_Printf("3 : %dn", clock);
  191. }
  192. rUCON2 |= (1<<15); // enable FCLK/n
  193. #else
  194. // In 921.6kbps case of following code, Fclk must be 296352000
  195. rUCON0 = rUCON0 & ~(0xf<<12) | (0xe<<12);  // FCLK divider 14(n=20), for max 921.6kbps
  196. rUCON1 &= ~(0xf<<12); // 0 setting
  197. rUCON2 &= ~(0xf<<12); // 0 setting
  198. clock = Fclk / 20;
  199. rUCON2 |= (1<<15); // enable FCLK/n
  200. #endif 
  202. // select buadrate.
  203.     if(ch == 0) {
  204.      rUCON0 |= (3<<10); // Select FCLK/n
  205. rUBRDIV0=( (int)(clock/16./baud+0.5) -1 ); //Baud rate divisior register
  206.    }
  207.     else if(ch==1){
  208.      rUCON1 |= (3<<10); // Select FCLK/n
  209. rUBRDIV1=( (int)(clock/16./baud+0.5) -1 ); //Baud rate divisior register
  210.    }
  211.     else {
  212.      rUCON2 |= (3<<10); // Select FCLK/n
  213.     rUBRDIV2=( (int)(clock/16./baud+0.5) -1 ); //Baud rate divisior register
  214.    }
  216. // S/W work-around for using FCLK/n
  217. rGPHCON = rGPHCON & ~(3<<16); //GPH8(UEXTCLK) input 
  218. Delay(1);
  219. rGPHCON = rGPHCON & ~(3<<16) | (1<<17); //GPH8(UEXTCLK) UEXTCLK
  220. }
  222. void Uart_Fclkn_Dis(void) // for 2440A
  223. {
  224. // S/W work-around for using FCLK/n
  225. rGPHCON = rGPHCON & ~(3<<16); //GPH8(UEXTCLK) input 
  226. Delay(1);
  227. rGPHCON = rGPHCON & ~(3<<16) | (1<<17); //GPH8(UEXTCLK) UEXTCLK
  228. }
  230. //---------------------------------------UART0 test function-------------------------------------
  231. void __irq Uart0_TxInt(void)
  232. {
  233.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0); // Just for the safety
  234.     if(*uart0TxStr != '') 
  235.     {
  236.         WrUTXH0(*uart0TxStr++);
  237.     ClearPending(BIT_UART0); // Clear master pending
  238.     rSUBSRCPND=(BIT_SUB_TXD0); // Clear Sub int pending
  239.     rINTSUBMSK&=~(BIT_SUB_TXD0); // Unmask sub int
  240.     }
  241.     else
  242.     {
  243.      isTxInt=0;
  244.      ClearPending(BIT_UART0); // Clear master pending
  245.         rSUBSRCPND=(BIT_SUB_TXD0); // Clear Sub int pending
  246.         rINTMSK|=(BIT_UART0);
  247.     }
  248. }
  250. void __irq Uart0_RxIntOrErr(void)
  251. {
  252.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  253.     if(rSUBSRCPND&BIT_SUB_RXD0) __sub_Uart0_RxInt();
  254.     else __sub_Uart0_RxErrInt();
  255.     ClearPending(BIT_UART0); 
  256.     rSUBSRCPND=(BIT_SUB_RXD0|BIT_SUB_ERR0); // Clear Sub int pending    
  257.     rINTSUBMSK&=~(BIT_SUB_RXD0|BIT_SUB_ERR0);    
  258. }
  260. void __sub_Uart0_RxInt(void)
  261. {
  262.     if(RdURXH0()!='r') 
  263.     {
  264.      Uart_Printf("%c",RdURXH0());
  265.      *uart0RxStr++ =(char)RdURXH0();
  266.     }
  267.     else
  268.     {
  269.      isRxInt=0;
  270.      *uart0RxStr='';
  271.      Uart_Printf("n");
  272.     }
  273. }
  275. void __sub_Uart0_RxErrInt(void)
  276. {
  277. U32 iStatus;
  279. iStatus = rUERSTAT0;
  281.     switch(iStatus)//to clear and check the status of register bits
  282.     {
  283. case 1:
  284.     Uart_Printf("Overrun error!n");
  285.     break;
  286. case 2:
  287.     Uart_Printf("Parity error!n");
  288.     break;
  289. case 4:
  290.     Uart_Printf("Frame error!n");
  291.     break;
  292. case 6:
  293.     Uart_Printf("Parity, Frame error!n");
  294.     break;
  295. case 8:
  296. Uart_Printf("Breake detectn");
  297. break;
  298. case 0xa:
  299. Uart_Printf("Parity error & Break detect!n");
  300. break;
  301. case 0xc:
  302. Uart_Printf("Frame error & Breake detectn");
  303. break;
  304. case 0xe:
  305. Uart_Printf("Parity, Frame error & Break detect!n");
  306. break;
  307. default :
  308. Uart_Printf("Unknown error : 0x%xn", iStatus);
  309.     break;
  310.     }
  312.     isRxInt=0;
  313. }
  316. void Test_Uart0_Int(void)
  317. {
  318. U8 ch;
  319. int iBaud;
  321.     Uart_Port_Set(); 
  323.     Uart_Select(1);    
  324.     Uart_Printf("nConnect PC[COM1 or COM2] and UART0 of SMDK2440 with a serial cable!!! n");
  325.     Uart_Printf("Then, press any key........n");
  326.     Uart_Select(0);
  327.     Uart_Getch();
  329. /******** For operating clock test *********/
  330. Uart_Printf("[Uart channel 0 Interrupt test]n");
  331. Uart_Printf("Select operating clock 1. PCLK(D)    2. UCLK     3. FCLK/n  nChoose : ");
  332. ch = Uart_Getch();
  333. switch (ch)
  334. {
  335. case '2' :
  336. rMISCCR = rMISCCR & ~(7<<8) | (1<<10); // CLKOUT1 = PCLK
  337. Uart_Uextclk_En(0, 115200, Pclk);
  338. break;
  339. case '3' :
  340. Uart_Printf("Type the baudrate and then change the same baudrate of host, too.n");
  341.  Uart_Printf("Baudrate (ex 9600, 115200[D], 921600) : ");
  342. iBaud = Uart_GetIntNum();
  343. if (iBaud == -1) iBaud = 115200;
  344. Uart_Fclkn_En(0, iBaud);
  345. Uart_Getch();
  346. break;
  347. default :
  348. Uart_Pclk_En(0, 115200);
  349. }
  351. #if 0       
  352. /******** Select UART or IrDA *********/
  353. Uart_Printf("Select 1. UART(D) or  2. IrDA modenChoose : ");
  354. if (Uart_Getch() == '2')
  355. rULCON0 |= (1<<6); // IrDA mode
  356. else
  357. rULCON0 &= ~(1<<6); // UART mode
  358. #endif
  360. /*********** UART0 Tx test with interrupt ***********/  
  361.     isTxInt=1;
  362.     uart0TxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890->UART0 Tx interrupt test is good!!!!rn";
  363.     Uart_Printf("[Uart channel 0 Tx Interrupt Test]n");
  365.     pISR_UART0=(unsigned)Uart0_TxInt;
  367.     rULCON0=(0<<6)|(0<<3)|(0<<2)|(3); // Normal,No parity,One stop bit, 8bit
  368.     rUCON0 |= (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(0<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
  369.     //Clock,Tx:Def,Rx:Def,Rx timeout:x,Rx error int:x,Loop-back:x,Send break:x,Tx:int,Rx:int
  370.     Uart_TxEmpty(1); //wait until tx buffer is empty.
  371.     rINTMSK=~(BIT_UART0);
  372.     rINTSUBMSK=~(BIT_SUB_TXD0);
  374.     while(isTxInt);
  375.     
  376.     /*********** UART0 Rx test with interrupt ***********/
  377.     isRxInt=1;
  378.     uart0RxStr=(char *)UARTBUFFER;
  379.     Uart_Printf("n[Uart channel 0 Rx Interrupt Test]:n");
  380.     Uart_Printf("After typing characters and ENTER key  you will see the characters which was typed by you.");
  381.     Uart_Printf("nTo quit, press ENTER key.!!!n");
  383.     Uart_TxEmpty(1); //wait until tx buffer is empty.
  384.     pISR_UART0 =(unsigned)Uart0_RxIntOrErr;
  385.     rULCON0=(0<<6)|(0<<3)|(0<<2)|(3); // Normal,No parity,One stop bit, 8bit
  386.     rUCON0 |= (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(1<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
  387.     //Clock,Tx:pulse,Rx:pulse,Rx timeout:x,Rx error int:o,Loop-back:x,Send break:x,Tx:int,Rx:int
  389.     // Clear Int Pending and Unmask    
  390.     ClearPending(BIT_UART0);
  391.     rINTMSK=~(BIT_UART0);
  392.     rSUBSRCPND=(BIT_SUB_TXD0|BIT_SUB_RXD0|BIT_SUB_ERR0);    
  393.     rINTSUBMSK=~(BIT_SUB_RXD0|BIT_SUB_ERR0);
  394.     
  395.     while(isRxInt);
  396.     
  397.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_ERR0);
  398.     rINTMSK|=(BIT_UART0);
  399.  
  400.     Uart_Printf("%sn",(char *)UARTBUFFER);
  402.      Uart_Printf("nConnect PC[COM1 or COM2] and UART1 of SMDK2440 with a serial cable!!! n");
  403.     Uart_Printf("Then, press any key........n");
  404.    
  405.     Uart_Select(1);
  406.     Uart_Getch();
  408.     Uart_Port_Return();
  409. }
  412. void __irq Uart0_TxDmaDone(void)
  413. {
  414.     rDMASKTRIG0=0x0; // Stop Dma0
  415.     isDone=0;
  416.     rINTMSK |= BIT_DMA0;
  417.     ClearPending(BIT_DMA0);
  418. }
  420. void __irq Uart0_RxDmaOrErr(void)
  421. {
  422.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  423.     if(rSUBSRCPND&BIT_SUB_ERR0)  __sub_Uart0_RxErrInt();
  424.     
  425.     ClearPending(BIT_UART0);
  426.     rSUBSRCPND=(BIT_SUB_ERR0); // Clear Sub int pending    
  427.     rINTSUBMSK&=~(BIT_SUB_ERR0);    
  428. }
  430. void __irq Uart0_RxDmaDone(void)
  431. {
  432.     rDMASKTRIG0=0x0; //DMA0 Channel Off
  433.     isDone=0;
  434.     *(uart0RxStr+5)='';
  435.     rINTMSK|=(BIT_DMA0);
  436.     ClearPending(BIT_DMA0);
  437. }
  439. void Test_Uart0_Dma(void)
  440. {
  441.     Uart_Port_Set(); 
  442.     Uart_Select(1);    
  443.     /*********** UART0 Tx test with DMA0 ***********/ 
  444.     isDone=1;
  445.     uart0TxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890->UART0 Tx Test by DMA0 is good!!!!rn";
  446.     Uart_Printf("n[Uart channel 0 DMA0 Tx Test]n");
  447.     Uart_TxEmpty(1);
  449.     Uart_Printf("nConnect PC[COM1 or COM2] and UART0 of SMDK2440 with a serial cable!!! n");
  450.     Uart_Printf("Then, press any key........n");
  451.    
  452.     Uart_Select(0);
  453.     Uart_Getch();
  455.    
  456.     pISR_DMA0  =(unsigned)Uart0_TxDmaDone;
  458.     rULCON0=(0<<6)|(0<<3)|(0<<2)|(3); // Normal,No parity,One stop bit, 8bit
  459.     rUCON0 = (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(0<<6)|(0<<5)|(0<<4)|(2<<2)|(0);
  460.     //Clock,Tx:Def,Rx:Def,Rx timeout:x,Rx error int:x,Loop-back:x,Send break:x,Tx:dma0,Rx:x
  462.     /***DMA0 init***/
  463.     rDISRC0=(U32)uart0TxStr; // Start address
  464.     rDISRCC0=(0<<1)|(0); // AHB,Increment
  465.     rDIDST0=(U32)UTXH0; // Memory buffer Address
  466.     rDIDSTC0=(1<<1)|(1); // APB,Fixed
  467.     rDCON0=(1<<31)|(0<<30)|(1<<29)|(0<<28)|(0<<27)|(1<<24)|(1<<23)|(1<<22)|(0<<20)|strlen((char*)uart0TxStr);
  468.     //handshake, sync PCLK, TC int, single tx, single service, Uart0, H/W request,auto-reload off, Byte size Tx, Tx count value
  469.     rINTMSK=~(BIT_DMA0);
  470.     rDMASKTRIG0=(0<<2)|(1<<1)|(0);    //no-stop, DMA0 channel on, no-SW trigger 
  472.     while(isDone);
  474.     /*********** UART0 Rx test with DMA0 ***********/ 
  475.     isDone=1;
  476.     uart0RxStr=(char *)UARTBUFFER;
  477.    
  478.     Uart_Printf("n[Uart channel 0 DMA0 Rx Test]n");
  479.     Uart_Printf("Type any five keys!!!n");    
  480.     Uart_Printf("Then you will see what you typed.n");
  482.     pISR_DMA0=(unsigned)Uart0_RxDmaDone;
  483.     pISR_UART0=(unsigned)Uart0_RxDmaOrErr;
  485.     
  486.     rULCON0=(0<<6)|(0<<3)|(0<<2)|(3); // Normal,No parity,One stop bit, 8bit
  487.     rUCON0 &= 0x400; // For the PCLK <-> UCLK fuction  
  488.     rUCON0 |= (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(1<<6)|(0<<5)|(0<<4)|(1<<2)|(2);
  489.     //Clock,Tx:Def,Rx:Def,Rx timeout:x,Rx error int:o,Loop-back:x,Send break:x,Tx:int,Rx:dma0
  491.     
  492.     /***DMA0 init***/
  493.     rDISRC0=(U32)URXH0; // Start address
  494.     rDISRCC0=(1<<1)|(1); // APB,Fixed
  495.     rDIDST0=(U32)uart0RxStr;         // Memory buffer Address
  496.     rDIDSTC0= (0<<1)|(0); // AHB,Increment
  497.     rDCON0=(1<<31)|(0<<30)|(1<<29)|(0<<28)|(0<<27)|(1<<24)|(1<<23)|(1<<22)|(0<<20)|(5);
  498.     //handshake, sync PCLK, TC int, single tx, single service, Uart0, H/W request,auto-reload off, Byte size Tx, Tx count value
  500.     // Clear Int Pending and Unmask    
  501.     ClearPending(BIT_UART0);
  502.     rINTMSK=~(BIT_DMA0|BIT_UART0);
  503.     rSUBSRCPND=(BIT_SUB_TXD0|BIT_SUB_RXD0|BIT_SUB_ERR0);        
  504.     rINTSUBMSK=~(BIT_SUB_ERR0);
  505.     rDMASKTRIG0=(0<<2)|(1<<1)|(0);    //no-stop, DMA0 channel on, no-SW trigger 
  507.     while(isDone);
  509.     Uart_Printf("%sn",uart0RxStr);
  511.      Uart_Printf("nConnect PC[COM1 or COM2] and UART1 of SMDK2440 with a serial cable!!! n");
  512.     Uart_Printf("Then, press any key........n");
  513.    
  514.     Uart_Select(1);
  515.     Uart_Getch();
  517.     Uart_Port_Return();
  518. }
  520. volatile U32 *fifo_cnt; //temporary for fifo count test
  521. volatile U32 fcnt = 0;
  523. void __irq Uart0_TxFifo(void)
  524. {
  525.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0); // Just for the safety
  526. rINTMSK|=BIT_UART0;
  527. rSUBSRCPND=BIT_SUB_TXD0; // Clear Sub int pending
  528. ClearPending(BIT_UART0); // Clear master pending
  530. *fifo_cnt++ = ++fcnt;
  531. *fifo_cnt++ = rUFCON0;
  532. *fifo_cnt++ = (rUFSTAT0>>8)&0x3f;
  533. *fifo_cnt = 0;
  535.     while (!(rUFSTAT0 & 0x4000) && (*uart0TxStr != ''))  //until tx fifo full or end of string
  536.      WrUTXH0(*uart0TxStr++);
  538.     if(*uart0TxStr != '') 
  539.     {
  540.         rINTSUBMSK&=~(BIT_SUB_TXD0); // Unmask sub int
  541.         rINTMSK&=~(BIT_UART0);
  542.     }
  543. }
  545. void __irq Uart0_RxFifoOrErr(void)
  546. {
  547.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  548.     if(rSUBSRCPND&BIT_SUB_RXD0) __sub_Uart0_RxFifo();
  549.     else __sub_Uart0_RxErrInt();
  550.     ClearPending(BIT_UART0);
  551.     rSUBSRCPND=(BIT_SUB_RXD0|BIT_SUB_ERR0); // Clear Sub int pending    
  552.     rINTSUBMSK&=~(BIT_SUB_RXD0|BIT_SUB_ERR0);    
  553. }
  555. void __sub_Uart0_RxFifo(void)
  556. {
  557.     while(rUFSTAT0&0x7f) //During the Rx FIFO is not empty
  558.     {
  559. rx_point++;
  560. if(rx_point<5)
  561. rx_filesize |= (RdURXH0()<<(8*(rx_point-1))); // First 4-bytes mean file size
  562. else if(rx_point>(rx_filesize-2))
  563. {
  564. rx_dncs |= (RdURXH0()<<(8*(1-(rx_filesize-rx_point)))); //Last 2-bytes mean checksum.
  565. if(rx_point==rx_filesize) rx_isdone=0;
  566. }
  567. else
  568. rx_checksum+=RdURXH0();
  569.     }
  570. }
  572. void Test_Uart0_Fifo(void)
  573. {
  574. int i;
  576.     Uart_Port_Set(); 
  577.     Uart_Select(1);
  578.     /******* UART0 Tx FIFO test with interrupt ********/     
  579.     Uart_Printf("[Uart channel 0 Tx FIFO Interrupt Test]n");
  580.     Uart_TxEmpty(1); //wait until tx buffer is empty.
  582.     Uart_Printf("nConnect PC[COM1 or COM2] and UART0 of SMDK2440 with a serial cable!!! n");
  583.     Uart_Printf("Then, press any key........n");
  584.    
  585.     Uart_Select(0);
  586.     Uart_Getch();
  588. fifo_cnt = (U32 *)_NONCACHE_STARTADDRESS; // temporary buffer
  590.     /* <Tx Trigger Level:empty> */    
  591.     uart0TxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ->UART0 Tx FIFO interrupt(TL 48byte) test is good!!!!rn";
  592.     pISR_UART0=(U32)Uart0_TxFifo;
  593.     rULCON0=(0<<6)|(0<<3)|(0<<2)|(3); // Normal,No parity,One stop bit, 8bit
  594.     rUCON0 &= 0x400; // For the PCLK <-> UCLK fuction    
  595.     rUCON0 |= (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(0<<6)|(0<<5)|(0<<4)|(1<<2)|(0);
  596.     //Clock,Tx:Def,Rx:Def,Rx timeout:x,Rx error int:x,Loop-back:x,Send break:x,Tx:int,Rx:x
  597.     rUFCON0=(3<<6)|(2<<4)|(1<<2)|(1<<1)|(1);
  598.     //Tx and Rx FIFO Trigger Level:8byte,Tx and Rx FIFO Reset,FIFO on
  599.     rINTMSK=~(BIT_UART0);
  600.     rINTSUBMSK=~(BIT_SUB_TXD0);
  601.     Delay(500);
  602. rUFCON0=(3<<6)|(2<<4)|(1<<2)|(1<<1)|(0);
  604. // edited by junon
  605. /* <Tx Trigger Level:16Byte> */   
  606. rUFCON0=(2<<6)|(2<<4)|(1<<2)|(1<<1)|(1);
  607. uart0TxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ->UART0 Tx FIFO interrupt(TL 32byte) test is good!!!!rn";
  608. rINTMSK=~(BIT_UART0);
  609. rINTSUBMSK=~(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  610. Delay(500);
  612. /* <Tx Trigger Level:32Byte> */   
  613. rUFCON0=(1<<6)|(2<<4)|(1<<2)|(1<<1)|(1);
  614. uart0TxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ->UART0 Tx FIFO interrupt(TL 16byte) test is good!!!!rn";
  615. rINTMSK=~(BIT_UART0);
  616. rINTSUBMSK=~(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  617. Delay(500);
  619. /* <Tx Trigger Level:48Byte> */   
  620. rUFCON0=(0<<6)|(2<<4)|(1<<2)|(1<<1)|(1);
  621. uart0TxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ->UART0 Tx FIFO interrupt(TL 0byte) test is good!!!!rn";
  622. rINTMSK=~(BIT_UART0);
  623. rINTSUBMSK=~(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  624. Delay(500);
  625. rUFCON0=(0<<6)|(2<<4)|(1<<2)|(1<<1)|(0);
  626. //Tx and Rx FIFO Trigger Level:48byte,Tx and Rx FIFO Reset,FIFO off
  628. Uart_Printf("Saved FIFO current count in ISR!! Interrupt count : %dn",fcnt);
  629. fifo_cnt = (U32 *)_NONCACHE_STARTADDRESS;
  630. while(*fifo_cnt)
  631. Uart_Printf("[0x%x,%d,0x%x,%d] ", fifo_cnt, *fifo_cnt++, *fifo_cnt++,*fifo_cnt++);
  632. fcnt = 0;
  634.     /******* UART0 Rx FIFO test with interrupt ********/     
  635.     rx_dncs=0;
  636.     rx_point=0;
  637.     rx_isdone=1;
  638.     rx_filesize=0;
  639.     rx_checksum=0;
  640.     Uart_Printf("[Uart channel 0 Rx FIFO Interrupt Test]n");
  641. //----------------------------------------------------
  642.     pISR_UART0=(unsigned)Uart0_RxFifoOrErr;
  644.     rULCON0=(0<<6)|(0<<3)|(0<<2)|(3); // Normal,No parity,One stop bit, 8bit
  645.     rUCON0 &= 0x400; // For the PCLK <-> UCLK fuction
  646.     rUCON0 |= (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(1<<7)|(1<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
  647.     //Clock,Tx:Def,Rx:Def,Rx timeout:o,Rx error int:o,Loop-back:x,Send break:x,Tx:int,Rx:int
  648.     rUFCON0=(1<<6)|(2<<4)|(1<<2)|(1<<1)|(1);
  649.     //Tx and Rx FIFO Trigger Level:4byte,Tx and Rx FIFO Reset,FIFO on
  651.     // Clear Int Pending and Unmask 
  652.     ClearPending(BIT_UART0);
  653.     rINTMSK=~(BIT_UART0);
  654.     rSUBSRCPND=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  655.     rINTSUBMSK=~(BIT_SUB_RXD0|BIT_SUB_ERR0);
  657.     Uart_Printf("Download the target file[*.bin] by Uart0n");
  659.     while(rx_isdone);
  661.     rINTMSK |= (BIT_UART0);
  662.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  664.     rUFCON0=(3<<6)|(2<<4)|(1<<2)|(1<<1)|(0);
  665.     //Tx and Rx FIFO Trigger Level:12byte,Tx and Rx FIFO Reset,FIFO off
  667.     if(rx_dncs==(rx_checksum&0xffff)) 
  668. Uart_Printf("nDownload test OK!!!n");
  669.     else 
  670. Uart_Printf("nError!!!n");
  672.     Uart_Printf("nConnect PC[COM1 or COM2] and UART1 of SMDK2440 with a serial cable!!! n");
  673.     Uart_Printf("Then, press any key........n");
  674.    
  675.     Uart_Select(1);
  676.     Uart_Getch();
  678.     Uart_Port_Return();
  679. }
  683. void __irq Uart0_AfcTx(void)
  684. {
  685.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  687.     if(tx_cnt<AFC_BUFLEN)
  688.     {
  689.      Uart_Printf("%d,",*txdataPt);
  690.      WrUTXH0(*txdataPt++);
  691. tx_cnt++;
  692.         ClearPending(BIT_UART0);
  693.         rSUBSRCPND=(BIT_SUB_TXD0);
  694.         rINTSUBMSK&=~(BIT_SUB_TXD0);
  695.     }
  696.     else
  697.     {
  698.      tx_end=1;
  699.         while(rUFSTAT0 & 0x7f00); //Until FIFO is empty
  700.         ClearPending(BIT_UART0);
  701.         rSUBSRCPND=(BIT_SUB_TXD0);
  702.      rINTMSK|=BIT_UART0;
  703.     }
  704. }
  706. void __irq Uart0_AfcRxOrErr(void)
  707. {
  708.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  709.     if(rSUBSRCPND&BIT_SUB_RXD0) __sub_Uart0_RxAfc();    
  710.     else __sub_Uart0_RxErrInt();
  712.     ClearPending(BIT_UART0);
  713.     rSUBSRCPND=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  714.     rINTSUBMSK&=~(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  715. }
  717. void __sub_Uart0_RxAfc(void)
  718. {
  719.     while( rUFSTAT0 & 0x7f )
  720.     {
  721. *rxdataPt=rURXH0;
  722. Uart_Printf("%d,",*rxdataPt++);
  723. rx_cnt++;
  724.     }
  725.     if(rx_cnt == AFC_BUFLEN) 
  726.     {
  727.     rx_end=1;
  728.      rINTMSK|=BIT_UART0;
  729.     }
  730. }
  731.  
  732. void Test_Uart0_AfcTx(void)
  733. {
  734.     int i;
  735.     tx_cnt=0;
  736.     tx_end=0;
  737.     txdataFl=(volatile U8 *)UARTBUFFER;
  738.     txdataPt=(volatile U8 *)UARTBUFFER;
  739.     for(i=0;i<AFC_BUFLEN;i++) *txdataFl++=i; // Initialize the AFC data
  740.     Uart_Port_Set(); 
  741.     Uart_Select(1);
  742.     Uart_Printf("[Uart channel 0 AFC Tx Test]n");
  743.     Uart_Printf("This test should be configured two boards.n");
  744.     Uart_Printf("Connect Tx and Rx Board with twitsted(rx/tx, nCTS/nRTS) cable .n");
  745.      
  746.    
  747.     pISR_UART0=(unsigned) Uart0_AfcTx;
  749.     rULCON0=(0<<6)|(0<<3)|(0<<2)|(3); // Normal,No parity,One stop bit, 8bit
  750.     rUCON0 &= 0x400; // For the PCLK <-> UCLK fuction    
  751.     rUCON0 |= (1<<9)|(1<<8)|(0<<7)|(0<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
  752.     //Clock,Tx:Lev,Rx:Lev,Rx timeout:x,Rx error int:x,Loop-back:x,Send break:x,Tx:int,Rx:int
  753.     rUFCON0=(1<<6)|(0<<4)|(1<<2)|(1<<1)|(1);
  754.     //Tx and Rx FIFO Trigger Level:4byte,Tx and Rx FIFO Reset,FIFO on
  755.     rUMCON0=0x10;   // Enable Uart0 AFC 
  757.     Uart_Printf("nKeep the connection between PC[COM1 or COM2] and UART1 of SMDK2410!!! n");
  758.     Uart_Printf("Press any key to start Rx and then Star Tx....n");
  759.     Uart_TxEmpty(1);
  760.     Uart_Getch();
  761.   
  762.     // Clear Int Pending and Unmask 
  763.     rINTMSK=~(BIT_UART0);
  764.     rINTSUBMSK=~(BIT_SUB_TXD0);
  766.      while(!tx_end);
  768.      rINTMSK|=(BIT_UART0);
  769.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  770.     rUFCON0=(3<<6)|(2<<4)|(1<<2)|(1<<1)|(0);
  771.     //Tx and Rx FIFO Trigger Level:12byte,Tx and Rx FIFO Reset,FIFO off
  772.     Uart_Printf("nEnd Tx, transfer data count=%dn",tx_cnt);
  775.     Uart_Port_Return();
  776. }
  778. void Test_Uart0_AfcRx(void)
  779. {
  780.     unsigned int i;
  781.     rx_cnt=0;
  782.     rx_end=0;
  783.     afc_err=0;
  784.     rxdataCk=(volatile U8 *)UARTBUFFER;
  785.     rxdataPt=(volatile U8 *)UARTBUFFER;
  786.     Uart_Port_Set(); 
  787.     Uart_Select(1);
  788.     Uart_Printf("[Uart channel 0 AFC Rx Test]n");
  789.     Uart_Printf("This test should be configured two boards.n");
  790.     Uart_Printf("Connect Tx and Rx Board with twitsted(rx/tx, nCTS/nRTS) cable .n");
  791.     
  792.     pISR_UART0=(unsigned) Uart0_AfcRxOrErr;
  794.     rULCON0=(0<<6)|(0<<3)|(0<<2)|(3); // Normal,No parity,One stop bit, 8bit
  795.     rUCON0 &= 0x400; // For the PCLK <-> UCLK fuction    
  796.     rUCON0 |= (1<<9)|(1<<8)|(1<<7)|(1<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
  797.     //Clock,Tx:Lev,Rx:Lev,Rx timeout:o,Rx error int:o,Loop-back:x,Send break:x,Tx:o,Rx:o
  798.     
  799.     rUFCON0=(1<<6)|(0<<4)|(1<<2)|(1<<1)|(1);
  800.     //Tx and Rx FIFO Trigger Level:4byte,Tx and Rx FIFO Reset,FIFO on
  801.     rUMCON0=0x10;   // Enable Uart0 AFC 
  803.     
  804.     Uart_Printf("nKeep the connection between PC[COM1 or COM2] and UART0 of SMDK2410!!! n");
  805.     Uart_Printf("Press any key to start Rx and then Star Tx....n");
  806.     Uart_Getch();
  808.  
  809.    // Clear Int Pending and Unmask 
  810.      rSUBSRCPND=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  811.      rINTSUBMSK=~(BIT_SUB_RXD0|BIT_SUB_ERR0);
  812.      ClearPending(BIT_UART0);
  813.      rINTMSK=~(BIT_UART0);
  815.     while(!rx_end);
  817.   //  rINTMSK|=BIT_UART0;
  818.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  819.     rUFCON0=(3<<6)|(2<<4)|(1<<2)|(1<<1)|(0);
  820.     //Tx and Rx FIFO Trigger Level:12byte,Tx and Rx FIFO Reset,FIFO off
  821.     Uart_Printf("nEnd Rx, receive data count=%dn",rx_cnt);
  822.     for(i=0;i<AFC_BUFLEN;i++) 
  823.      if(i-(*rxdataCk++)) {
  824.      Uart_Printf("i=%dn",i);
  825.      afc_err++;
  826.      }
  827.     if(afc_err)
  828.      Uart_Printf("AFC test fail!! Error count=%dn",afc_err);
  829.     else
  830.      Uart_Printf("AFC test is good!!n");
  832.     Uart_Port_Return();
  833. }
  836. // added by junon start
  837. void __irq Uart0_RxOverrunErr(void)
  838. {
  839.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  840.     if(rSUBSRCPND&BIT_SUB_ERR0) 
  841. {
  842. __sub_Uart0_RxErrInt();
  843.      ClearPending(BIT_UART0); 
  844.     rSUBSRCPND=(BIT_SUB_RXD0|BIT_SUB_ERR0); // Clear Sub int pending    
  845. return;
  846.     }
  847.     rINTSUBMSK&=~(BIT_SUB_RXD0|BIT_SUB_ERR0);    
  848. }
  851. void Test_Uart0_RxErr(void) // need two serial port cables.
  852. {
  853. U8 ch;
  854. U8 cError;
  856.     Uart_Port_Set(); 
  857.    
  858.     Uart_Select(1);
  859.     Uart_Printf("nConnect PC[COM1 or COM2] and UART0 of SMDK2440 with a serial cable!!! n");
  860.     Uart_Printf("In this case, Uart0 : test port,  Uart1 : debug portn");
  861.     Uart_Printf("Then, press any key........n");
  862. //    Uart_Select(0); // Change the uart port    
  863.     Uart_Getch();
  865.    while(1)
  866. {
  867.     /*********** UART0 Rx test with interrupt ***********/
  868.     isRxInt=1;
  869.     uart0RxStr=(char *)UARTBUFFER;
  870.     Uart_Printf("n[Uart channel 0 Rx Error Check]n");
  871.     Uart_TxEmpty(1); //wait until tx buffer is empty.
  873. rUFCON0=(1<<6)|(0<<4)|(1<<2)|(1<<1)|0; // FIFO disable
  875. // for 2440A. add Frame error, Parity error, Break detect check.
  876.     Uart_Printf("n1. Overrun Error check[D]   2. Frame error   3. Parity error  n"); 
  877. cError = Uart_Getch();
  878.     if (cError== '2')
  879. {
  880. pISR_UART0 =(unsigned)Uart0_RxIntOrErr;
  882. rULCON0=(0<<6)|(4<<3)|(0<<2)|(0); // Normal,No parity,One stop bit, 7bit
  883. rUCON0 = (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(1<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
  884. //Clock,Tx:pulse,Rx:pulse,Rx timeout:x,Rx error int:o,Loop-back:x,Send break:x,Tx:int,Rx:int
  885. Uart_Printf("This port was set 7 data bit, no parity, 1 stop bit. Send just characters..n");
  886.     }
  887. else if (cError== '3')
  888. {
  889. pISR_UART0 =(unsigned)Uart0_RxIntOrErr;
  891. rULCON0=(0<<6)|(5<<3)|(0<<2)|(3); // Normal,Even parity,One stop bit, 8bit
  892. rUCON0 = (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(1<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
  893. //Clock,Tx:pulse,Rx:pulse,Rx timeout:x,Rx error int:o,Loop-back:x,Send break:x,Tx:int,Rx:int
  894. Uart_Printf("This port was set 8 data bit, even parity, 1 stop bit. Send just characters..n");
  895. }
  896.     else 
  897. {
  898. pISR_UART0 = (unsigned)Uart0_RxOverrunErr;
  900. rULCON0=(0<<6)|(0<<3)|(0<<2)|(3); // Normal,No parity,One stop bit, 8bit
  901.     rUCON0 = (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(1<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
  902.     //Clock,Tx:pulse,Rx:pulse,Rx timeout:x,Rx error int:o,Loop-back:x,Send break:x,Tx:int,Rx:int
  904. Uart_Printf("1. Using FIFO 2. Not using FIFO[D] n");
  905. if (Uart_Getch() == '1') 
  906. {
  907. rUFCON0 |= 1;
  908. Uart_Printf("Press Any key as 65 times in UART0 terminal window..n");
  909. Uart_Printf("then Overrun error will be occured.. n"); 
  910. }
  911. else
  912. {
  913. rUFCON0 &= ~1;
  914. Uart_Printf("Press Any key as 2 times in UART0 terminal window..n");
  915. Uart_Printf("then Overrun error will be occured.. n");
  916. }
  917. }
  919.     // Clear Int Pending and Unmask    
  920.     rSUBSRCPND=(BIT_SUB_TXD0|BIT_SUB_RXD0|BIT_SUB_ERR0);    
  921.     ClearPending(BIT_UART0);
  922.     rINTSUBMSK=~(BIT_SUB_RXD0|BIT_SUB_ERR0);
  923.     rINTMSK=~(BIT_UART0);
  925.     while(isRxInt);
  927. // UART0 mask
  928.      rINTSUBMSK|=(BIT_SUB_TXD0|BIT_SUB_RXD0|BIT_SUB_ERR0);
  929. rINTMSK|=(BIT_UART0);
  931. rUFCON0 |= 3<<1; // fifo reset
  932. Uart_Printf("1. One more  2. Exit[D] n");
  933. if (Uart_Getch() == '1') continue;
  934. else break;
  935. }
  937.     Uart_Port_Return();
  938. }
  940. #if 0
  941. void Enter_Uart0_ISR(void)
  942. {
  943. rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  944. rINTMSK |= BIT_UART0;
  945. ClearPending(BIT_UART0);
  946. rSUBSRCPND=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  947. }
  949. void Exit_Uart0_ISR(void)
  950. {
  951. rINTSUBMSK&=~(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  952. rINTMSK &= ~(BIT_UART0);
  953. }
  955. void __irq Uart0_Cts(void)
  956. {
  957. Enter_Uart0_ISR();
  959. Exit_Uart0_ISR();
  960. }
  962. void Test_Rts_Rx(void)
  963. {
  964.     int i = 1;
  966.     Uart_Port_Set(); 
  967.     //U32 safc_rGPHCON,safc_rGPHDAT,safc_rGPHUP;
  968.     tx_cnt=0;
  969.     Uart_Select(1);
  970.     Uart_Printf("[Uart channel 0 CTS Rx Test]n");
  971.     Uart_Printf("Check nCTS0 signal with oscilloscope! n");
  972. Uart_Printf("When FIFO nuber is 32, Active nRTS0... n");
  973.     
  974. //    pISR_UART0=(unsigned) Uart0_Cts;
  976.     rULCON0=(0<<6)|(0<<3)|(0<<2)|(3); // Normal,No parity,One stop bit, 8bit
  977.     rUCON0 |= (1<<9)|(1<<8)|(0<<7)|(0<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
  978.     //Clock,Tx:Lev,Rx:Lev,Rx timeout:x,Rx error int:x,Loop-back:x,Send break:x,Tx:int,Rx:int
  979.     rUFCON0=(3<<6)|(3<<4)|(1<<2)|(1<<1)|(1);
  980.     //Tx and Rx FIFO Trigger Level:32byte,Tx and Rx FIFO Reset,FIFO on
  981.     rUMCON0=0x10;   // Enable Uart0 AFC 
  983. // rINTMSK&=~(BIT_UART0);
  984. // rINTSUBMSK&=~(BIT_SUB_RXD0);
  985. rINTMSK |= (BIT_UART0); 
  986. rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_TXD0|BIT_SUB_ERR0);
  988. while( Uart_Getch() != 'r');  // just press any key at 32 times..
  990. Uart_Printf("nEnd Tx, transfer data count=%dn",tx_cnt);
  992. Uart_Select(0);
  993.     Uart_Port_Return();
  994. }
  995. #endif
  997. void Test_Uart0_Temp(void)
  998. {
  999. U8 ch;
  1000. int iBaud;
  1001. volatile char *cStartBuf;
  1003.     Uart_Port_Set(); 
  1005.     Uart_Select(1);    
  1007. /******** For operating clock test *********/
  1008. Uart_Printf("[Uart channel 0 Interrupt test]n");
  1009. Uart_Printf("Select operating clock 1. PCLK    2. UCLK     3. FCLK/n(D)  nChoose : ");
  1010. ch = Uart_Getch();
  1011. switch (ch)
  1012. {
  1013. case '1' :
  1014. Uart_Pclk_En(0, 115200);
  1015. break;
  1016. case '2' :
  1017. rMISCCR = rMISCCR & ~(7<<8) | (1<<10); // CLKOUT1 = PCLK
  1018. Uart_Uextclk_En(0, 115200, Pclk);
  1019. break;
  1020. default :
  1021. Uart_Printf("Type the baudrate and then change the same baudrate of host, too.n");
  1022. Uart_Printf("Baudrate (ex 9600, 115200, 921600[D]) : ");
  1023. iBaud = Uart_GetIntNum();
  1024. if (iBaud == -1) iBaud = 921600;
  1025. Uart_Fclkn_En(0, iBaud);
  1026. Uart_Getch();
  1027. break;
  1028. }
  1030. /*********** UART0 Tx test with interrupt ***********/  
  1031.     isTxInt=1;
  1032.     uart0TxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890->UART0 Tx interrupt test is good!!!!rn";
  1033. cStartBuf = uart0TxStr;
  1034.     Uart_Printf("[Uart channel 0 Tx Interrupt Test]n");
  1036.     pISR_UART0=(unsigned)Uart0_TxInt;
  1038.     rULCON0=(0<<6)|(0<<3)|(0<<2)|(3); // Normal,No parity,One stop bit, 8bit
  1039.     rUCON0 |= (TX_INTTYPE<<9)|(RX_INTTYPE<<8)|(0<<7)|(0<<6)|(0<<5)|(0<<4)|(1<<2)|(1);
  1040.     //Clock,Tx:Def,Rx:Def,Rx timeout:x,Rx error int:x,Loop-back:x,Send break:x,Tx:int,Rx:int
  1041. Uart_Printf("BRDIV0 = 0x%xn", rUBRDIV0);
  1042. Uart_Printf("UCON0 = 0x%xn", rUCON0);
  1043. Uart_Printf("UCON1 = 0x%xn", rUCON1);
  1044. Uart_Printf("Press enter key to exit n");
  1046.     Uart_TxEmpty(0); //wait until tx buffer is empty.
  1047.     rINTMSK&=~(BIT_UART0);
  1048.     rINTSUBMSK&=~(BIT_SUB_TXD0);
  1051.     while(1)
  1052. {
  1053. if (isTxInt==0)
  1054. {
  1055. uart0TxStr = cStartBuf;
  1056. rINTMSK&=~(BIT_UART0);
  1057. rINTSUBMSK&=~(BIT_SUB_TXD0|BIT_SUB_RXD0|BIT_SUB_ERR0);
  1058. isTxInt=1;
  1059. }
  1060. if (Uart_GetKey()=='r') break;
  1061.     }
  1062.     
  1063.     rINTSUBMSK|=(BIT_SUB_RXD0|BIT_SUB_ERR0);
  1064.     rINTMSK|=(BIT_UART0);
  1065.  
  1066.     Uart_Port_Return();
  1067. }
  1069. // junon end
  1071. //---------------------------------------UART0 test function-------------------------------------