这些小活动你都参加了吗?快来围观一下吧!>>
电子产品世界 » 论坛首页 » DIY与开源设计 » 电子DIY » mini2440 中SD卡测试源码阅读笔记

共5条 1/1 1 跳转至

mini2440 中SD卡测试源码阅读笔记

工程师
2013-03-05 20:18:34     打赏

      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
 
    if(!Chk_CMDend(12, 1)) 
 goto STRCMD12;
    rSDICSTA=0xa00; // Clear cmd_end(with rsp)
 
    rSDIFSTA=rSDIFSTA&0x200;  //Clear Rx FIFO Last data Ready, YH 040221
 
 
 Uart_Printf("rSDIFSTA1=0x%x\n", rSDIFSTA); //YH 040221
 
   rSDIFSTA=rSDIFSTA&0x200;  //Clear Rx FIFO Last data Ready, YH 040221
 
 Uart_Printf("rSDIFSTA2=0x%x\n", rSDIFSTA); //YH 040221
 
    Uart_Printf("\n--End stream read test\n");
}
 void Wt_Block(void)
{
    U32 mode;
    int status;
    wt_cnt=0; 
    Uart_Printf("Block write test[ Polling write ]\n"); 
 mode = 0 ;
 rSDIFSTA=rSDIFSTA|(1<<16); //复位 FIFO
 
    if(mode!=2)
 rSDIDCON=(2<<22)|(1<<20)|(1<<17)|(Wide<<16)|(1<<14)|(3<<12)|(block
<<0); 
//设置数据控制寄存器:字传输,块数据传输,4bit 数据传输,开始数据传输,
数据发送模//式,共写 block 个块 
 
    rSDICARG=0x0; // CMD24/25 地址参数
 
REWTCMD:
    switch(mode)
    {
 case POL:
     if(block<2) // SINGLE_WRITE,写单块
 
     {
  rSDICCON=(0x1<<9)|(0x1<<8)|0x58; //CMD24 为短应答并等待应答,开始发
 
//送 CMD24 单块写命令,开始写,产生 RSP1
 
  if(!Chk_CMDend(24, 1)) //-- Check end of CMD24 
      goto REWTCMD; //命令发送失败
 
     }
     else // MULTI_WRITE,写多块
 
     {
 rSDICCON=(0x1<<9)|(0x1<<8)|0x59; //CMD25 为短应答并等待应答,开发
 
//送 CMD25 多块写命令,开始读写,产生 RSP1
 
   if(!Chk_CMDend(25, 1)) //-- Check end of CMD25
 
   goto REWTCMD; //命令发送失败
 
     }
     rSDICSTA=0xa00; // 清命令和应答结束标志 
 
     while(wt_cnt<128*block)
     {
  status=rSDIFSTA;
  if((status&0x2000)==0x2000) //FIFO 未满
 
  {
      rSDIDAT=*Tx_buffer++;
      wt_cnt++;
   //Uart_Printf("Block No.=%d, wt_cnt=%d\n",block,wt_cnt);
 
  }      }
     break;
 
 case INT:
     pISR_SDI=(unsigned)Wt_Int;
     rINTMSK = ~(BIT_SDI);
     rSDIIMSK=0x10; // Tx FIFO half int.
 
     if(block<2) // SINGLE_WRITE
 
     {
  rSDICCON=(0x1<<9)|(0x1<<8)|0x58;  //sht_resp, wait_resp, dat, start,
CMD24
 
  if(!Chk_CMDend(24, 1)) //-- Check end of CMD24
 
      goto REWTCMD;
     }
     else // MULTI_WRITE
 
     {
  rSDICCON=(0x1<<9)|(0x1<<8)|0x59;  //sht_resp, wait_resp, dat, start,
CMD25
 
  if(!Chk_CMDend(25, 1)) //-- Check end of CMD25 
 
      goto REWTCMD;
     }
     rSDICSTA=0xa00; // Clear cmd_end(with rsp) 
     while(!TR_end);
     //while(wt_cnt<128);
 
     rINTMSK |= (BIT_SDI);
     TR_end=0;
     rSDIIMSK=0; // All mask
 
     break;
 case DMA:
     pISR_DMA0=(unsigned)DMA_end;
     rINTMSK = ~(BIT_DMA0);
  rSDIDCON=rSDIDCON|(1<<24); //YH 040227, Burst4 Enable
 
     rDISRC0=(int)(Tx_buffer); // Tx_buffer
 
     rDISRCC0=(0<<1)+(0<<0); // AHB, inc
 
     rDIDST0=(U32)(SDIDAT); // SDIDAT
 
     rDIDSTC0=(1<<1)+(1<<0); // APB, fix
 
     rDCON0=(1<<31)+(0<<30)+(1<<29)+(0<<28)+(0<<27)+(2<<24)+(1<<23)
+(1<<22)+(2<<20)+128*block;
     //handshake, sync PCLK, TC int, single tx, single service, SDI,
H/W request, 
 
     //auto-reload off, word, 128blk*num
      rDMASKTRIG0=(0<<2)+(1<<1)+0; //no-stop, DMA0 channel on, no-sw
trigger
 
     
  rSDIDCON=(2<<22)|(1<<20)|(1<<17)|(Wide<<16)|(1<<15)|(1<<14)|(3<<1
2)|(block<<0); //YH 040220
 
      // Word Tx, Tx after rsp, blk, 4bit bus, dma enable, Tx start,
blk num
 
     if(block<2) // SINGLE_WRITE
 
     {
  rSDICCON=(0x1<<9)|(0x1<<8)|0x58;  //sht_resp, wait_resp, dat, start,
CMD24
 
  if(!Chk_CMDend(24, 1)) //-- Check end of CMD24
 
      goto REWTCMD; 
     }
     else // MULTI_WRITE
 
     {
  rSDICCON=(0x1<<9)|(0x1<<8)|0x59;  //sht_resp, wait_resp, dat, start,
CMD25
 
  if(!Chk_CMDend(25, 1)) //-- Check end of CMD25 
 
      goto REWTCMD;       }
     rSDICSTA=0xa00; // Clear cmd_end(with rsp)
 
     while(!TR_end); 
     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); //YH 040220, Clear Data Transfer mode =>
no operation, Cleata Data Transfer start
 
    rSDIDSTA=0x10; // Clear data Tx/Rx end
 
    if(block>1)
    {
 //--Stop cmd(CMD12)
 
REWCMD12: 
 rSDIDCON=(1<<18)|(1<<17)|(0<<16)|(1<<14)|(1<<12)|(block<<0); //YH
040220 
 
 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 REWCMD12;
 rSDICSTA=0xa00; // Clear cmd_end(with rsp)
 
 //-- Check end of DATA(with busy state)
 
 if(!Chk_BUSYend()) 
     Uart_Printf("error\n");
 rSDIDSTA=0x08; //! Should be cleared by writing '1'.
 
    }
}
void Wt_Stream(void) // only for MMC, 3blk write
 
