mini2440中SD卡測試源碼閱讀筆記
 
 
 
      SD卡讀寫包括兩種模式：SD模式和SPI模式。其中SD模式又可以分為1bit和4bit兩種傳輸模式。SD卡缺省使用專有的SD模式。SD卡規范中主要講了一些命令，響應和CRC效驗等等，整個規范的內容還是很多的。

 SD卡上電后，卡處于空閑狀態，主機發送CMD0復位SD卡，然后通過CMD55和ACMD41判斷當前電壓是否在卡的工作范圍內。在得到了正確的響應后，主機可以繼續通過CMD10讀取SD卡的CID寄存器，通過CMD16設置數據塊長度，通過CMD9讀取卡的CSD寄存器。從CSD寄存器中，主機可以獲知卡容量，支持的命令集等重要參數。此時，卡以進入了傳輸狀態，主機就可以通過CMD17/18和CMD24/25對卡進行讀寫。CRC校驗是為了防止SD卡的命令，應答，數據傳輸出現錯誤。每個命令和應答信號都會產生CRC效驗碼，每個數據塊的傳輸也會長生CRC效驗碼。

這段程序是友善之臂推出的mini2440開發板中帶的ADS測試源碼。整個閱讀代碼的過程是對這S3C2440的芯片手冊和SD卡規范來看的，對于MMC卡沒有給出注釋，其實和SD卡是大同小異。由于是初次接觸ARM，對SD規范的認識也不是很深入，再加上自己水平有限，還不能完全讀懂源代碼，其中的肯定存在一些錯誤，歡迎大家一起交流討論。

 

#include <stdio.h>
#include <string.h>
#include "def.h"
#include "option.h"
#include "2440addr.h"
#include "2440lib.h"
#include "sdi.h"


#define INICLK 300000
#define SDCLK 24000000 //PCLK=49.392MHz

#define MMCCLK 15000000 //PCLK=49.392MHz

#define POL 0
#define INT 1
#define DMA 2
int CMD13(void); // Send card status

int CMD9(void);

unsigned int *Tx_buffer; //128[word]*16[blk]=8192[byte]

unsigned int *Rx_buffer; //128[word]*16[blk]=8192[byte]

volatile unsigned int rd_cnt;//讀數據計數器

volatile unsigned int wt_cnt;//寫數據計數器

volatile unsigned int block; //讀寫塊總數

volatile unsigned int TR_end=0;
int Wide=0; // 0:1bit, 1:4bit

int MMC=0; // 0:SD , 1:MMC

int Maker_ID;
char Product_Name[7]; 
int Serial_Num;
volatile int RCA;
void Test_SDI(void)
{
 U32 save_rGPEUP, save_rGPECON;
    RCA=0;
    MMC=0;
    block=3072; //3072Blocks=1.5MByte, ((2Block=1024Byte)*1024Block=1MByte)

 save_rGPEUP=rGPEUP;
 save_rGPECON=rGPECON;
 //**配置SD/MMC控制器

    rGPEUP = 0xf83f; // SDCMD, SDDAT[3:0] => PU En.

    rGPECON = 0xaaaaaaaa; //SDCMD, SDDAT[3:0]

    Uart_Printf("\nSDI Card Write and Read Test\n");
    if(!SD_card_init()) //等待SD卡初始化完成

 return;
    TR_Buf_new();//發送數據緩沖區初始化

    Wt_Block();//寫卡

    Rd_Block();//讀卡

    View_Rx_buf();
    if(MMC)
 TR_Buf_new();
    if(MMC)
    {
  rSDICON |=(1<<5); // YH 0519, MMC Type SDCLK

  Wt_Stream();
  Rd_Stream();
  View_Rx_buf();
    }
    Card_sel_desel(0); // Card deselect

    if(!CMD9())
 Uart_Printf("Get CSD fail!!!\n");
    rSDIDCON=0;//tark???

    rSDICSTA=0xffff;
 rGPEUP=save_rGPEUP;
 rGPECON=save_rGPECON; 
}
void TR_Buf_new(void) //發送數據緩沖區初始化

