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

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

uCOS

开发平台：

C/C++

sdi.c：源码内容
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include "def.h"
  4. #include "option.h"
  5. #include "2440addr.h"
  6. #include "2440lib.h"
  7. #include "sdi.h"
  9. //YH 0811#define INICLK 300000
  10. #define INICLK 300000
  11. //#define NORCLK 25000000
  12. #define SDCLK 24000000 //PCLK=49.392MHz
  13. #define MMCCLK 15000000 //PCLK=49.392MHz
  15. #define POL 0
  16. #define INT 1
  17. #define DMA 2
  19. int CMD13(void);    // Send card status
  20. int CMD9(void);
  21. // Global variables
  23. //YH 0728 int *Tx_buffer; //128[word]*16[blk]=8192[byte]
  24. //YH 0728 int *Rx_buffer; //128[word]*16[blk]=8192[byte]
  26. unsigned int *Tx_buffer; //128[word]*16[blk]=8192[byte]
  27. unsigned int *Rx_buffer; //128[word]*16[blk]=8192[byte]
  28. volatile unsigned int rd_cnt;
  29. volatile unsigned int wt_cnt;
  30. volatile unsigned int block;
  31. volatile unsigned int TR_end=0;
  33. int Wide=0; // 0:1bit, 1:4bit
  34. int MMC=0;  // 0:SD  , 1:MMC
  36. int  Maker_ID;
  37. char Product_Name[7]; 
  38. int  Serial_Num;
  40. volatile int RCA;
  42. void Test_SDI(void)
  43. {
  44. U32 save_rGPEUP, save_rGPECON;
  45. int k;
  47.     RCA=0;
  48.     MMC=0;
  49.     block=3072;   //3072Blocks=1.5MByte, ((2Block=1024Byte)*1024Block=1MByte)
  50. //    block=13;
  52. save_rGPEUP=rGPEUP;
  53. save_rGPECON=rGPECON;
  55.     rGPEUP  = 0xf83f;     // SDCMD, SDDAT[3:0] => PU En.
  56.     rGPECON = 0xaaaaaaaa; //SDCMD, SDDAT[3:0]
  57. //    rGPECON = 0xaaa800aa; //SDCMD, SDDAT[3:0] => Input
  60.     Uart_Printf("n[SDI test]n");
  61.     
  62.     if(!SD_card_init())
  63. return;
  64.     
  65.     TR_Buf_new();
  66. /*
  67. INOM:    
  68.     //Uart_Printf("How many blocks to test?(1~16)?");
  69.     block=(U32)Uart_GetIntNum();
  70.     if((block==0)|block>16)
  71. goto INOM;
  72.     //block=1;//tark
  73.     //Uart_Printf("n");
  74. */
  76.     //CMD13();
  77. //YH 040227
  78. // for(k=0;k<4;k++)
  79.     Wt_Block();
  81.     Rd_Block();
  82.     View_Rx_buf();
  84.     if(MMC)
  85. TR_Buf_new();
  86.     
  87.     if(MMC)
  88.     {
  89. rSDICON |=(1<<5);    // YH 0519, MMC Type SDCLK
  91. Wt_Stream();
  92. Rd_Stream();
  93. View_Rx_buf();
  94.     }
  96.     Card_sel_desel(0); // Card deselect
  98.     if(!CMD9())
  99. Uart_Printf("Get CSD fail!!!n");
  100.     rSDIDCON=0;//tark???
  101.     rSDICSTA=0xffff;
  102. rGPEUP=save_rGPEUP;
  103. rGPECON=save_rGPECON;
  104. }
  106. void TR_Buf_new(void)
  107. {
  108.     //-- Tx & Rx Buffer initialize
  109.     int i, j;
  110.     int start = 0x03020100;
  112.     Tx_buffer=(unsigned int *)0x31000000;
  114.     j=0;
  115.     for(i=0;i<2048;i++) //128[word]*16[blk]=8192[byte]
  116. *(Tx_buffer+i)=i+j;
  117. // *(Tx_buffer+i)=0x5555aaaa;
  118.     Flush_Rx_buf();
  119. /*
  120.     for(i=0;i<20;i++){
  121.         for(j=0;j<128;j++){
  122. Tx_buffer[j+i*128]=start;
  123. if(j % 64 == 63) start = 0x0302010;
  124. else start = start + 0x04040404;
  125.         }
  126.         start = 0x03020100;
  127.     }
  128. */
  129. }
  131. void Flush_Rx_buf(void)
  132. {
  133.     //-- Flushing Rx buffer 
  134.     int i;
  136.     Rx_buffer=(unsigned int *)0x31800000;
  138.     for(i=0;i<2048;i++) //128[word]*16[blk]=8192[byte]
  139. *(Rx_buffer+i)=0;
  140.     Uart_Printf("n--End Rx buffer flushn");
  141. }
  143. void View_Rx_buf()
  144. {
  145.     //-- Display Rx buffer 
  146.     int i,error=0;
  148.     Tx_buffer=(unsigned int *)0x31000000;
  149.     Rx_buffer=(unsigned int *)0x31800000;
  151.     Uart_Printf("Check Rx datan");
  153.     for(i=0;i<128*block;i++)
  154.     {
  155.         if(Rx_buffer[i] != Tx_buffer[i])
  156. {
  157.     Uart_Printf("nTx/Rx errorn"); 
  158.     Uart_Printf("%d:Tx-0x%08x, Rx-0x%08xn",i,Tx_buffer[i], Rx_buffer[i]);
  159.     error=1;
  160.     break;
  161.         }
  162. //YH 040227 Uart_Printf(".");
  163.     }
  164.     if(!error)
  165. Uart_Printf(" O.K.n");
  166. }
  168. void View_Tx_buf(void)
  169. {
  170.     //-- Display Tx buffer 
  171.     int i;
  173.     //for(i=0;i<2048;i++)
  174. //Uart_Printf("TB[%02x]=%x,",Tx_buffer[i]);
  175. }
  178. int SD_card_init(void)
  179. {
  180. //-- SD controller & card initialize 
  181.     int i;
  182.     char key;
  185.     /* Important notice for MMC test condition */
  186.     /* Cmd & Data lines must be enabled by pull up resister */
  188. //YH 0816, Org    rSDIPRE=PCLK/(2*INICLK)-1; // 400KHz
  189.     rSDIPRE=PCLK/(INICLK)-1; // 400KHz
  190. Uart_Printf("Init. Frequency is %dHzn",(PCLK/(rSDIPRE+1)));
  191.     
  192. //    rSDICON=(1<<4)|(1<<1)|1; // Type B, FIFO reset, clk enable
  193. rSDICON=(1<<4)|1; // Type B, clk enable
  194. rSDIFSTA=rSDIFSTA|(1<<16); //YH 040223 FIFO reset
  195.     rSDIBSIZE=0x200; // 512byte(128word)
  196.     rSDIDTIMER=0x7fffff; // Set timeout count
  198.     for(i=0;i<0x1000;i++);  // Wait 74SDCLK for MMC card
  200.     //Uart_Printf("rSDIRSP0=0x%xn",rSDIRSP0);
  201.     CMD0();
  202.     Uart_Printf("nIn idlen");
  204.     //-- Check MMC card OCR
  205.     if(Chk_MMC_OCR()) 
  206.     {
  207. Uart_Printf("nIn MMC readyn");
  208. MMC=1;
  209. goto RECMD2;
  210.     }
  212.     Uart_Printf("MMC check end!!n");
  213.     //-- Check SD card OCR
  214.     if(Chk_SD_OCR()) 
  215.         Uart_Printf("nIn SD readyn");
  217.     else
  218.     {
  219. Uart_Printf("nInitialize failnNo Card assertionn");
  220.         return 0;
  221.     }
  223. RECMD2:
  224.     //-- Check attaced cards, it makes card identification state
  225.     rSDICARG=0x0;   // CMD2(stuff bit)
  226.     rSDICCON=(0x1<<10)|(0x1<<9)|(0x1<<8)|0x42; //lng_resp, wait_resp, start, CMD2
  228.     //-- Check end of CMD2
  229.     if(!Chk_CMDend(2, 1)) 
  230. goto RECMD2;
  231.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  233.     Uart_Printf("nEnd idn");
  235. RECMD3:
  236.     //--Send RCA
  237.     rSDICARG=MMC<<16;     // CMD3(MMC:Set RCA, SD:Ask RCA-->SBZ)
  238.     rSDICCON=(0x1<<9)|(0x1<<8)|0x43; // sht_resp, wait_resp, start, CMD3
  240.     //-- Check end of CMD3
  241.     if(!Chk_CMDend(3, 1)) 
  242. goto RECMD3;
  243.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  245.     //--Publish RCA
  246.     if(MMC) {
  247. RCA=1;
  248. //YH 0812        rSDIPRE=(PCLK/(MMCCLK)+1)-1; // YH 0716, Normal clock=20MHz
  249.         rSDIPRE=(PCLK/MMCCLK)-1; // YH 0812, Normal clock=20MHz
  251.         Uart_Printf("MMC Frequency is %dHzn",(PCLK/(rSDIPRE+1)));
  252.      }
  253.     else 
  254.      {
  255. RCA=( rSDIRSP0 & 0xffff0000 )>>16;
  256.     Uart_Printf("RCA=0x%xn",RCA);
  258. rSDIPRE=PCLK/(SDCLK)-1; // Normal clock=25MHz
  259. Uart_Printf("SD Frequency is %dHzn",(PCLK/(rSDIPRE+1)));
  260.      } //YH 0716
  261.     //--State(stand-by) check
  262.     if( rSDIRSP0 & 0x1e00!=0x600 )  // CURRENT_STATE check
  263. goto RECMD3;
  264.     
  265.     Uart_Printf("nIn stand-byn");
  266.     
  267. //    rSDIPRE=PCLK/(2*NORCLK)-1; // Normal clock=25MHz
  268. //YH 0716    rSDIPRE=PCLK/(SDCLK)-1; // Normal clock=25MHz
  269. //YH 0716    //Uart_Printf("SD Frequency is %dMHzn",(PCLK/(rSDIPRE+1)));
  271.     Card_sel_desel(1); // Select
  273.     if(!MMC)
  274. Set_4bit_bus();
  275.     else
  276. Set_1bit_bus();
  278.     return 1;
  279. }
  281. void Card_sel_desel(char sel_desel)
  282. {
  283.     //-- Card select or deselect
  284.     if(sel_desel)
  285.     {
  286. RECMDS7:
  287. rSDICARG=RCA<<16; // CMD7(RCA,stuff bit)
  288. rSDICCON= (0x1<<9)|(0x1<<8)|0x47;   // sht_resp, wait_resp, start, CMD7
  290. //-- Check end of CMD7
  291. if(!Chk_CMDend(7, 1))
  292.     goto RECMDS7;
  293. rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  295. //--State(transfer) check
  296. if( rSDIRSP0 & 0x1e00!=0x800 )
  297.     goto RECMDS7;
  298.     }
  299.     else
  300.     {
  301. RECMDD7:
  302. rSDICARG=0<<16; //CMD7(RCA,stuff bit)
  303. rSDICCON=(0x1<<8)|0x47; //no_resp, start, CMD7
  305. //-- Check end of CMD7
  306. if(!Chk_CMDend(7, 0))
  307.     goto RECMDD7;
  308. rSDICSTA=0x800; // Clear cmd_end(no rsp)
  309.     }
  310. }
  312. void __irq Rd_Int(void)
  313. {
  314.     U32 i,status;
  316.     status=rSDIFSTA;
  317.     if( (status&0x200) == 0x200 ) // Check Last interrupt?
  318.     {
  319. for(i=(status & 0x7f)/4;i>0;i--)
  320. {
  321.     *Rx_buffer++=rSDIDAT;
  322.     rd_cnt++;
  323. }
  324. // Uart_Printf("status1=0x%xn", status);
  325. // status=rSDIFSTA&0x200; //If you do like this, rSDIFSTA register will not be updated., YH 040221
  326. rSDIFSTA=rSDIFSTA&0x200; //Clear Rx FIFO Last data Ready, YH 040221
  327. // Uart_Printf("rSDIFSTA=0x%xn", rSDIFSTA);
  328.     }
  329.     else if( (status&0x80) == 0x80 ) // Check Half interrupt?
  330.     {
  331.         for(i=0;i<8;i++)
  332.         {
  333.          *Rx_buffer++=rSDIDAT;
  334.     rd_cnt++;
  335. }
  336.     }
  337. // Uart_Printf("rSDIFSTA=0x%xn", rSDIFSTA); //YH 040221
  339.     ClearPending(BIT_SDI);
  340. }
  342. void __irq Wt_Int(void)
  343. {
  344.     ClearPending(BIT_SDI);
  346.     rSDIDAT=*Tx_buffer++;
  347.     wt_cnt++;
  349.     if(wt_cnt==128*block)
  350.     {
  351. rINTMSK |= BIT_SDI;
  352. rSDIDAT=*Tx_buffer;
  353. TR_end=1;
  354.     }
  355. }
  357. void __irq DMA_end(void)
  358. {
  359.     ClearPending(BIT_DMA0);
  360.     
  361.     TR_end=1;
  362. }
  364. void Rd_Block(void)
  365. {
  366.     U32 mode;
  367.     int status;
  369.     rd_cnt=0;    
  370.     Uart_Printf("[Block read test]n");
  372. RE0:
  373.     Uart_Printf("0:Polling read   1:Interrupt read   2:DMA readnSelect the test mode?");
  374.     mode=(U32)Uart_GetIntNum();
  376. Uart_Printf("n");
  378.     if(mode>2)
  379. goto RE0;
  381. //    rSDICON = rSDICON|(1<<1); // FIFO reset
  382. rSDIFSTA=rSDIFSTA|(1<<16); // FIFO reset
  384.     if(mode!=2)
  385. rSDIDCON=(2<<22)|(1<<19)|(1<<17)|(Wide<<16)|(1<<14)|(2<<12)|(block<<0); //YH 040220
  386. //Word Rx, Rx after cmd, blk, 4bit bus, Rx start, blk num, data start, data transmit mode
  388.     rSDICARG=0x0; // CMD17/18(addr)
  390. RERDCMD:
  391.     switch(mode)
  392.     {
  393. case POL:
  394.     if(block<2) // SINGLE_READ
  395.     {
  396. rSDICCON=(0x1<<9)|(0x1<<8)|0x51;    // sht_resp, wait_resp, dat, start, CMD17
  397. if(!Chk_CMDend(17, 1)) //-- Check end of CMD17
  398.     goto RERDCMD;     
  399.     }
  400.     else // MULTI_READ
  401.     {
  402. rSDICCON=(0x1<<9)|(0x1<<8)|0x52;    // sht_resp, wait_resp, dat, start, CMD18
  403. if(!Chk_CMDend(18, 1)) //-- Check end of CMD18 
  404.     goto RERDCMD;
  405.     }
  407.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)     
  409.     while(rd_cnt<128*block) // 512*block bytes
  410.     {
  411. if((rSDIDSTA&0x20)==0x20) // Check timeout 
  412. {
  413.     rSDIDSTA=(0x1<<0x5);  // Clear timeout flag
  414.     break;
  415. }
  416. status=rSDIFSTA;
  417. if((status&0x1000)==0x1000) // Is Rx data?
  418. {
  419.     *Rx_buffer++=rSDIDAT;
  420.     rd_cnt++;
  421. }
  422.     }
  423.     break;
  425. case INT:
  426.     pISR_SDI=(unsigned)Rd_Int;
  427.     rINTMSK = ~(BIT_SDI);
  428.     
  429.     rSDIIMSK=5; // Last & Rx FIFO half int.
  431.     if(block<2) // SINGLE_READ
  432.     {
  433. rSDICCON=(0x1<<9)|(0x1<<8)|0x51;    // sht_resp, wait_resp, dat, start, CMD17
  434. if(!Chk_CMDend(17, 1)) //-- Check end of CMD17
  435.     goto RERDCMD;     
  436.     }
  437.     else // MULTI_READ
  438.     {
  439. rSDICCON=(0x1<<9)|(0x1<<8)|0x52;    // sht_resp, wait_resp, dat, start, CMD18
  440. if(!Chk_CMDend(18, 1)) //-- Check end of CMD18 
  441.     goto RERDCMD;
  442.     }
  443.     
  444.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  446.     while(rd_cnt<128*block);
  448.     rINTMSK |= (BIT_SDI);
  449.     rSDIIMSK=0; // All mask
  450.     break;
  452. case DMA:
  453.     pISR_DMA0=(unsigned)DMA_end;
  454.     rINTMSK = ~(BIT_DMA0);
  455. rSDIDCON=rSDIDCON|(1<<24); //YH 040227, Burst4 Enable
  457.     rDISRC0=(int)(SDIDAT); // SDIDAT
  458.     rDISRCC0=(1<<1)+(1<<0); // APB, fix
  459.     rDIDST0=(U32)(Rx_buffer); // Rx_buffer
  460.     rDIDSTC0=(0<<1)+(0<<0); // AHB, inc
  461.     rDCON0=(1<<31)+(0<<30)+(1<<29)+(0<<28)+(0<<27)+(2<<24)+(1<<23)+(1<<22)+(2<<20)+128*block;
  462.     //handshake, sync PCLK, TC int, single tx, single service, SDI, H/W request, 
  463.     //auto-reload off, word, 128blk*num
  464.     rDMASKTRIG0=(0<<2)+(1<<1)+0;    //no-stop, DMA2 channel on, no-sw trigger 
  466. //     rSDIDCON=(2<<22)|(1<<19)|(1<<17)|(Wide<<16)|(1<<15)|(2<<12)|(block<<0);
  467.     rSDIDCON=(2<<22)|(1<<19)|(1<<17)|(Wide<<16)|(1<<15)|(1<<14)|(2<<12)|(block<<0);
  468.     // Word Rx, Rx after rsp, blk, 4bit bus, dma enable, Rx start, blk num, Data start, data receive mode, YH 040220
  469.     if(block<2) // SINGLE_READ
  470.     {
  471. rSDICCON=(0x1<<9)|(0x1<<8)|0x51;    // sht_resp, wait_resp, dat, start, CMD17
  472. if(!Chk_CMDend(17, 1)) //-- Check end of CMD17
  473.     goto RERDCMD;     
  474.     }
  475.     else // MULTI_READ
  476.     {
  477. rSDICCON=(0x1<<9)|(0x1<<8)|0x52;    // sht_resp, wait_resp, dat, start, CMD18
  478. if(!Chk_CMDend(18, 1)) //-- Check end of CMD18 
  479.     goto RERDCMD;
  480.     }
  482.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  483.     while(!TR_end);
  484. //Uart_Printf("rSDIFSTA=0x%xn",rSDIFSTA);
  485.     rINTMSK |= (BIT_DMA0);
  486.     TR_end=0;
  487.     rDMASKTRIG0=(1<<2); //DMA0 stop
  488.     break;
  490. default:
  491.     break;
  492.     }
  493.     //-- Check end of DATA
  494.     if(!Chk_DATend()) 
  495. Uart_Printf("dat errorn");
  497. rSDIDCON=rSDIDCON&~(7<<12); //YH 040220, Clear Data Transfer mode => no operation, Cleata Data Transfer start
  498. rSDIFSTA=rSDIFSTA&0x200; //Clear Rx FIFO Last data Ready, YH 040221
  499.     rSDIDSTA=0x10; // Clear data Tx/Rx end detect
  501.     if(block>1)
  502.     {
  503. RERCMD12:    
  504. //--Stop cmd(CMD12)
  505. rSDICARG=0x0;     //CMD12(stuff bit)
  506. rSDICCON=(0x1<<9)|(0x1<<8)|0x4c;//sht_resp, wait_resp, start, CMD12
  508. //-- Check end of CMD12
  509. if(!Chk_CMDend(12, 1)) 
  510.     goto RERCMD12;
  511. rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  512.     }
  513. }
  516. void Rd_Stream(void) // only for MMC, 3blk read
  517. {
  518.     int i;
  519.     int status, rd_cnt=0;
  521.     if(MMC!=1)
  522.     {
  523. Uart_Printf("Stream read command supports only MMC!n");
  524. return;
  525.     }    
  526.     Uart_Printf("n[Stream read test]n");
  527.     
  528. RECMD11:
  529. //    rSDIDCON=(2<<22)|(1<<19)|(0<<17)|(0<<16)|(2<<12);
  530.   rSDIDCON=(2<<22)|(1<<19)|(0<<17)|(0<<16)|(1<<14)|(2<<12);
  533.     rSDICARG=0x0;   // CMD11(addr)
  534.     rSDICCON=(0x1<<9)|(0x1<<8)|0x4b;   //sht_resp, wait_resp, dat, start, CMD11
  536.     while(rd_cnt<128*block)
  537.     {
  538. if( (rSDIDSTA&0x20) == 0x20 )
  539. {
  540.     Uart_Printf("Rread timeout error");
  541.     return ;
  542. }
  543.     
  544. status=rSDIFSTA;
  545. if((status&0x1000)==0x1000)
  546. {
  547.     //*Rx_buffer++=rSDIDAT;
  548.     //rd_cnt++;
  549.     Rx_buffer[rd_cnt++]=rSDIDAT;
  550. }
  551.     }
  553.     //-- Check end of CMD11
  554.     if(!Chk_CMDend(11, 1)) 
  555. goto RECMD11;
  556.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  558.     //-- Check end of DATA
  559. //    rSDIDCON=(2<<22)|(1<<19)|(0<<17)|(0<<16)|(1<<14)|(0<<12);
  560.     rSDIDCON=(2<<22)|(1<<19)|(0<<17)|(0<<16); //YH 040220
  561.     rSDIDCON=rSDIDCON&~(7<<12); //YH 040220, no operation, data ready
  563.     while( rSDIDSTA&0x3 !=0x0 );
  564.     if(rSDIDSTA!=0) 
  565. Uart_Printf("rSDIDSTA=0x%xn", rSDIDSTA);
  566.     rSDIDSTA=0xff; //YH 040221
  568. STRCMD12:    
  569.     //--Stop cmd(CMD12)
  570.     rSDICARG=0x0;     //CMD12(stuff bit)
  571.     rSDICCON=(0x1<<9)|(0x1<<8)|0x4c; //sht_resp, wait_resp, start, CMD12
  573.     //-- Check end of CMD12
  574.     if(!Chk_CMDend(12, 1)) 
  575. goto STRCMD12;
  576.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  577.     rSDIFSTA=rSDIFSTA&0x200; //Clear Rx FIFO Last data Ready, YH 040221
  578. /*
  579.     //-- Display Rx data
  580.     //Uart_Printf("nRx datan");
  581.     for(i=0;i<128*2;i++)
  582.     {
  583.         if(Rx_buffer[i] != Tx_buffer[i])
  584. {
  585.     //Uart_Printf("%08x, %08xn",Tx_buffer[i], Rx_buffer[i]);
  586.     break;
  587.         }
  588.     }
  589. */
  591. Uart_Printf("rSDIFSTA1=0x%xn", rSDIFSTA); //YH 040221
  592.    rSDIFSTA=rSDIFSTA&0x200; //Clear Rx FIFO Last data Ready, YH 040221
  593. Uart_Printf("rSDIFSTA2=0x%xn", rSDIFSTA); //YH 040221
  595.     Uart_Printf("n--End stream read testn");
  596. }
  599. void Wt_Block(void)
  600. {
  601.     U32 mode;
  602.     int i,status;
  604.     wt_cnt=0;    
  605.     Uart_Printf("[Block write test]n");
  607. RE1:
  608. Uart_Printf("0:Polling write   1:Interrupt write   2:DMA writenSelect the test mode?");
  609.     mode=(U32)Uart_GetIntNum();
  611.     if(mode>2)
  612. goto RE1;
  614. //    rSDICON |= rSDICON|(1<<1); // FIFO reset
  615. rSDIFSTA=rSDIFSTA|(1<<16); //YH 040223 FIFO reset
  617.     if(mode!=2)
  618. // rSDIDCON=(2<<22)|(1<<20)|(1<<17)|(Wide<<16)|(3<<12)|(block<<0);
  619. rSDIDCON=(2<<22)|(1<<20)|(1<<17)|(Wide<<16)|(1<<14)|(3<<12)|(block<<0); //YH 040220
  621.     //Word Tx, Tx after rsp, blk, 4bit bus, Tx start, blk num
  623.     rSDICARG=0x0;     // CMD24/25(addr)
  625. REWTCMD:
  626.     switch(mode)
  627.     {
  628. case POL:
  629.     if(block<2) // SINGLE_WRITE
  630.     {
  631. rSDICCON=(0x1<<9)|(0x1<<8)|0x58; //sht_resp, wait_resp, dat, start, CMD24
  632. if(!Chk_CMDend(24, 1)) //-- Check end of CMD24
  633.     goto REWTCMD;
  634.     }
  635.     else // MULTI_WRITE
  636.     {
  637. rSDICCON=(0x1<<9)|(0x1<<8)|0x59; //sht_resp, wait_resp, dat, start, CMD25
  638. if(!Chk_CMDend(25, 1)) //-- Check end of CMD25
  639. goto REWTCMD;
  640.     }
  642.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  643.     
  644.     while(wt_cnt<128*block)
  645.     {
  646. status=rSDIFSTA;
  647. if((status&0x2000)==0x2000) 
  648. {
  649.     rSDIDAT=*Tx_buffer++;
  650.     wt_cnt++;
  651. //Uart_Printf("Block No.=%d, wt_cnt=%dn",block,wt_cnt);
  652. }
  653.     }
  654.     break;
  656. case INT:
  657.     pISR_SDI=(unsigned)Wt_Int;
  658.     rINTMSK = ~(BIT_SDI);
  660.     rSDIIMSK=0x10;  // Tx FIFO half int.
  662.     if(block<2)     // SINGLE_WRITE
  663.     {
  664. rSDICCON=(0x1<<9)|(0x1<<8)|0x58;    //sht_resp, wait_resp, dat, start, CMD24
  665. if(!Chk_CMDend(24, 1)) //-- Check end of CMD24
  666.     goto REWTCMD;
  667.     }
  668.     else     // MULTI_WRITE
  669.     {
  670. rSDICCON=(0x1<<9)|(0x1<<8)|0x59;    //sht_resp, wait_resp, dat, start, CMD25
  671. if(!Chk_CMDend(25, 1)) //-- Check end of CMD25 
  672.     goto REWTCMD;
  673.     }
  675.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  677.     while(!TR_end);
  678.     //while(wt_cnt<128);
  680.     rINTMSK |= (BIT_SDI);
  681.     TR_end=0;
  682.     rSDIIMSK=0; // All mask
  683.     break;
  685. case DMA:
  686.     pISR_DMA0=(unsigned)DMA_end;
  687.     rINTMSK = ~(BIT_DMA0);
  688. rSDIDCON=rSDIDCON|(1<<24); //YH 040227, Burst4 Enable
  690.     rDISRC0=(int)(Tx_buffer); // Tx_buffer
  691.     rDISRCC0=(0<<1)+(0<<0); // AHB, inc
  692.     rDIDST0=(U32)(SDIDAT); // SDIDAT
  693.     rDIDSTC0=(1<<1)+(1<<0); // APB, fix
  694.     rDCON0=(1<<31)+(0<<30)+(1<<29)+(0<<28)+(0<<27)+(2<<24)+(1<<23)+(1<<22)+(2<<20)+128*block;
  695.     //handshake, sync PCLK, TC int, single tx, single service, SDI, H/W request, 
  696.     //auto-reload off, word, 128blk*num
  697.     rDMASKTRIG0=(0<<2)+(1<<1)+0;    //no-stop, DMA0 channel on, no-sw trigger
  698.     
  699. //     rSDIDCON=(2<<22)|(1<<20)|(1<<17)|(Wide<<16)|(1<<15)|(3<<12)|(block<<0);
  700. rSDIDCON=(2<<22)|(1<<20)|(1<<17)|(Wide<<16)|(1<<15)|(1<<14)|(3<<12)|(block<<0); //YH 040220
  702.     // Word Tx, Tx after rsp, blk, 4bit bus, dma enable, Tx start, blk num
  703.     if(block<2)     // SINGLE_WRITE
  704.     {
  705. rSDICCON=(0x1<<9)|(0x1<<8)|0x58;    //sht_resp, wait_resp, dat, start, CMD24
  706. if(!Chk_CMDend(24, 1)) //-- Check end of CMD24
  707.     goto REWTCMD;     
  708.     }
  709.     else     // MULTI_WRITE
  710.     {
  711. rSDICCON=(0x1<<9)|(0x1<<8)|0x59;    //sht_resp, wait_resp, dat, start, CMD25
  712. if(!Chk_CMDend(25, 1)) //-- Check end of CMD25 
  713.     goto REWTCMD;     
  714.     }
  716.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  718.     while(!TR_end);
  720.     rINTMSK |= (BIT_DMA0);
  721.     TR_end=0;
  722.     rDMASKTRIG0=(1<<2); //DMA0 stop
  724.     break;
  726. default:
  727.     break;
  728.     }
  729.     
  730.     //-- Check end of DATA
  731.     if(!Chk_DATend()) 
  732. Uart_Printf("dat errorn");
  734. rSDIDCON=rSDIDCON&~(7<<12); //YH 040220, Clear Data Transfer mode => no operation, Cleata Data Transfer start
  735.     rSDIDSTA=0x10; // Clear data Tx/Rx end
  737.     if(block>1)
  738.     {
  739. //--Stop cmd(CMD12)
  740. REWCMD12:    
  741. // rSDIDCON=(1<<18)|(1<<17)|(0<<16)|(1<<12)|(block<<0);
  742. rSDIDCON=(1<<18)|(1<<17)|(0<<16)|(1<<14)|(1<<12)|(block<<0);  //YH  040220
  745. rSDICARG=0x0;     //CMD12(stuff bit)
  746. rSDICCON=(0x1<<9)|(0x1<<8)|0x4c;    //sht_resp, wait_resp, start, CMD12
  748. //-- Check end of CMD12
  749. if(!Chk_CMDend(12, 1)) 
  750.     goto REWCMD12;
  751. rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  753. //-- Check end of DATA(with busy state)
  754. if(!Chk_BUSYend()) 
  755.     Uart_Printf("errorn");
  756. rSDIDSTA=0x08; //! Should be cleared by writing '1'.
  757.     }
  758. }
  760. void Wt_Stream(void) // only for MMC, 3blk write
  761. {
  762.     int status, wt_cnt=0;
  764.     if(MMC!=1)
  765.     {
  766. Uart_Printf("Stream write command supports only MMC!n");
  767. return;
  768.     }
  769.     Uart_Printf("n[Stream write test]n");
  770. RECMD20:
  771. //    rSDIDCON=(2<<22)|(1<<20)|(0<<17)|(0<<16)|(3<<12);  // stream mode
  772.     rSDIDCON=(2<<22)|(1<<20)|(0<<17)|(0<<16)|(1<<14)|(3<<12);  // stream mode
  775.     rSDICARG=0x0; // CMD20(addr)
  776.     rSDICCON=(0x1<<9)|(0x1<<8)|0x54;    //sht_resp, wait_resp, dat, start, CMD20
  778.     //-- Check end of CMD25
  779.     if(!Chk_CMDend(20, 1)) 
  780. goto RECMD20;
  781.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  783.     while(wt_cnt<128*block)
  784.     {
  785. status=rSDIFSTA;
  786. if((status&0x2000)==0x2000) 
  787.     rSDIDAT=Tx_buffer[wt_cnt++];
  788.     }
  790.     //-- Check end of DATA
  791.     while( rSDIFSTA&0x400 );
  792.     Delay(10);    // for the empty of DATA line(Hardware)
  793. //    rSDIDCON=(1<<20)|(0<<17)|(0<<16)|(1<<14)|(0<<12);
  794.     rSDIDCON=(1<<20)|(0<<17)|(0<<16); //YH 040220
  795.     rSDIDCON=rSDIDCON&~(7<<12); //YH 040220, no operation, data ready
  797.     while( (rSDIDSTA&0x3)!=0x0 );
  798.     if(rSDIDSTA!=0x0) 
  799. Uart_Printf("rSDIDSTA=0x%xn", rSDIDSTA);
  801.     rSDIDSTA=0xff; //Clear rSDIDSTA
  803. STWCMD12:    
  804.     //--Stop cmd(CMD12)
  805. //    rSDIDCON=(1<<18)|(1<<17)|(0<<16)|(1<<12);
  806.     rSDIDCON=(1<<18)|(1<<17)|(0<<16)|(1<<14)|(1<<12);
  809.     rSDICARG=0x0;     //CMD12(stuff bit)
  810.     rSDICCON=(0x1<<9)|(0x1<<8)|0x4c;   //sht_resp, wait_resp, start, CMD12
  812.     //-- Check end of CMD12
  813.     if(!Chk_CMDend(12, 1)) 
  814. goto STWCMD12;
  815.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  817.     //-- Check end of DATA(with busy state)
  818.     if(!Chk_BUSYend()) 
  819. Uart_Printf("errorn");
  820.     rSDIDSTA=0x08;
  822.     Uart_Printf("n--End Stream write testn");
  823. }
  826. int Chk_CMDend(int cmd, int be_resp)
  827. //0: Timeout
  828. {
  829.     int finish0;
  831.     if(!be_resp)    // No response
  832.     {
  833.      finish0=rSDICSTA;
  834. while((finish0&0x800)!=0x800) // Check cmd end
  835.     finish0=rSDICSTA;
  837. rSDICSTA=finish0;// Clear cmd end state
  839. return 1;
  840.     }
  841.     else // With response
  842.     {
  843.      finish0=rSDICSTA;
  844. while( !( ((finish0&0x200)==0x200) | ((finish0&0x400)==0x400) ))    // Check cmd/rsp end
  845. // while( !( ((finish0&0x200)==0x200) | ((finish0&0x400)==0x800) )) // Check cmd/rsp end
  846. // while((finish0&0x1800)!=0x1800) //YH 0811 Check cmd end
  847. // Uart_Printf("CMD%d:rSDICSTA=0x%xn", cmd, rSDICSTA); //YH 0811
  849. finish0=rSDICSTA;
  853. //YH 0624 if(cmd==1 | cmd==9 | cmd==41) // CRC no check
  854. if(cmd==1 | cmd==41) // CRC no check, CMD9 is a long Resp. command.
  856. {
  857.     if( (finish0&0xf00) != 0xa00 )  // Check error
  858.     {
  859. rSDICSTA=finish0;   // Clear error state
  861. if(((finish0&0x400)==0x400))
  862.     return 0; // Timeout error
  863.          }
  864.     rSDICSTA=finish0; // Clear cmd & rsp end state
  865. }
  866. else // CRC check
  867. {
  868.     if( (finish0&0x1f00) != 0xa00 ) // Check error
  869.     {
  870. Uart_Printf("CMD%d:rSDICSTA=0x%x, rSDIRSP0=0x%xn",cmd, rSDICSTA, rSDIRSP0);
  871. rSDICSTA=finish0;   // Clear error state
  873. if(((finish0&0x400)==0x400))
  874.     return 0; // Timeout error
  875.          }
  876.     rSDICSTA=finish0;
  877. }
  878. return 1;
  879.     }
  880. }
  882. int Chk_DATend(void)
  883. {
  884.     int finish;
  886.     finish=rSDIDSTA;
  887.     while( !( ((finish&0x10)==0x10) | ((finish&0x20)==0x20) ))
  888. // Chek timeout or data end
  889. finish=rSDIDSTA;
  891.     if( (finish&0xfc) != 0x10 )
  892.     {
  893.         Uart_Printf("DATA:finish=0x%xn", finish);
  894.         rSDIDSTA=0xec;  // Clear error state
  895.         return 0;
  896.     }
  897.     return 1;
  898. }
  900. int Chk_BUSYend(void)
  901. {
  902.     int finish;
  904.     finish=rSDIDSTA;
  905.     while( !( ((finish&0x08)==0x08) | ((finish&0x20)==0x20) ))
  906. finish=rSDIDSTA;
  908.     if( (finish&0xfc) != 0x08 )
  909.     {
  910.         Uart_Printf("DATA:finish=0x%xn", finish);
  911.         rSDIDSTA=0xf4;  //clear error state
  912.         return 0;
  913.     }
  914.     return 1;
  915. }
  917. void CMD0(void)
  918. {
  919.     //-- Make card idle state 
  920.     rSDICARG=0x0;     // CMD0(stuff bit)
  921.     rSDICCON=(1<<8)|0x40;   // No_resp, start, CMD0
  923.     //-- Check end of CMD0
  924.     Chk_CMDend(0, 0);
  925.     rSDICSTA=0x800;     // Clear cmd_end(no rsp)
  926. }
  928. int Chk_MMC_OCR(void)
  929. {
  930.     int i;
  933.     //-- Negotiate operating condition for MMC, it makes card ready state
  934.     for(i=0;i<100;i++) //Negotiation time is dependent on CARD Vendors.
  935.     {
  936. //     rSDICARG=0xffc000;          //CMD1(MMC OCR:2.6V~3.6V)
  937. rSDICARG=0xff8000;          //CMD1(SD OCR:2.7V~3.6V)
  938.      rSDICCON=(0x1<<9)|(0x1<<8)|0x41;    //sht_resp, wait_resp, start, CMD1
  940.      //-- Check end of CMD1
  941. //  if(Chk_CMDend(1, 1) & rSDIRSP0==0x80ffc000) //[31]:Card Power up status bit (busy)
  942. //0xffc000 is Voltage window
  943. if(Chk_CMDend(1, 1) && (rSDIRSP0>>16)==0x80ff) //YH 0903 [31]:Card Power up status bit (busy)
  944. // if(Chk_CMDend(1, 1) & rSDIRSP0==0x80ff8000) 
  945. {
  946.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  947.     return 1; // Success
  948. }
  949.     }
  950.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  951.     return 0; // Fail
  952. }
  954. int Chk_SD_OCR(void)
  955. {
  956.     int i,j=0;
  958.     //-- Negotiate operating condition for SD, it makes card ready state
  959.     for(i=0;i<50;i++) //If this time is short, init. can be fail.
  960.     {
  961.      CMD55();    // Make ACMD
  963.      rSDICARG=0xff8000; //ACMD41(SD OCR:2.7V~3.6V)
  964. //     rSDICARG=0xffc000; //ACMD41(MMC OCR:2.6V~3.6V)
  965.      rSDICCON=(0x1<<9)|(0x1<<8)|0x69;//sht_resp, wait_resp, start, ACMD41
  967. //-- Check end of ACMD41
  968.      if( Chk_CMDend(41, 1) & rSDIRSP0==0x80ff8000 ) 
  969. {
  970.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  972.     return 1; // Success     
  973. }
  974. Delay(200); // Wait Card power up status
  975.     }
  976.     //Uart_Printf("SDIRSP0=0x%xn",rSDIRSP0);
  977.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  978.     return 0; // Fail
  979. }
  981. int CMD55(void)
  982. {
  983.     //--Make ACMD
  984.     rSDICARG=RCA<<16; //CMD7(RCA,stuff bit)
  985.     rSDICCON=(0x1<<9)|(0x1<<8)|0x77; //sht_resp, wait_resp, start, CMD55
  987.     //-- Check end of CMD55
  988.     if(!Chk_CMDend(55, 1)) 
  989. return 0;
  991.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  992.     return 1;
  993. }
  995. int CMD13(void)//SEND_STATUS
  996. {
  997.     int response0;
  999.     rSDICARG=RCA<<16; // CMD13(RCA,stuff bit)
  1000.     rSDICCON=(0x1<<9)|(0x1<<8)|0x4d; // sht_resp, wait_resp, start, CMD13
  1002.     //-- Check end of CMD13
  1003.     if(!Chk_CMDend(13, 1)) 
  1004. return 0;
  1005.     //Uart_Printf("rSDIRSP0=0x%xn", rSDIRSP0);
  1006.     if(rSDIRSP0&0x100)
  1007. //Uart_Printf("Ready for Datan");
  1008. //    else 
  1009. //Uart_Printf("Not Readyn");
  1010.     response0=rSDIRSP0;
  1011.     response0 &= 0x3c00;
  1012.     response0 = response0 >> 9;
  1013.     //Uart_Printf("Current Status=%dn", response0);
  1014.     if(response0==6)
  1015. Test_SDI();
  1017.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  1018.     return 1;
  1019. }
  1021. int CMD9(void)//SEND_CSD
  1022. {
  1023.     rSDICARG=RCA<<16; // CMD9(RCA,stuff bit)
  1024.     rSDICCON=(0x1<<10)|(0x1<<9)|(0x1<<8)|0x49; // long_resp, wait_resp, start, CMD9
  1026.     Uart_Printf("n****CSD register****n");
  1027.     //-- Check end of CMD9
  1028.     if(!Chk_CMDend(9, 1)) 
  1029. return 0;
  1031.     Uart_Printf(" SDIRSP0=0x%xn SDIRSP1=0x%xn SDIRSP2=0x%xn SDIRSP3=0x%xn", rSDIRSP0,rSDIRSP1,rSDIRSP2,rSDIRSP3);
  1032.     return 1;
  1033. }
  1035. void Set_1bit_bus(void)
  1036. {
  1037.     Wide=0;
  1038.     if(!MMC)
  1039. SetBus();
  1040.     Uart_Printf("n****1bit bus****n");
  1041. }
  1043. void Set_4bit_bus(void)
  1044. {
  1045.     Wide=1;
  1046.     SetBus();
  1047.     Uart_Printf("n****4bit bus****n");
  1048. }
  1050. void SetBus(void)
  1051. {
  1052. SET_BUS:
  1053.     CMD55(); // Make ACMD
  1054.     //-- CMD6 implement
  1055.     rSDICARG=Wide<<1;     //Wide 0: 1bit, 1: 4bit
  1056.     rSDICCON=(0x1<<9)|(0x1<<8)|0x46; //sht_resp, wait_resp, start, CMD55
  1058.     if(!Chk_CMDend(6, 1))   // ACMD6
  1059. goto SET_BUS;
  1060.     rSDICSTA=0xa00;     // Clear cmd_end(with rsp)
  1061. }
  1063. void Set_Prt(void)
  1064. {
  1065.     //-- Set protection addr.0 ~ 262144(32*16*512) 
  1066.     Uart_Printf("[Set protection(addr.0 ~ 262144) test]n");
  1068. RECMD28:
  1069.     //--Make ACMD
  1070.     rSDICARG=0;     // CMD28(addr) 
  1071.     rSDICCON=(0x1<<9)|(0x1<<8)|0x5c; //sht_resp, wait_resp, start, CMD28
  1073.     //-- Check end of CMD28
  1074.     if(!Chk_CMDend(28, 1)) 
  1075. goto RECMD28;
  1076.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  1077. }
  1079. void Clr_Prt(void)
  1080. {
  1081.     //-- Clear protection addr.0 ~ 262144(32*16*512) 
  1082.     //Uart_Printf("[Clear protection(addr.0 ~ 262144) test]n");
  1084. RECMD29:
  1085.     //--Make ACMD
  1086.     rSDICARG=0;     // CMD29(addr)
  1087.     rSDICCON=(0x1<<9)|(0x1<<8)|0x5d; //sht_resp, wait_resp, start, CMD29
  1089.     //-- Check end of CMD29
  1090.     if(!Chk_CMDend(29, 1)) 
  1091. goto RECMD29;
  1092.     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
  1093. }