{
    int status, wt_cnt=0;
    if(MMC!=1)
    {
 Uart_Printf("Stream write command supports only MMC!\n");
 return;
    }     Uart_Printf("\n[Stream write test]\n");
RECMD20:
    rSDIDCON=(2<<22)|(1<<20)|(0<<17)|(0<<16)|(1<<14)|(3<<12); //
stream mode
 
 
    rSDICARG=0x0; // CMD20(addr)
 
    rSDICCON=(0x1<<9)|(0x1<<8)|0x54; //sht_resp, wait_resp, dat,
start, CMD20
 
    //-- Check end of CMD25
 
    if(!Chk_CMDend(20, 1)) 
 goto RECMD20;
    rSDICSTA=0xa00; // Clear cmd_end(with rsp)
 
    while(wt_cnt<128*block)
    {
 status=rSDIFSTA;
 if((status&0x2000)==0x2000) 
     rSDIDAT=Tx_buffer[wt_cnt++];
    }
    //-- Check end of DATA
 
    while( rSDIFSTA&0x400 );
    Delay(10); // for the empty of DATA line(Hardware)
 
    rSDIDCON=(1<<20)|(0<<17)|(0<<16); //YH 040220 
    rSDIDCON=rSDIDCON&~(7<<12); //YH 040220, no operation, data ready
 
    while( (rSDIDSTA&0x3)!=0x0 );
    if(rSDIDSTA!=0x0) 
 Uart_Printf("rSDIDSTA=0x%x\n", rSDIDSTA);
    rSDIDSTA=0xff; //Clear rSDIDSTA
 
STWCMD12: 
    //--Stop cmd(CMD12)
 
    rSDIDCON=(1<<18)|(1<<17)|(0<<16)|(1<<14)|(1<<12);
 
    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 STWCMD12;
    rSDICSTA=0xa00; // Clear cmd_end(with rsp)
 
    //-- Check end of DATA(with busy state)
 
    if(!Chk_BUSYend()) 
 Uart_Printf("error\n");
    rSDIDSTA=0x08;     Uart_Printf("\n--End Stream write test\n");
}
 