{
    //-- Tx & Rx Buffer initialize

    int i, j;
    Tx_buffer=(unsigned int *)0x31000000;
    j=0;
    for(i=0;i<2048;i++) //128[word]*16[blk]=8192[byte]

 *(Tx_buffer+i)=i+j;
    Flush_Rx_buf();
}
void Flush_Rx_buf(void) //接收數據緩沖區清0

{
    //-- Flushing Rx buffer 

    int i;
    Rx_buffer=(unsigned int *)0x31800000;
    for(i=0;i<2048;i++) //128[word]*16[blk]=8192[byte]

 *(Rx_buffer+i)=0;
    Uart_Printf("End Rx buffer flush\n");
}
void View_Rx_buf()
{
    //-- Display Rx buffer 

    int i,error=0;
    Tx_buffer=(unsigned int *)0x31000000;
    Rx_buffer=(unsigned int *)0x31800000;
    Uart_Printf("Check Rx data\n");
    for(i=0;i<128*block;i++)
    {
        if(Rx_buffer[i] != Tx_buffer[i])
  {
      Uart_Printf("\nTx/Rx error\n"); 
      Uart_Printf("%d:Tx-0x%08x, Rx-0x%08x\n",i,Tx_buffer[i], Rx_buffer[i]);
      error=1;
      break;
        }
    }
    
    if(!error)
    {
  Uart_Printf("\nThe Tx_buffer is same to Rx_buffer!\n");
  Uart_Printf("SD CARD Write and Read test is OK!\n");
 }
}
void View_Tx_buf(void)
{
}
int SD_card_init(void) //SD卡初始化

