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

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

uCOS

开发平台：

C/C++

Spi.c：源码内容
  1. /*============================================================
  3. File Name: SPI.c
  4. Description: S3C2440A SPI controller Function Test
  5.     Version: 0.1 
  7.     History:
  8.       0.1: 2003. 07. 06, Programming Start.
  9.       0.2: 2004. 05. 14, added keyboard test codes 
  10.                    
  11. =============================================================*/
  13. #include <string.h>
  14. #include "2440addr.h"
  15. #include "2440lib.h"
  16. #include "spi.h"
  17. #include "def.h"
  19. #define spi_count 0x80
  20. #define SPI_BUFFER _NONCACHE_STARTADDRESS
  22. void __irq Spi_Int(void);
  23. void __irq Dma1Tx_Int(void);
  24. void __irq Dma1Rx_Int(void);
  26. void Test_Spi1_MS_poll(void); // added by junon
  28. volatile char *spiTxStr,*spiRxStr;
  29. volatile int endSpiTx;
  30. volatile int tx_dma1Done;
  31. volatile int rx_dma1Done;
  32. unsigned int spi_rGPECON,spi_rGPEDAT,spi_rGPEUP;
  33. unsigned int spi_rGPGCON,spi_rGPGDAT,spi_rGPGUP;
  34. unsigned int spi_rGPDCON,spi_rGPDDAT,spi_rGPDUP;
  36. /////////////////////// 2004.05.14 added by junon
  37. #define ONEBIT    0x1
  39. int putcToKBCTL(U8 c);
  40. void getsFromKBCTL(U8 *m, int cnt);
  41. void Test_Spikbd_IO(void);
  42. void Test_Spikbd_keyscan(void);
  44. unsigned int spikbd_rGPBCON,spikbd_rGPBDAT,spikbd_rGPBUP;
  45. unsigned int spikbd_rGPDCON,spikbd_rGPDDAT,spikbd_rGPDUP;
  46. unsigned int spikbd_rGPFCON,spikbd_rGPFDAT,spikbd_rGPFUP;
  47. unsigned int spikbd_rGPGCON,spikbd_rGPGDAT,spikbd_rGPGUP;
  48. ///////////////////////
  51. /****************************************************************
  52.  *              SMDK2400 SPI configuration                 *
  53.  *  GPG2=nSS0, GPE11=SPIMISO0, GPE12=SPIMOSI0, GPE13=SPICLK0     *
  54.  *  GPG3=nSS1, GPG5 =SPIMISO1, GPG6 =SPIMOSI1, GPG7 =SPICLK1      *
  55.  *  SPI1 is tested by OS(WINCE). So, Only SPI0 is tested by this code          *               
  56.  ****************************************************************/
  58. void * func_spi_test[][2]=
  59. {
  60. //     "0123456789012345" max 15磊 肺茄沥窍咯 comment窍技夸.
  61. //SPI
  62. (void *)Test_Spi_MS_int,  "SPI0 RxTx Int  ",
  63. (void *)Test_Spi_MS_poll,  "SPI0 RxTx POLL ",
  64. (void *)Test_Spi_M_Int,  "SPI0 M Rx INT  ",
  65. (void *)Test_Spi_S_Int,  "SPI0 S Tx INT  ",
  66. (void *)Test_Spi_M_Tx_DMA1,  "SPI0 M Tx DMA1 ",
  67. (void *)Test_Spi_S_Rx_DMA1,  "SPI0 S Rx DMA1 ",
  68. (void *)Test_Spi_M_Rx_DMA1,  "SPI0 M Rx DMA1 ",
  69. (void *)Test_Spi_S_Tx_DMA1,  "SPI0 S Tx DMA1 ",
  70. (void *)Test_Spi1_MS_poll,  "SPI1 RxTx POLL ",
  71. (void *)Test_Spikbd_IO, "SPI1 keybd IO  ",
  72. (void *)Test_Spikbd_keyscan, "SPI1 keybd scan",
  73. 0,0
  74. };
  76. void Spi_Test(void)
  77. {
  78. int i;
  80. Uart_Printf("n======  SPI Test program start ======n");
  82. while(1)
  83. {
  84. i=0;
  85. Uart_Printf("nn");
  86. while(1)
  87. {   //display menu
  88. Uart_Printf("%2d:%s",i,func_spi_test[i][1]);
  89. i++;
  90. if((int)(func_spi_test[i][0])==0)
  91. {
  92. Uart_Printf("n");
  93. break;
  94. }
  95. if((i%4)==0)
  96. Uart_Printf("n");
  97. }
  99. Uart_Printf("nPress Enter key to exit : ");
  100. i = Uart_GetIntNum();
  101. if(i==-1) break; // return.
  102. if(i>=0 && (i<((sizeof(func_spi_test)-1)/8)) ) // select and execute...
  103. ( (void (*)(void)) (func_spi_test[i][0]) )();
  104. }
  106. Uart_Printf("n====== SPI Test program end ======n");
  107. }
  109. void SPI_Port_Init(int MASorSLV)
  110. {
  111. // SPI channel 0 setting
  112.     spi_rGPECON=rGPECON;
  113.     spi_rGPEDAT=rGPEDAT;
  114.     spi_rGPEUP=rGPEUP;
  115.     rGPECON=((rGPECON&0xf03fffff)|0xa800000); // using SPI 0
  116. rGPEUP = (rGPEUP & ~(7<<11)) | (1<<13);
  117.     spi_rGPGCON=rGPGCON;
  118.     spi_rGPGDAT=rGPGDAT;
  119.     spi_rGPGUP=rGPGUP;
  120.     if(MASorSLV==1)
  121.     {
  122.         rGPGCON=((rGPGCON&0xffffffcf)|0x10); // Master(GPIO_Output)
  123.         rGPGDAT|=0x4; // Activate nSS 
  124.     }
  125.     else
  126.      rGPGCON=((rGPGCON&0xffffffcf)|0x30); // Slave(nSS)
  127.     rGPGUP|=0x4;
  128. /*
  129. // SPI channel 1-1 setting --> Key board
  130. rGPGCON=(rGPGCON&0xffff033f)|(3<<6)|(3<<10)|(3<<12)|(1<<14); // MISO1, MOSI1, CLK1, Master
  131. rGPGDAT|=0x8;
  132. rGPGUP=(rGPGUP&~(7<<5))|(1<<7);
  133. */
  134. // SPI channel 1-2 setting --> VD16~18
  135. spi_rGPDCON=rGPDCON;
  136. spi_rGPDDAT=rGPDDAT;
  137. spi_rGPDUP=rGPDUP;
  138. rGPDCON=(rGPDCON&0xcfc0ffff)|(3<<16)|(3<<18)|(3<<20)|(1<<28); // MISO1, MOSI1, CLK1, Master
  139. rGPDDAT|=1<<14;
  140. rGPDUP=(rGPDUP&~(7<<8))|(1<<10);
  141. }
  143. void SPI_Port_Return(void)
  144. {
  145.     rGPECON=spi_rGPECON;
  146.     rGPEDAT=spi_rGPEDAT;
  147.     rGPEUP=spi_rGPEUP;
  149.     rGPGCON=spi_rGPGCON;
  150.     rGPGDAT=spi_rGPGDAT;
  151.     rGPGUP=spi_rGPGUP;
  153.     rGPDCON=spi_rGPDCON;
  154.     rGPDDAT=spi_rGPDDAT;
  155.     rGPDUP=spi_rGPDUP;
  156. }
  159. void Test_Spi1_MS_poll(void)
  160. {
  161.     int i;
  162.     char *txStr,*rxStr;
  163.     SPI_Port_Init(1); 
  164.     Uart_Printf("[SPI Polling Tx/Rx Test]n");
  165.     Uart_Printf("Connect SPIMOSI1 into SPIMISO1.n");
  166.     endSpiTx=0;
  167.     spiTxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 - SPI1";
  168.     spiRxStr=(char *) SPI_BUFFER;
  169.     txStr=(char *)spiTxStr;
  170.     rxStr=(char *)spiRxStr;
  172.     rSPPRE1=0x0; //if PCLK=50Mhz,SPICLK=25Mhz
  173.     rSPCON1=(0<<5)|(1<<4)|(1<<3)|(1<<2)|(0<<1)|(0<<0);//Polling,en-SCK,master,low,A,normal
  174.     rSPPIN1=(0<<2)|(1<<1)|(0<<0);//dis-ENMUL,SBO,release
  175.     
  176.     while(endSpiTx==0)
  177.     {
  178. if(rSPSTA1&0x1)   //Check Tx ready state    
  179. {
  180.      if(*spiTxStr!='')
  181. rSPTDAT1=*spiTxStr++;
  182.      else
  183. endSpiTx=1;
  184.      while(!(rSPSTA1&0x1));   //Check Rx ready state 
  185. *spiRxStr++=rSPRDAT1;
  186. }
  187.     }
  189.     rSPCON1&=~(1<<4);//dis-SCK
  190.     *(spiRxStr-1)='';//remove last dummy data & attach End of String(Null)
  191.     
  192.     Uart_Printf("Tx Strings:%sn",txStr);
  193.     Uart_Printf("Rx Strings:%s :",rxStr);
  194.     
  195.     if(strcmp(rxStr,txStr)==0)
  196.         Uart_Printf("O.K.n");
  197.     else 
  198.         Uart_Printf("ERROR!!!n");
  199.     SPI_Port_Return();
  200. }
  203. void Test_Spi_MS_int(void)
  204. {
  205.     char *txStr,*rxStr;
  206.     SPI_Port_Init(1); 
  207.     Uart_Printf("[SPI0 Interrupt Tx/Rx Test]n");
  208.     Uart_Printf("Connect SPIMOSI0 into SPIMISO0.n");
  210.     pISR_SPI0=(unsigned)Spi_Int;
  211.     endSpiTx=0;
  212.     spiTxStr="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  213.     spiRxStr=(char *) SPI_BUFFER;
  214.     txStr=(char *)spiTxStr;
  215.     rxStr=(char *)spiRxStr;
  216.     rSPPRE0=0x0; //if PCLK=50Mhz,SPICLK=25Mhz
  217.     rSPCON0=(1<<5)|(1<<4)|(1<<3)|(1<<2)|(0<<1)|0;//int,en-SCK,master,low,A,normal
  218.     rSPPIN0=(0<<2)|(1<<1)|(0<<0);//dis-ENMUL,SBO,release
  219.     rINTMSK=~(BIT_SPI0);
  221.     while(endSpiTx==0);
  223. rSPCON0&=~((1<<5)|(1<<4));//poll, dis-SCK
  224. Uart_Printf("Current Rx address = 0x%xn",spiRxStr);
  225.     *spiRxStr='';//attach End of String(Null)
  227.     Uart_Printf("Tx Strings:%sn",txStr);
  228.     Uart_Printf("Rx Strings:%s :",rxStr+1);//remove first dummy data
  229.     if(strcmp(rxStr+1,txStr)==0)
  230.         Uart_Printf("O.K.n");
  231.     else 
  232.         Uart_Printf("ERROR!!!n");
  233.     SPI_Port_Return();
  234. }
  237. void __irq Spi_Int(void)
  238. {
  239.     unsigned int status;
  241. rINTMSK|=BIT_SPI0;
  242.     ClearPending(BIT_SPI0); 
  243.     status=rSPSTA0;
  244.     if(rSPSTA0&0x6) 
  245.      Uart_Printf("Data Collision or Multi Master Error(0x%x)!!!n", status);
  246.     while(!(rSPSTA0&0x1));   //Check ready state
  247.     *spiRxStr++=rSPRDAT0;    //First Rx data is garbage data
  248. // Uart_Printf("Current Rx address = 0x%xn",spiRxStr);
  249.     
  250.     if(*spiTxStr!='') 
  251.     {
  252.      rSPTDAT0=*spiTxStr++;
  253. rINTMSK&=~BIT_SPI0;
  254.     }
  255.     else
  256.     {
  257.     endSpiTx=1;
  258.     }
  259. }
  261. void Test_Spi_MS_poll(void)
  262. {
  263.     int i;
  264.     char *txStr,*rxStr;
  265.     SPI_Port_Init(1); 
  266.     Uart_Printf("[SPI Polling Tx/Rx Test]n");
  267.     Uart_Printf("Connect SPIMOSI0 into SPIMISO0.n");
  268.     endSpiTx=0;
  269.     spiTxStr="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  270.     spiRxStr=(char *) SPI_BUFFER;
  271.     txStr=(char *)spiTxStr;
  272.     rxStr=(char *)spiRxStr;
  274.     rSPPRE0=0x0; //if PCLK=50Mhz,SPICLK=25Mhz
  275.     rSPCON0=(0<<5)|(1<<4)|(1<<3)|(1<<2)|(0<<1)|(0<<0);//Polling,en-SCK,master,low,A,normal
  276.     rSPPIN0=(0<<2)|(1<<1)|(0<<0);//dis-ENMUL,SBO,release
  277.     
  278.     while(endSpiTx==0)
  279.     {
  280. if(rSPSTA0&0x1)   //Check Tx ready state    
  281. {
  282.      if(*spiTxStr!='')
  283. rSPTDAT0=*spiTxStr++;
  284.      else
  285. endSpiTx=1;
  286.      while(!(rSPSTA0&0x1));   //Check Rx ready state 
  287. *spiRxStr++=rSPRDAT0;
  288. }
  289.     }
  291.     rSPCON0&=~(1<<4);//dis-SCK
  292.     *(spiRxStr-1)='';//remove last dummy data & attach End of String(Null)
  293.     
  294.     Uart_Printf("Tx Strings:%sn",txStr);
  295.     Uart_Printf("Rx Strings:%s :",rxStr);
  296.     
  297.     if(strcmp(rxStr,txStr)==0)
  298.         Uart_Printf("O.K.n");
  299.     else 
  300.         Uart_Printf("ERROR!!!n");
  301.     SPI_Port_Return();
  302. }
  305. void Test_Spi_M_Tx_DMA1(void)
  306. {
  308.     int i,first,second;
  309.     unsigned char *tx_ptr;
  310.     SPI_Port_Init(1); // Master(GPIO) 
  311.     Uart_Printf("[SPI DMA1 Master Tx test]n");
  312.     Uart_Printf("This test should be configured two boardsnStart Rx first.n");
  314.     tx_ptr=(unsigned char *) SPI_BUFFER;
  315.     for(i=0; i<spi_count; i++)
  316. *(tx_ptr+i)=i; 
  318.     tx_dma1Done=0;
  320.     pISR_DMA1 = (unsigned)Dma1Tx_Int;
  321.     rINTMSK=~(BIT_DMA1);
  323.     //Step1. SPI init
  324.     rSPPRE0=0x0; //if PCLK=50Mhz,SPICLK=25Mhz
  325.     rSPCON0=(2<<5)|(1<<4)|(1<<3)|(1<<2)|(0<<1)|(0<<0);//DMA1,en-SCK,master,low,A,normal
  326. //    rSPCON0=(2<<5)|(1<<4)|(1<<3)|(1<<2)|(1<<1)|(0<<0);//DMA1,en-SCK,master,low,B,normal    
  327.     rSPPIN0=(0<<2)|(1<<1)|(0<<0);//dis-ENMUL,SBO,release
  329.     //Step2. DMA1 init 
  330.     rDISRC1=(unsigned)tx_ptr; //Address of Memory
  331.     rDISRCC1=(0<<1)|(0); //AHB(Memory), inc
  332.     rDIDST1=(unsigned)0x59000010;//Address of SPTDAT Register
  333.     rDIDSTC1=(1<<1)|(1); //APB(SPI), fix
  334.     rDCON1=(1<<31)|(0<<30)|(1<<29)|(0<<28)|(0<<27)|(3<<24)|(1<<23)|(1<<22)|(0<<20)|(spi_count);
  335.     //handshake, sync PCLK, TC int, single tx, single service, SPI, H/W request, 
  336.     //off-reload, byte, 128Bytes
  338.     rGPGDAT&=0xfffffffb; // Activate nSS 
  339.     rDMASKTRIG1=(0<<2)|(1<<1)|(0);    //run, DMA1 channel on, no-sw trigger 
  341.     while(tx_dma1Done==0);
  343.     while(!(rSPSTA0&0x1)); // Tx is done
  345.     rGPGDAT|=0x4; // Deactivate nSS 
  346. //    rSPCON0=(0<<5)|(0<<4)|(1<<3)|(1<<2)|(0<<1)|(0<<0);//poll,dis-SCK,master,low,A,normal
  347.     rSPCON0=(0<<5)|(0<<4)|(1<<3)|(1<<2)|(1<<1)|(0<<0);//poll,dis-SCK,master,low,B,normal
  348.     Uart_Printf("nDMA1 transfer endn");
  349.     for(i=0; i<spi_count; i++)
  350. Uart_Printf("0x%02x,",*tx_ptr++);
  351.     SPI_Port_Return();
  352. }
  354. void __irq Dma1Tx_Int(void)
  355. {
  356.     tx_dma1Done=1;
  357.     rINTMSK|=BIT_DMA1;
  358.     ClearPending(BIT_DMA1);
  359. }
  362. void Test_Spi_S_Rx_DMA1(void)
  363. {
  364.     int i;
  365.     unsigned char *rx_ptr;
  366.     SPI_Port_Init(0); // Slave(nSS) 
  367.     Uart_Printf("[SPI DMA1 Slave Rx Test]n");
  368.     Uart_Printf("This test should be configured two boardsnStart Rx first.n");
  369.     rx_ptr=(unsigned char *) SPI_BUFFER;
  370.     for(i=0;i<0x500;i++)
  371. *(rx_ptr+i)=0x0; // Zero Initialize
  372.     rx_dma1Done=0;
  374.     pISR_DMA1 = (unsigned)Dma1Rx_Int;
  375.     rINTMSK=~(BIT_DMA1);
  377.     //Step1. SPI init
  378.     rSPPRE0=0x0; //if PCLK=50Mhz,SPICLK=25Mhz
  379.     rSPCON0=(2<<5)|(0<<4)|(0<<3)|(1<<2)|(0<<1)|(1<<0);//DMA1,dis-SCK,slave,low,A,TAGD
  380. //    rSPCON0=(2<<5)|(0<<4)|(0<<3)|(1<<2)|(1<<1)|(1<<0);//DMA1,dis-SCK,slave,low,B,TAGD
  381.     //When you use [Slave Rx with DMA] function you should have to set TAGD bit
  382.     rSPPIN0=(0<<2)|(1<<1)|(0<<0);//dis-ENMUL,SBO,release
  384.     //Step2. DMA1 init 
  385.     rDISRC1=(unsigned)0x59000014;//Address of SPRDAT Register
  386.     rDISRCC1=(1<<1)|(1); //APB(SPI), fix
  387.     rDIDST1=(unsigned)rx_ptr; //Address of Memory
  388.     rDIDSTC1=(0<<1)|(0); //AHB(Memory), inc
  389.     rDCON1=(1<<31)|(0<<30)|(1<<29)|(0<<28)|(0<<27)|(3<<24)|(1<<23)|(1<<22)|(0<<20)|(spi_count);
  390.     //handshake, sync PCLK, TC int, single tx, single service, SPI, H/W request, 
  391.     //off-reload, byte, 128Bytes
  393.     rDMASKTRIG1=(0<<2)|(1<<1)|(0);    //run, DMA1 channel on, no-sw trigger 
  395.     while(rx_dma1Done==0);
  397.     rSPCON0=(0<<5)|(0<<4)|(0<<3)|(1<<2)|(1<<1)|(0<<0);//poll,dis-SCK,slave,low,B,normal
  398.     while(!rSPSTA0&0x1);
  399.     *(rx_ptr+spi_count)=rSPRDAT0;
  400.     rx_ptr=(unsigned char *) SPI_BUFFER;
  401.     for(i=1;i<(spi_count+1);i++)
  402. Uart_Printf("0x%02x,",*(rx_ptr+i));
  403.     Uart_Printf("nDMA1 receive end");
  404.     SPI_Port_Return();
  405. }
  407. void __irq Dma1Rx_Int(void)
  408. {
  409.     rx_dma1Done=1;
  410.     rINTMSK|=BIT_DMA1;
  411.     ClearPending(BIT_DMA1);
  412. }
  415. void Test_Spi_M_Rx_DMA1(void)
  416. {
  417.     int i;
  418.     unsigned char *rx_ptr;
  419.     SPI_Port_Init(1); // Master(GPIO)
  420.     Uart_Printf("[SPI DMA1 Master Rx Test]n");
  421.     Uart_Printf("This test should be configured two boardsnStart Tx first.n");
  423.     rx_ptr=(unsigned char *)SPI_BUFFER;
  424.     for(i=0;i<0x500;i++)
  425. *(rx_ptr+i)=0x0; // Zero Initialize
  426.     rx_dma1Done=0;
  428.     pISR_DMA1 = (unsigned)Dma1Rx_Int;
  429.     rINTMSK=~(BIT_DMA1);
  430.     //Step1. SPI init
  432.     rSPPRE0=0x1; //if PCLK=50Mhz,SPICLK=25Mhz
  433. //    rSPCON0=(2<<5)|(1<<4)|(1<<3)|(1<<2)|(0<<1)|(1<<0);//DMA1,en-SCK,master,low,A,TAGD    
  434.     rSPCON0=(2<<5)|(1<<4)|(1<<3)|(1<<2)|(1<<1)|(1<<0);//DMA1,en-SCK,master,low,B,TAGD
  435.     rGPGDAT&=0xfffffffb; // Activate nSS 
  436.     //When you use [Master Rx with DMA] function you should have to set TAGD bit
  437.     rSPPIN0=(0<<2)|(1<<1)|(0<<0);//dis-ENMUL,SBO,release
  439.  
  440.     //Step2. DMA1 init 
  441.     rDISRC1=(unsigned)0x59000014;//Address of SPRDAT Register
  442.     rDISRCC1=(1<<1)|(1); //APB(SPI), fix
  443.     rDIDST1=(unsigned)rx_ptr; //Address of Memory
  444.     rDIDSTC1=(0<<1)|(0); //AHB(Memory), inc
  445.     rDCON1=(1<<31)|(0<<30)|(1<<29)|(0<<28)|(0<<27)|(3<<24)|(1<<23)|(1<<22)|(0<<20)|(spi_count);
  446.     //handshake, sync PCLK, TC int, single tx, single service, SPI, H/W request, 
  447.     //off-reload, byte, 128Bytes
  448.     rDMASKTRIG1=(0<<2)|(1<<1)|(0);    //run, DMA1 channel on, no-sw trigger 
  450.     while(rx_dma1Done==0);
  452.     rSPCON0=(0<<5)|(1<<4)|(1<<3)|(1<<2)|(0<<1)|(0<<0);//poll,dis-SCK,master,low,A,normal
  453. //    rSPCON0=(0<<5)|(1<<4)|(1<<3)|(1<<2)|(1<<1)|(0<<0);//poll,dis-SCK,master,low,B,normal
  455.     while(!rSPSTA0&0x1);
  457.     *(rx_ptr+spi_count)=rSPRDAT0;
  458.     rx_ptr=(unsigned char *)SPI_BUFFER;
  459.     rGPGDAT|=0x4; // Deactivate nSS 
  460.     
  461.     for(i=1;i<(spi_count+1);i++)
  462. Uart_Printf("0x%02x,",*(rx_ptr+i));//to remove first dummy data
  464.     Uart_Printf("nDMA1 receive end");
  465.     SPI_Port_Return();
  466. }
  468. void Test_Spi_S_Tx_DMA1(void)
  469. {
  470.     int i;
  471.     unsigned char *tx_ptr;
  472.     SPI_Port_Init(0); // Slave (nSS)
  473.     Uart_Printf("[SPI DMA1 Slave Tx test]n");
  474.     Uart_Printf("This test should be configured two boardsnStart Tx first.n");
  475.     tx_ptr=(U8 *) SPI_BUFFER;
  476.     for(i=0; i<spi_count; i++)
  477. *(tx_ptr+i)=i;
  478.     tx_dma1Done=0;
  479.     pISR_DMA1 = (unsigned)Dma1Tx_Int;
  480.     rINTMSK=~(BIT_DMA1);
  482.     //Step1. SPI init
  483.     rSPPRE0=0x0; //if PCLK=50Mhz,SPICLK=25Mhz
  484. //    rSPCON0=(2<<5)|(0<<4)|(0<<3)|(1<<2)|(0<<1)|(0<<0);//DMA1,dis-SCK,slave,low,A,normal
  485.     rSPCON0=(2<<5)|(0<<4)|(0<<3)|(1<<2)|(1<<1)|(0<<0);//DMA1,dis-SCK,slave,low,B,normal
  486.     rSPPIN0=(0<<2)|(1<<1)|(0<<0);//dis-ENMUL,SBO,release
  488.     //Step2. DMA1 init 
  489.     rDISRC1=(unsigned)tx_ptr; //Address of Memory
  490.     rDISRCC1=(0<<1)|(0); //AHB(Memory), inc
  491.     rDIDST1=(unsigned)0x59000010;//Address of SPTDAT Register
  492.     rDIDSTC1=(1<<1)|(1); //APB(SPI), fix
  493.     rDCON1=(1<<31)|(0<<30)|(1<<29)|(0<<28)|(0<<27)|(3<<24)|(1<<23)|(1<<22)|(0<<20)|(spi_count);
  494.     //handshake, sync PCLK, TC int, single tx, single service, SPI, H/W request, 
  495.     //off-reload, byte, 128Bytes
  497.     rDMASKTRIG1=(0<<2)|(1<<1)|(0);    //run, DMA1 channel on, no-sw trigger 
  500.     while(tx_dma1Done==0);
  502.     while(!(rSPSTA0&0x1)); // Tx is done
  503.     rSPCON0=(0<<5)|(0<<4)|(0<<3)|(1<<2)|(0<<1)|(0<<0);//poll,dis-SCK,slave,low,A,normal
  504. //    rSPCON0=(0<<5)|(0<<4)|(0<<3)|(1<<2)|(1<<1)|(0<<0);//poll,dis-SCK,slave,low,B,normal
  505.     Uart_Printf("nDMA1 transfer endn");
  506.     for(i=0; i<spi_count; i++)
  507. Uart_Printf("0x%02x,",*tx_ptr++);
  508.     SPI_Port_Return();
  509. }
  512. void Test_Spi_M_Int(void)
  513. {
  514.     char *rxStr,*txStr;
  515.     SPI_Port_Init(1); // Master
  516.     Uart_Printf("[SPI Interrupt Master Rx test]n");
  517.     Uart_Printf("This test should be configured two boardsnStart Slave first.n");
  518.     pISR_SPI0=(unsigned)Spi_Int;
  519.     endSpiTx=0;
  520.     spiTxStr="1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
  521.     spiRxStr=(char *) SPI_BUFFER;
  522.     txStr=(char *)spiTxStr;
  523.     rxStr=(char *)spiRxStr;
  524.     rSPPRE0=0x1; //if PCLK=50Mhz,SPICLK=12.5Mhz
  525.     rSPCON0=(1<<5)|(1<<4)|(1<<3)|(1<<2)|(0<<1)|(0<<0);//int,en-SCK,master,low,A,normal
  526. //    rSPCON0=(1<<5)|(1<<4)|(1<<3)|(1<<2)|(1<<1)|(0<<0);//int,en-SCK,master,low,B,normal
  527.     rSPPIN0=(0<<2)|(1<<1)|(0<<0);//dis-ENMUL,SBO,release
  528.     rGPGDAT&=0xfffffffb; // Activate nSS 
  529.     rINTMSK=~(BIT_SPI0);
  531.     while(endSpiTx==0);
  533.     rGPGDAT|=0x4; // Deactivate nSS 
  534.     rSPCON0=(0<<5)|(0<<4)|(1<<3)|(1<<2)|(0<<1)|(0<<0);//Poll,dis-SCK,master,low,A,normal
  535. //    rSPCON0=(0<<5)|(0<<4)|(1<<3)|(1<<2)|(1<<1)|(0<<0);//Poll,dis-SCK,master,low,B,normal
  536.     Uart_Printf("Current address :0x%xn",spiRxStr);
  537.     *spiRxStr='';//attach End of String(Null)
  538.     Uart_Printf("Tx Strings:%sn",txStr);
  539.     Uart_Printf("Rx Strings:%s :",rxStr+1);//remove first dummy data
  540.     if(strcmp((rxStr+1),txStr)==0)
  541.         Uart_Printf("O.K.n");
  542.     else 
  543.         Uart_Printf("ERROR!!!n");
  544.     SPI_Port_Return();
  545. }
  549. void Test_Spi_S_Int(void)
  550. {
  551.     char *rxStr,*txStr;
  552.     SPI_Port_Init(0); // Slave (nSS)
  553.     Uart_Printf("[SPI Interrupt Slave Tx test]n");
  554.     Uart_Printf("This test should be configured two boardsnStart Slave first.n");
  555.     pISR_SPI0=(unsigned)Spi_Int;
  556.     endSpiTx=0;
  557.     spiTxStr="1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
  558.     spiRxStr=(char *) SPI_BUFFER;
  559.     txStr=(char *)spiTxStr;
  560.     rxStr=(char *)spiRxStr;
  561.     rSPPRE0=0x0; //if PCLK=50Mhz,SPICLK=25Mhz
  562.     rSPCON0=(1<<5)|(0<<4)|(0<<3)|(1<<2)|(0<<1)|(0<<0);//int,dis-SCK,slave,low,A,normal
  563. //    rSPCON0=(1<<5)|(0<<4)|(0<<3)|(1<<2)|(1<<1)|(0<<0);//int,dis-SCK,slave,low,B,normal
  564.     rSPPIN0=(0<<2)|(1<<1)|(0<<0);//dis-ENMUL,SBO,release
  565.     rINTMSK=~(BIT_SPI0);
  567.     while(endSpiTx==0);
  569.     rSPCON0=(0<<5)|(0<<4)|(0<<3)|(1<<2)|(0<<1)|(0<<0);//Poll,dis-SCK,master,low,A,normal
  570. //    rSPCON0=(0<<5)|(0<<4)|(0<<3)|(1<<2)|(1<<1)|(0<<0);//Poll,dis-SCK,master,low,B,normal
  571. Uart_Printf("Current address :0x%xn",spiRxStr);
  572.     *spiRxStr='';//attach End of String(Null)
  573.     Uart_Printf("Tx Strings:%sn",txStr);
  574.     Uart_Printf("Rx Strings:%s :",rxStr+1);//remove first dummy data
  575.     if(strcmp((rxStr+1),txStr)==0)
  576.         Uart_Printf("O.K.n");
  577.     else 
  578.         Uart_Printf("ERROR!!!n");
  579.     SPI_Port_Return();
  580. }
  583. ///////////////////////// 2004.05.14 added by junon 
  585. static void __irq Eint1(void)
  586. {
  587.     U8           ui8ScanCode;
  589. getsFromKBCTL(&ui8ScanCode, 1);
  591. ClearPending(BIT_EINT1);
  593. Uart_Printf("keybd interrupt asserted -> scancode = 0x%xn", ui8ScanCode);
  595. }
  597. void SPIKBD_Port_Init()
  598. {
  599. spikbd_rGPBCON = rGPBCON;
  600. spikbd_rGPBDAT = rGPBDAT;
  601. spikbd_rGPBUP  = rGPBUP;
  603. spikbd_rGPDCON = rGPDCON;
  604. spikbd_rGPDDAT = rGPDDAT;
  605. spikbd_rGPDUP  = rGPDUP;
  607. spikbd_rGPFCON = rGPFCON;
  608. spikbd_rGPFDAT = rGPFDAT;
  609. spikbd_rGPFUP  = rGPFUP;
  611. spikbd_rGPGCON = rGPGCON;
  612. spikbd_rGPGDAT = rGPGDAT;
  613. spikbd_rGPGUP  = rGPGUP;
  615. // Setup IO port for SPI interface & Keyboard
  617. // Setup EINT1 (KBDINT)
  618.     rGPFCON &= ~(0x3 << 2);  // Clear GPF1 
  619.     rGPFCON |= (0x2 << 2);   // Set GPF1 to EINT1 for Keyboard interrupt
  621.     rEXTINT0 &= ~(0x7 << 4);    // Clear EINT1
  622.     rEXTINT0 |= (0x2 << 4);     // fallig edge triggered for EINT1
  624. // setup SPI interface
  625. // GPG5 : SPIMISO (KBDSPIMISO)
  626. // GPG6 : SPIMOSI (KBDSPIMOSI)
  627. // GPG7 : SPICLK  (KBDSPICLK)
  628.     rGPGCON &= ~((0x3 << 10) | (0x3 << 12) | (0x3 << 14));   // Clear GPG5,6,7
  629.     rGPGCON |= ((0x3 << 10) | (0x3 << 12) | (0x3 << 14));    
  630.      
  631. // setup _SS signal(nSS_KBD)
  632.     rGPBCON &= ~(0x3 << 12);         // Clear GPB6
  633.     rGPBCON |= (ONEBIT << 12);        // Set Port GPB6 to output for nSS signal
  635. // setup _PWR_OK signal (KEYBOARD)
  636.     rGPBCON &= ~(0x3 << 0);         // Clear GPB0 
  637.     rGPBCON |= (ONEBIT << 0);       // Set Port GPB0 to output for _PWR_OK signal
  639.     rGPDDAT &=~(ONEBIT << 0);        // set _PWR_OK to 0
  640. }
  642. void SPIKBD_Port_Return(void)
  643. {
  644. rGPBCON = spikbd_rGPBCON;
  645. rGPBDAT = spikbd_rGPBDAT;
  646. rGPBUP  = spikbd_rGPBUP;
  648. rGPDCON = spikbd_rGPDCON;
  649. rGPDDAT = spikbd_rGPDDAT;
  650. rGPDUP  = spikbd_rGPDUP;
  651.                  
  652. rGPFCON = spikbd_rGPFCON;
  653. rGPFDAT = spikbd_rGPFDAT;
  654. rGPFUP  = spikbd_rGPFUP;
  655.                  
  656. rGPGCON = spikbd_rGPGCON;
  657. rGPGDAT = spikbd_rGPGDAT;
  658. rGPGUP  = spikbd_rGPGUP;
  659. }
  661. int putcToKBCTL(U8 c)
  662. {
  663. U32 i;
  665.    rGPBDAT &= ~(ONEBIT << 6);       //Set _SS signal to low (Slave Select)
  667. while((rSPSTA1 & ONEBIT)==0); // wait while busy
  669. rSPTDAT1 = c;                 // write left justified data
  671. while((rSPSTA1 & ONEBIT)==0); // wait while busy
  672.    
  673.     rGPBDAT |= (ONEBIT << 6);        //Set _SS signal to high (Slave Select)
  675. i = rSPRDAT1;
  677. return(i);
  678. }
  680. void getsFromKBCTL(U8 *m, int cnt)
  681. {
  682. int i, j;
  683. volatile tmp = 1;
  685. for(j = 0; j < 3; j++)
  686. tmp += tmp;
  687. for(j = 0; j < 250 * 30; j++)
  688. tmp += tmp;
  690. for(i = 0; i < cnt; i++) 
  691. {
  692. m[i] = putcToKBCTL(0xFF);
  694. for(j = 0; j < 400; j++)
  695. tmp+= tmp;
  696. }
  697. }
  699. void putsToKBCTL(U8 *m,  int cnt)
  700. {
  701. int i, j, x;
  702. volatile tmp = 1;
  704. for(j = 0; j < 3; j++)
  705. x = j;
  706. for(j = 0; j < 3; j++)
  707. tmp += tmp;
  708. for(j = 0; j < 250 * 30; j++)
  709. tmp += tmp;
  711. for(i = 0; i < cnt; i++) {
  713. j = putcToKBCTL(m[i]);
  715. for(j = 0; j < 400; j++)
  716. tmp+= tmp;
  717. for(j = 0; j < 400; j++)
  718. x = j;
  719.     }
  720. }
  722. char lrc(U8 *buffer, int count)
  723. {
  724.     char lrc;
  725.     int n;
  727.     lrc = buffer[0] ^ buffer[1];
  729.     for (n = 2; n < count; n++)
  730.     {
  731.         lrc ^= buffer[n];
  732.     }
  734.     if (lrc & 0x80)
  735.         lrc ^= 0xC0;
  737.     return lrc;
  738. }
  740. int USAR_WriteRegister(int reg, int data)
  741. {
  742.     U8 cmd_buffer[4];
  744.     cmd_buffer[0] = 0x1b; //USAR_PH_WR;
  745.     cmd_buffer[1] = (unsigned char)reg;
  746.     cmd_buffer[2] = (unsigned char)data;
  748.     cmd_buffer[3] = lrc((U8 *)cmd_buffer,3);
  749.     putsToKBCTL((U8 *)cmd_buffer,4);
  751.     return TRUE;
  752. }
  754. void Kbd_PowerOn(void)
  755. {
  756. U8 msg[5];
  757. int t;
  758. char dummy = (char)0xff;
  760. SPIKBD_Port_Init();
  762. // Setup SPI registers
  763.     // Interrupt mode, prescaler enable, master mode, active high clock, format B, normal mode
  764.     rSPCON1 = (ONEBIT<<5)|(ONEBIT<<4)|(ONEBIT<<3)|(0x0<<2)|(ONEBIT<<1);
  765.     
  766. // Developer MUST change the value of prescaler properly whenever value of PCLK is changed.
  767.     rSPPRE1 = 255;// 99.121K = 203M/4/2/(255+1) PCLK=50.75Mhz FCLK=203Mhz SPICLK=99.121Khz
  768.          
  769.     for(t=0;t<20000; t++); // delay
  770.     msg[0] = (char)0x1b; msg[1] = (char)0xa0; msg[2] = (char)0x7b; msg[3] = (char)0; // Initialize USAR
  771.      for(t=0; t < 10; t++) {
  772.      dummy = putcToKBCTL(0xff);
  773.     }
  774.     
  775.     for(t=0; t<10; t++) { // wait for a while
  776.         putsToKBCTL(msg,3);
  777.         for(t=0;t<20000; t++);
  778.     }
  779.     t = 100;
  780.     while(t--) {
  781.         if((rGPFDAT & 0x2)==0) { // Read _ATN (KBDINT) GPF1
  782.             break;
  783.         }
  784.     } //check _ATN
  785.     if(t != 0) {
  786.         getsFromKBCTL(msg,3);
  787.     }    
  788.     t=100000;
  789.     while(t--); // delay
  790. msg[0] = (char)0x1b; msg[1] = (char)0xa1; msg[2] = (char)0x7a; msg[3] = (char)0; //Initialization complete
  791. putsToKBCTL(msg,3);
  793. Uart_Printf("KeybdPowerOnn");
  794. }
  796. void Test_Spikbd_keyscan(void)
  797. {
  798.     Uart_Printf("[SPIKBD Test keyscan] start.n");
  800. Kbd_PowerOn();
  802. rEXTINT0 = (rEXTINT0 & ~(7<<4)) | (2<<4); // falling edge
  804. pISR_EINT1=(U32)Eint1;
  806.     rSRCPND = BIT_EINT1;
  807.     rINTPND = BIT_EINT1;
  809.     rINTMSK=~(BIT_EINT1);
  811. Uart_Getch();
  813. rINTMSK = BIT_ALLMSK;
  815.     Uart_Printf("[SPIKBD Test keyscan] end.n");
  817.     SPIKBD_Port_Return();
  818. }
  820. void SPIKBD_Port_Init_IO()
  821. {
  822. spikbd_rGPBCON = rGPBCON;
  823. spikbd_rGPBDAT = rGPBDAT;
  824. spikbd_rGPBUP  = rGPBUP;
  826. spikbd_rGPDCON = rGPDCON;
  827. spikbd_rGPDDAT = rGPDDAT;
  828. spikbd_rGPDUP  = rGPDUP;
  830. spikbd_rGPFCON = rGPFCON;
  831. spikbd_rGPFDAT = rGPFDAT;
  832. spikbd_rGPFUP  = rGPFUP;
  834. spikbd_rGPGCON = rGPGCON;
  835. spikbd_rGPGDAT = rGPGDAT;
  836. spikbd_rGPGUP  = rGPGUP;
  838. // Setup IO port for SPI interface & Keyboard
  840. // Setup KBDINT as output
  841.     rGPFCON &= ~(0x3 << 2);  // Clear GPF1 
  842.     rGPFCON |= (0x1 << 2);   // Set GPF1 to EINT1 for Keyboard interrupt
  844. // setup SPI interface
  845. // GPG5 : SPIMISO (KBDSPIMISO)
  846. // GPG6 : SPIMOSI (KBDSPIMOSI)
  847. // GPG7 : SPICLK  (KBDSPICLK)
  848.     rGPGCON &= ~((0x3 << 10) | (0x3 << 12) | (0x3 << 14));   // Clear GPG5,6,7
  849.     rGPGCON |= ((0x1 << 10) | (0x1 << 12) | (0x1 << 14));    
  850.      
  851. // setup _SS signal(nSS_KBD)
  852.     rGPBCON &= ~(0x3 << 12);         // Clear GPB6
  853.     rGPBCON |= (ONEBIT << 12);        // Set Port GPB6 to output for nSS signal
  855. // setup _PWR_OK signal (KEYBOARD)
  856.     rGPBCON &= ~(0x3 << 0);         // Clear GPB0 
  857.     rGPBCON |= (ONEBIT << 0);       // Set Port GPB0 to output for _PWR_OK signal
  858. }
  861. void Test_Spikbd_IO(void)
  862. {
  863. int i = 0;
  865.     Uart_Printf("[SPIKBD IO-Test] startn");
  867. SPIKBD_Port_Init_IO();
  869. do 
  870. {
  871. Uart_Printf("test loop going - %dn", i);
  872. i++;
  874. if (i%2) 
  875. {
  876. rGPFDAT &= ~(1<<1); // GPF1 KBDINT
  877. rGPBDAT &= ~(1<<6); // GPB6
  878. rGPBDAT &= ~(1<<0); // GPB0
  879. rGPGDAT &= ~(7<<5); // GPG5,6,7 (SPIMISO,SPIMOSI,SPICLK)
  880. }
  881. else 
  882. {
  883. rGPFDAT |= (1<<1); // GPF1 KBDINT
  884. rGPBDAT |= (1<<6); // GPB6
  885. rGPBDAT |= (1<<0); // GPB0
  886. rGPGDAT |= (7<<5); // GPG5,6,7 (SPIMISO,SPIMOSI,SPICLK)
  887. }
  889. } while(Uart_GetKey() == 0);
  892.     Uart_Printf("[SPIKBD IO-Test] endn");
  893.     
  894.     SPIKBD_Port_Return();
  896. }
  897. //////////////////////////////////