int Chk_CMDend(int cmd, int be_resp)
//0: Timeout
 
{
    int finish0;
    if(!be_resp) // 没有应答信号
 
    {
     finish0=rSDICSTA; //读取 SDI command status register,
 
  while((finish0&0x800)!=0x800) // 等待命令结束
 
     finish0=rSDICSTA;
 rSDICSTA=finish0;// 清命令结束标志
 
 return 1; //成功,返回 1
 
    }
    else // 有应答信号
 
    {
     finish0=rSDICSTA; //读取 SDI command status register,
 
 while( !( ((finish0&0x200)==0x200) | ((finish0&0x400)==0x400) )) //
检查超时和应答信号
   finish0=rSDICSTA;
 if(cmd==1 | cmd==41) // CRC no check, CMD9 is a long Resp. command.
 
 {
     if( (finish0&0xf00) != 0xa00 ) // 命令,应答有错,或超时
 
     {
  rSDICSTA=finish0; // 清错误标志
 
  if(((finish0&0x400)==0x400)) // 若超时,返回 0
 
      return 0; 
         }
     rSDICSTA=finish0; // 清命令和应答结束标志
 
 }
 else // 进行 CRC 效验
 
 {
     if( (finish0&0x1f00) != 0xa00 ) // CRC 效验出错
 
     {
  Uart_Printf("CMD%d:rSDICSTA=0x%x, rSDIRSP0=0x%x\n",cmd, rSDICSTA,
rSDIRSP0); //输出对应寄存器的值
 
  rSDICSTA=finish0; // 清除错误标志位
 
  if(((finish0&0x400)==0x400)) // 若超时,返回 0
       return 0; 
         }
     rSDICSTA=finish0;
 }
 return 1;
    }
}
int Chk_DATend(void)
{
    int finish;
    finish=rSDIDSTA;
    while( !( ((finish&0x10)==0x10) | ((finish&0x20)==0x20) )) 
 // 检查数据结束和超时位
 
 finish=rSDIDSTA;
    if( (finish&0xfc) != 0x10 )//数据传输结束
 
    {
        Uart_Printf("DATA:finish=0x%x\n", finish);
        rSDIDSTA=0xec; //清除错误标志
 
        return 0;
    }
    return 1;
}
int Chk_BUSYend(void)
{
    int finish;
    finish=rSDIDSTA;     while( !( ((finish&0x08)==0x08) | ((finish&0x20)==0x20) ))//检查
忙标志位
 
 finish=rSDIDSTA;
    if( (finish&0xfc) != 0x08 )
    {
        Uart_Printf("DATA:finish=0x%x\n", finish);
        rSDIDSTA=0xf4; //清除错误标志
 
        return 0;
    }
    return 1;
}
void CMD0(void) //CMD0 用于对 SD 实现软件复位,不论卡处于何种状态,使
SD 卡处于//空闲状态,等待下一个命令的到来
 