{
//-- SD controller & card initialize 

    int i;
    /* Important notice for MMC test condition */
    /* Cmd & Data lines must be enabled by pull up resister */
    rSDIPRE=PCLK/(INICLK)-1; // 400KHz

 Uart_Printf("Init. Frequency is %dHz\n",(PCLK/(rSDIPRE+1)));
    
 rSDICON=(1<<4)|1; //先傳高位，再傳低位，使能CLK

 rSDIFSTA=rSDIFSTA|(1<<16); //SDI FIFO status register，FIFO復位

    rSDIBSIZE=0x200; // SDI block size register，設置每塊大小為512byte(128word)

    rSDIDTIMER=0x7fffff; // SDI data / busy timer register，設置超時周期

    for(i=0;i<0x1000;i++); // 延時，CARD自身初始化需要74個CLK

    CMD0(); //發送CMD0

    Uart_Printf("In idle\n");
    //-- Check MMC card OCR

    if(Chk_MMC_OCR()) 
    {
 Uart_Printf("In MMC ready\n");
 MMC=1;
 goto RECMD2;
    }
    Uart_Printf("MMC check end!!\n");
    //-- Check SD card OCR

    if(Chk_SD_OCR()) 
        Uart_Printf("In SD ready\n");
    else
    {
  Uart_Printf("Initialize fail\nNo Card assertion\n");
        return 0;
    }
RECMD2:
//檢查連接的卡，識別卡的狀態

    rSDICARG=0x0; // CMD2(stuff bit)

rSDICCON=(0x1<<10)|(0x1<<9)|(0x1<<8)|0x42; //CMD2為長應答并等待應答,開始發

//送CMD2,命令卡發回CID寄存器(保存了生產廠家/時間/批號等等),產生RSP2

   //檢查CMD2是否成功發送并收到響應

    if(!Chk_CMDend(2, 1)) 
 goto RECMD2; //CMD2出錯，重新發送

    rSDICSTA=0xa00; // 清除命令和應答結束標志位

    Uart_Printf("End id\n");
RECMD3:
    //--發送CMD3，給卡分配RCA,

    rSDICARG=MMC<<16; //CMD3參數， MMC：設置 RCA, SD：請求發RCA

rSDICCON=(0x1<<9)|(0x1<<8)|0x43; //CMD3為短應答并等待應答,開始發

//送CMD3, MMC（設置RCA,產生RSP1）,SD（設置RCA,產生RSP6）

   //檢查CMD3是否成功發送并收到響應

    if(!Chk_CMDend(3, 1)) 
 goto RECMD3; //CMD3出錯，重新發送

    rSDICSTA=0xa00; // 清除命令和應答結束標志位

    //--Publish RCA

    if(MMC) {
     RCA=1;
        rSDIPRE=(PCLK/MMCCLK)-1; 
        Uart_Printf("MMC Frequency is %dHz\n",(PCLK/(rSDIPRE+1)));
     }
    else 
     {
   RCA=( rSDIRSP0 & 0xffff0000 )>>16; //回讀RCA,卡被分配RCA后進入//TransferMODE,準備讀寫

      Uart_Printf("RCA=0x%x\n",RCA);
   rSDIPRE=PCLK/(SDCLK)-1; // Normal clock=25MHz

   Uart_Printf("SD Frequency is %dHz\n",(PCLK/(rSDIPRE+1)));
     } //--State(stand-by) check

//根據SD規范，rSDIRSP0高16位存儲RCA，低16位存儲CARD的狀態

    if( rSDIRSP0 & 0x1e00!=0x600 ) // 檢查CARD狀態，不是處于stand-by狀態

 goto RECMD3; ////未就緒，重新發送CMD3 

    Uart_Printf("In stand-by\n");
    
    Card_sel_desel(1); // Select

    if(!MMC) //若位SD卡，設置4bit的數據傳輸模式

 Set_4bit_bus();
    else //若位MMC卡，設置1bit的數據傳輸模式

 Set_1bit_bus();
    return 1;
}
void Card_sel_desel(char sel_desel)
{
    //-- Card select or deselect

    if(sel_desel) //選擇該卡

    {
RECMDS7: //送CMD7表示選擇該卡,準備讀寫,產生RSP1.

 rSDICARG=RCA<<16; // CMD7參數（RCA,stuff bit)，其中高16位為RCA

 rSDICCON= (0x1<<9)|(0x1<<8)|0x47; //CMD7為短應答并等待應答,開始發

//送CMD7選擇該卡,準備讀寫,產生RSP1

    //檢查CMD7是否成功發送并收到響應

 if(!Chk_CMDend(7, 1))
     goto RECMDS7; //出錯，重新發送

 rSDICSTA=0xa00; //清除命令和應答結束標志位

 //檢查是否處于transfer mode

 if( rSDIRSP0 & 0x1e00!=0x800 ) 
     goto RECMDS7; //不處于transfer mode，重新發送CMD7

    }
    else //卸載該卡

    {
RECMDD7: 
 rSDICARG=0<<16; // CMD7參數（RCA,stuff bit)，其中高16位為RCA

 rSDICCON=(0x1<<8)|0x47; // 無應答并,并開始發送CMD7

  //檢查CMD7是否成功

 if(!Chk_CMDend(7, 0))
     goto RECMDD7; //失敗,重新卸載

 rSDICSTA=0x800; // //清除命令結束標志位

    }
}
void __irq Rd_Int(void) //讀中斷函數

{
    U32 i,status;
    status=rSDIFSTA;
    if( (status&0x200) == 0x200 ) //檢查接收FIFO最后是否有數據到來

    {
 for(i=(status & 0x7f)/4;i>0;i--)
 {
     *Rx_buffer++=rSDIDAT;
     rd_cnt++;
 }
 rSDIFSTA=rSDIFSTA&0x200; //清 Rx FIFO Last data Ready標志位

    }
    else if( (status&0x80) == 0x80 )// 檢查Half FULL interrupt標志，只要大于31個字節，就會將該標志置1

    {
        for(i=0;i<8;i++)
        {
         *Rx_buffer++=rSDIDAT;
     rd_cnt++;
 }
    }
    ClearPending(BIT_SDI);//清零源中斷掛起寄存器和中斷掛起寄存器

}
void __irq Wt_Int(void) //寫中斷函數