{
    //-- Make card idle state 
 
    rSDICARG=0x0; // ,CMD0(stuff bit)
 
    rSDICCON=(1<<8)|0x40; // 不等待应答信号,命令开始//并再次发送
CMD0 关于 cmd0 定义:0(start_bit)1(cmd 标志)000000(6 位 cmd 编//码)
后面是参数 (无参数就全 0)
 
    //-- Check end of CMD0
 
    Chk_CMDend(0, 0); // 检查命令是否成功发送
     rSDICSTA=0x800; // 清除命令结束标志
 
}
int Chk_MMC_OCR(void)
{
    int i;
 
    //-- MMC 卡识别的等待操作, 使卡处于空闲状态
 
    for(i=0;i<100;i++) //等待的时间取决于厂商
 
    {
// rSDICARG=0xffc000; //CMD1(MMC OCR:2.6V~3.6V), 设置工作电压
 
  rSDICARG=0xff8000; //CMD1(SD OCR:2.7V~3.6V),设置工作电压
 
     rSDICCON=(0x1<<9)|(0x1<<8)|0x41; //CMD1 为短应答并等待应答,开始
发送 CMD1
 
     //-- 检查 CMD1 是否发送成功,并检查卡状态
 
// if(Chk_CMDend(1, 1) & rSDIRSP0==0x80ffc000) //31:忙状态标志位,0
表示忙
 
  //0xffc000 为卡的正常工作电压范围
 
 if(Chk_CMDend(1, 1) && (rSDIRSP0>>16)==0x80ff) //卡处于空闲
 
// if(Chk_CMDend(1, 1) & rSDIRSP0==0x80ff8000)  
 {
     rSDICSTA=0xa00; // 清除命令和应答结束标志位
 
     return 1; // 成功
 
 }
    }
    rSDICSTA=0xa00; //清除命令和应答结束标志位
 
    return 0; // 失败
 
}
int Chk_SD_OCR(void)
{
    int i;
     //-- SD 卡识别的等待操作, 使卡处于空闲状态
 
for(i=0;i<50;i++) // 如果这段时间太短,SD 卡的初始化可能会失败
 
   {
     CMD55();  //送 CMD55,表示下个命令将是特殊功能命令 acmd,而非一般命
令 cmd
 
     rSDICARG=0xff8000; //ACMD41(SD OCR:2.7V~3.6V) ,设置工作电压
 
// rSDICARG=0xffc000;//ACMD41(MMC OCR:2.6V~3.6V)设置工作电压
rSDICCON=(0x1<<9)|(0x1<<8)|0x69;// ACMD41 为短应答并等待应答,开始发
 //送 ACMD41,命令卡发回 OCR 寄存器(保存了电压参数/busy 信号等等),产生
RSP3
 
    //-- 检查 ACMD41 是否发送成功,并检查卡状态 
 
 if( Chk_CMDend(41, 1) & rSDIRSP0==0x80ff8000 ) //发送成功并且卡处于
空闲状态
 
 {
     rSDICSTA=0xa00; //清除命令和应答结束标志位
 
     return 1; //成功
 
 }
 Delay(200); //等待卡上电后处于空闲状态
 
    }
    //Uart_Printf("SDIRSP0=0x%x\n",rSDIRSP0);
 
    rSDICSTA=0xa00; //清除命令和应答结束标志位
 
    return 0; // 失败
 
}
int CMD55(void)
{
  //CMD55,表示下个命令将是特殊功能 acmd,而非一般命令 cmd 
 
    rSDICARG=RCA<<16; //CMD55(RCA,stuff bit) 
    rSDICCON=(0x1<<9)|(0x1<<8)|0x77; //CMD55 为短应答(R1)并等待应答,
并开始发送 CMD55
 
     //-- 检查 CMD55 是成功发送
 
    if(!Chk_CMDend(55, 1)) 
 return 0; //出错,返回
 
rSDICSTA=0xa00; ////清除命令和应答结束标志位
 
return 1;
}
int CMD13(void)//送 CMD13,命令卡的当前状态
 
{
    int response0;
    rSDICARG=RCA<<16;// CMD13(RCA,stuff bit),高 16 位为 RCA
 
    rSDICCON=(0x1<<9)|(0x1<<8)|0x4d;//CMD13 为短应答(R1)并等待应答,
并开始发送 CMD13
 
    //-- Check end of CMD13
 
    if(!Chk_CMDend(13, 1)) //-- 检查 CMD13 是成功发送
 
 return 0; //出错,返回
 
    //Uart_Printf("rSDIRSP0=0x%x\n", rSDIRSP0); 
    if(rSDIRSP0&0x100) //数据是否就绪
 
 //Uart_Printf("Ready for Data\n");
 
// else 
 
 //Uart_Printf("Not Ready\n");
 
    response0=rSDIRSP0;
    response0 &= 0x3c00;
    response0 = response0 >> 9;
    //Uart_Printf("Current Status=%d\n", response0);
 
    if(response0==6) //卡处于 receive data state
 
 Test_SDI();
    rSDICSTA=0xa00; //清除命令和应答结束标志位
 
    return 1;
}
int CMD9(void)//送 CMD9,命令卡发回 CSD 寄存器(保存了读写参数/卡的容量
等内容),产生 RSP2
 
{
    rSDICARG=RCA<<16; // CMD9 参数,高 16 位为 RCA
 
    rSDICCON=(0x1<<10)|(0x1<<9)|(0x1<<8)|0x49; //CMD9 为长应答并等待
应答,开始发 
//送 CMD9,产生 RSP2
 
    Uart_Printf("\nCSD register :\n");
    //-- Check end of CMD9
 
    if(!Chk_CMDend(9, 1)) // 检查命令是否成功发送
 
 return 0; //失败则返回
 
    Uart_Printf("SDIRSP0=0x%x\nSDIRSP1=0x%x\nSDIRSP2=0x%x\nSDIRSP3=
0x%x\n", rSDIRSP0,rSDIRSP1,rSDIRSP2,rSDIRSP3);
    return 1;
}
void Set_1bit_bus(void)//设置 1 位数据线
 
{
    Wide=0;
    if(!MMC)
 SetBus();
    //Uart_Printf("\n****1bit bus****\n");
 
}
void Set_4bit_bus(void) //设置 4 位数据线 
 
{
    Wide=1;
    SetBus();
    //Uart_Printf("\n****4bit bus****\n"); 
}
void SetBus(void) //设置数据线宽度
 
{
SET_BUS:
    CMD55(); //CMD55,表示下个命令将是特殊功能 acmd,而非一般命令 cmd 
 
    rSDICARG=Wide<<1; //数据宽度 00: 1bit, 10: 4bit
 
rSDICCON=(0x1<<9)|(0x1<<8)|0x46; //ACMD6 为短应答(R1)并等待应答,并开
始发送
 
// ACMD6 设置数据线宽度位 4bit
 
    if(!Chk_CMDend(6, 1)) // 设置失败,则重新设置
 
 goto SET_BUS;
    rSDICSTA=0xa00; //清除命令和应答结束标志位
 
}
void Set_Prt(void)//写保护
 
{
    //-- Set protection addr.0 ~ 262144(32*16*512) 
 
    Uart_Printf("[Set protection(addr.0 ~ 262144) test]\n");
RECMD28:
    //--Make ACMD 
    rSDICARG=0; // CMD28(addr) 
 
    rSDICCON=(0x1<<9)|(0x1<<8)|0x5c; //sht_resp, wait_resp, start,
CMD28
 
    //-- Check end of CMD28
 
    if(!Chk_CMDend(28, 1)) 
 goto RECMD28;
    rSDICSTA=0xa00; // Clear cmd_end(with rsp)
 
}
void Clr_Prt(void)//清除写保护
 
{
    //-- Clear protection addr.0 ~ 262144(32*16*512) 
 
    //Uart_Printf("[Clear protection(addr.0 ~ 262144) test]\n");
 
RECMD29:
    //--Make ACMD
 
    rSDICARG=0; // CMD29(addr)
 
    rSDICCON=(0x1<<9)|(0x1<<8)|0x5d; //sht_resp, wait_resp, start,
CMD29
 
    //-- Check end of CMD29 
    if(!Chk_CMDend(29, 1)) 
 goto RECMD29;
    rSDICSTA=0xa00; // Clear cmd_end(with rsp)
 
}
   有的代码不涉及 SD 规范,有些代码很相似,所以就没有给出注释,通过 DMA
和中断读部分也没有给出注释,我只关心的是 SD卡的读写的实现。
 
 

 




关键词: mini2440     测试     源码     阅读     笔记     命令         

高工
2013-03-09 12:57:31     打赏
2楼
很好,很详细。这么长的代码贴出来,不容易啊,LZ辛苦了~!

专家
2013-03-15 16:20:33     打赏
3楼
很详细,参考代码也有!

助工
2013-03-24 10:39:24     打赏
4楼
good

助工
2013-03-24 11:14:19     打赏
5楼
luguo

共5条 1/1 1 跳转至

回复

匿名不能发帖!请先 [ 登陆 注册 ]