{
    ClearPending(BIT_SDI);//清零源中斷掛起寄存器和中斷掛起寄存器

    rSDIDAT=*Tx_buffer++;
    wt_cnt++;
    if(wt_cnt==128*block)
    {
 rINTMSK |= BIT_SDI;//屏蔽BIT_SDI中斷

 rSDIDAT=*Tx_buffer;
 TR_end=1;
    }
}
void __irq DMA_end(void)
{
    ClearPending(BIT_DMA0);//清零源中斷掛起寄存器和中斷掛起寄存器

    
    TR_end=1;
}
void Rd_Block(void)
{
    U32 mode;
    int status;
    rd_cnt=0; 
    Uart_Printf("Block read test[ Polling read ]\n");

 mode = 0 ;
 rSDIFSTA=rSDIFSTA|(1<<16); // 復位FIFO

    if(mode!=2)
 rSDIDCON=(2<<22)|(1<<19)|(1<<17)|(Wide<<16)|(1<<14)|(2<<12)|(block<<0); //YH 040220

//設置數據控制寄存器：字傳輸，塊數據傳輸，4bit數據傳輸，開始數據傳輸，數據發送模//式，共讀block個塊 

    rSDICARG=0x0; // CMD17/18地址參數

RERDCMD:
    switch(mode)
    {
 case POL:
     if(block<2) // SINGLE_READ寫單塊

     {
  rSDICCON=(0x1<<9)|(0x1<<8)|0x51; //CMD17為短應答并等待應答,開始發

//送CMD17單塊讀命令，開始讀,產生RSP1

  if(!Chk_CMDend(17, 1)) //-- Check end of CMD17

      goto RERDCMD; //失敗，繼續發送 

     }
     else // MULTI_READ，讀多塊

     {
  rSDICCON=(0x1<<9)|(0x1<<8)|0x52; //CMD18為短應答并等待應答,開始發

//送CMD18多塊讀命令，開始讀,產生RSP1

  if(!Chk_CMDend(18, 1)) //-- Check end of CMD18 

      goto RERDCMD; //失敗，繼續發送 

     }
     rSDICSTA=0xa00; // 清命令和應答結束標志 

     while(rd_cnt<128*block) // 512塊個字節

     {
  if((rSDIDSTA&0x20)==0x20) // 是否超時

  {
      rSDIDSTA=(0x1<<0x5); // 清超時標志位

      break;
  }
  status=rSDIFSTA;
  if((status&0x1000)==0x1000) // FIFO非空

  {
      *Rx_buffer++=rSDIDAT;
      rd_cnt++;
  }
     }
     break;
 
 case INT:
     pISR_SDI=(unsigned)Rd_Int;
     rINTMSK = ~(BIT_SDI);//屏蔽除所有其他中斷

     
     rSDIIMSK=5; // 開啟Last & Rx FIFO half 中斷.

     if(block<2) // SINGLE_READ

     {
  rSDICCON=(0x1<<9)|(0x1<<8)|0x51; //CMD17為短應答并等待應答,開始發

//送CMD17單塊讀命令，開始讀,產生RSP1

  if(!Chk_CMDend(17, 1)) //-- Check end of CMD17

      goto RERDCMD; //失敗，繼續發送 

     }
     else // MULTI_READ

     {
  rSDICCON=(0x1<<9)|(0x1<<8)|0x52; //CMD18為短應答并等待應答,開始發

//送CMD18多塊讀命令，開始讀,產生RSP1

  if(!Chk_CMDend(18, 1)) //-- Check end of CMD18 

      goto RERDCMD; //失敗，繼續發送 

     }
    
     rSDICSTA=0xa00; // 清命令和應答結束標志 

     while(rd_cnt<128*block);
     rINTMSK |= (BIT_SDI);//屏蔽BIT_SDI中斷

     rSDIIMSK=0; //屏蔽所有中斷

     break;
 case DMA:
     pISR_DMA0=(unsigned)DMA_end;
     rINTMSK = ~(BIT_DMA0);
  rSDIDCON=rSDIDCON|(1<<24); //YH 040227, Burst4 Enable

     rDISRC0=(int)(SDIDAT); // SDIDAT

     rDISRCC0=(1<<1)+(1<<0); // APB, fix

     rDIDST0=(U32)(Rx_buffer); // Rx_buffer

     rDIDSTC0=(0<<1)+(0<<0); // AHB, inc

     rDCON0=(1<<31)+(0<<30)+(1<<29)+(0<<28)+(0<<27)+(2<<24)+(1<<23)+(1<<22)+(2<<20)+128*block;
     rDMASKTRIG0=(0<<2)+(1<<1)+0; //no-stop, DMA2 channel on, no-sw trigger 

     rSDIDCON=(2<<22)|(1<<19)|(1<<17)|(Wide<<16)|(1<<15)|(1<<14)|(2<<12)|(block<<0);
     if(block<2) // SINGLE_READ

     {
  rSDICCON=(0x1<<9)|(0x1<<8)|0x51; // sht_resp, wait_resp, dat, start, CMD17

  if(!Chk_CMDend(17, 1)) //-- Check end of CMD17

      goto RERDCMD; 
     }
     else // MULTI_READ

     {
  rSDICCON=(0x1<<9)|(0x1<<8)|0x52; // sht_resp, wait_resp, dat, start, CMD18

  if(!Chk_CMDend(18, 1)) //-- Check end of CMD18 

      goto RERDCMD;
     }
     rSDICSTA=0xa00; // Clear cmd_end(with rsp)

     while(!TR_end);
  //Uart_Printf("rSDIFSTA=0x%x\n",rSDIFSTA);

     rINTMSK |= (BIT_DMA0);
     TR_end=0;
     rDMASKTRIG0=(1<<2); //DMA0 stop

     break;
 default:
     break;
    }
    //-- Check end of DATA

    if(!Chk_DATend()) 
 Uart_Printf("dat error\n");
 rSDIDCON=rSDIDCON&~(7<<12); 
 rSDIFSTA=rSDIFSTA&0x200; //Clear Rx FIFO Last data Ready, YH 040221

    rSDIDSTA=0x10; // Clear data Tx/Rx end detect

    if(block>1)
    {
RERCMD12: 
 //--Stop cmd(CMD12)

 rSDICARG=0x0; //CMD12(stuff bit)

 rSDICCON=(0x1<<9)|(0x1<<8)|0x4c;//sht_resp, wait_resp, start, CMD12

 //-- Check end of CMD12

 if(!Chk_CMDend(12, 1)) 
     goto RERCMD12;
 rSDICSTA=0xa00; // Clear cmd_end(with rsp)

    }
}

void Rd_Stream(void) // only for MMC, 3blk read

{
    int status, rd_cnt=0;
    if(MMC!=1)
    {
 Uart_Printf("Stream read command supports only MMC!\n");
 return;
    } 
    Uart_Printf("\n[Stream read test]\n");
    
RECMD11:
   rSDIDCON=(2<<22)|(1<<19)|(0<<17)|(0<<16)|(1<<14)|(2<<12);

    rSDICARG=0x0; // CMD11(addr)

    rSDICCON=(0x1<<9)|(0x1<<8)|0x4b; //sht_resp, wait_resp, dat, start, CMD11

    while(rd_cnt<128*block)
    {
 if( (rSDIDSTA&0x20) == 0x20 )
 {
     Uart_Printf("Rread timeout error");
     return ;
 }
     
 status=rSDIFSTA;
 if((status&0x1000)==0x1000)
 {
     //*Rx_buffer++=rSDIDAT;

     //rd_cnt++;

     Rx_buffer[rd_cnt++]=rSDIDAT;
 }
    }
    //-- Check end of CMD11

    if(!Chk_CMDend(11, 1)) 
 goto RECMD11;
    rSDICSTA=0xa00; // Clear cmd_end(with rsp)

    //-- Check end of DATA

    rSDIDCON=(2<<22)|(1<<19)|(0<<17)|(0<<16); //YH 040220

    rSDIDCON=rSDIDCON&~(7<<12); //YH 040220, no operation, data ready

    while( rSDIDSTA&0x3 !=0x0 );
    if(rSDIDSTA!=0) 
 Uart_Printf("rSDIDSTA=0x%x\n", rSDIDSTA);
    rSDIDSTA=0xff; //YH 040221

STRCMD12: 
    //--Stop cmd(CMD12)

    rSDICARG=0x0; //CMD12(stuff bit)

    rSDICCON=(0x1<<9)|(0x1<<8)|0x4c; //sht_resp, wait_resp, start, CMD12

    //-- Check end of CMD12