STM32入门学习笔记之SD卡基础读写实验4

（2）创建sdio_sdcard.c文件，并输入以下代码。

#include "sdio_sdcard.h"
#include "string.h"


SD_CardInfo SDCardInfo ;                                        //SD卡信息
u8 CardType=SDIO_STD_CAPACITY_SD_CARD_V1_1 ;                              //SD卡类型
/***************************************************
Name    :SDIO_Clock_Set
Function  :SDIO发送命令函数
Paramater  :
      cmdindex:命令索引,低六位有效
      waitrsp:期待的相应
        00/10:无响应
        01:短响应
        11:长响应
      arg:参数
Return    :错误代码
***************************************************/
void SDIO_Send_Cmd( u8 cmdindex, u8 waitrsp, u32 arg )
{      
  u32 tmpreg ;
  SDIO->ARG = arg ;
  tmpreg = SDIO->CMD ;
  tmpreg &= 0xFFFFF800 ;                                        //清除index和waitrsp
  tmpreg |= cmdindex&0X3F ;                                      //设置新的index
  tmpreg |= waitrsp<<6 ;                                        //设置新的wait rsp
  tmpreg |= 0<<8 ;                                          //无等待
  tmpreg |= 1<<10 ;                                          //命令通道状态机使能
  SDIO->CMD = tmpreg ;
}
/***************************************************
Name    :SDIO_Send_Data_Cfg
Function  :SDIO发送数据配置函数
Paramater  :
      datatimeout:超时时间设置
      datalen:传输数据长度,低25位有效,必须为块大小的整数倍
      blksize:块大小.实际大小为:2^blksize字节
      dir:数据传输方向
        0:控制器到卡
        1:卡到控制器
Return    :错误代码
***************************************************/
void SDIO_Send_Data_Cfg( u32 datatimeout, u32 datalen, u8 blksize, u8 dir )
{
  u32 tmpreg;
  SDIO->DTIMER = datatimeout ;
  SDIO->DLEN = datalen&0x1FFFFFF ;                                  //低25位有效
  tmpreg = SDIO->DCTRL ; 
  tmpreg &= 0xFFFFFF08 ;                                        //清除之前的设置
  tmpreg |= blksize<<4 ;                                        //设置块大小
  tmpreg |= 0<<2 ;                                          //块数据传输
  tmpreg |= ( dir&0x01 )<<1 ;                                      //方向控制
  tmpreg |= 1<<0 ;                                          //数据传输使能,DPSM状态机
  SDIO->DCTRL = tmpreg ;
}
/***************************************************
Name    :SDIO_Clock_Set
Function  :SDIO时钟初始化设置
Paramater  :
      clkdiv:时钟分频系数
Return    :错误代码
***************************************************/
void SDIO_Clock_Set( u8 clkdiv )
{
  u32 tmpreg = SDIO->CLKCR ;
  tmpreg &= 0xFFFFFF00 ;
  tmpreg |= clkdiv;
  SDIO->CLKCR = tmpreg ;
}
/***************************************************
Name    :CmdError
Function  :检查CMD0的执行状态
Paramater  :None
Return    :错误代码
***************************************************/
SD_Error CmdError()
{
  SD_Error errorstatus = SD_OK ;
  u32 timeout=SDIO_CMD0TIMEOUT ;
  while( timeout-- )
  {
    //命令已发送(无需响应)
    if( SDIO->STA&( 1<<7 ) )
      break ;
  }
  if( timeout==0 )
    return SD_CMD_RSP_TIMEOUT ;
  SDIO->ICR = 0x5FF ;                                          //清除标记
  return errorstatus ;
}
/***************************************************
Name    :CmdResp7Error
Function  :检查R7响应的错误状态
Paramater  :None
Return    :错误代码
***************************************************/
SD_Error CmdResp7Error()
{
  u32 status ;
  u32 timeout = 0x00010000 ;
   while( timeout-- )
  {
    status = SDIO->STA ;
    if( ( status&0x45 )!=0 )                                    //等待接收到应答
      break ;
  }
  //响应超时
   if( ( timeout==0 )||( ( status&0x04 )==0x04 ) )
  {
    //当前卡不是2.0兼容卡,或者不支持设定的电压范围
    SDIO->ICR |= 1<<2 ;                                        //清除命令响应超时标志
    return SD_CMD_RSP_TIMEOUT ;
  }
  //成功接收到响应
  if( ( status&0x40 )==0x40 )
    SDIO->ICR |= 1<<6 ;                                        //清除响应标志
  return SD_OK ;
}
/***************************************************
Name    :CmdResp1Error
Function  :检查R1响应的错误状态
Paramater  :
      cmd:当前命令
Return    :错误代码
***************************************************/
SD_Error CmdResp1Error( u8 cmd )
{    
     u32 status ;
  while( 1 )
  {
    status = SDIO->STA ;
    if( ( status&0x45 )!=0 )                                    //等待接收到应答
      break ;
  }
  //响应超时
  if( ( status&0x04 )==0x04 )
  {
     SDIO->ICR |= 1<<2 ;                                        //清除命令响应超时标志
    return SD_CMD_RSP_TIMEOUT ;
  }
  //CRC错误
   if( ( status&0x01 )==0x01 )
  {
     SDIO->ICR |= 1<<0;                                        //清除标志
    return SD_CMD_CRC_FAIL;
  }
  if( SDIO->RESPCMD!=cmd )
    return SD_ILLEGAL_CMD ;                                      //命令不匹配
    SDIO->ICR = 0x5FF ;                                          //清除标记
  return ( SD_Error )( SDIO->RESP1&0xFDFFE008 ) ;                            //返回卡响应
}
/***************************************************
Name    :CmdResp3Error
Function  :检查R3响应的错误状态
Paramater  :None
Return    :错误代码
***************************************************/
SD_Error CmdResp3Error()
{
  u32 status ;             
   while( 1 )
  {
    status = SDIO->STA ;
    if( ( status&0x45 )!=0 )                                     //等待接收到应答
      break ;
  }
  //响应超时
   if( ( status&0x04 )==0x04 )
  {
    SDIO->ICR |= 1<<2 ;                                        //清除命令响应超时标志
    return SD_CMD_RSP_TIMEOUT ;
  }
     SDIO->ICR = 0x5FF ;                                          //清除标记
   return SD_OK ;
}
/***************************************************
Name    :CmdResp2Error
Function  :检查R2响应的错误状态
Paramater  :None
Return    :错误代码
***************************************************/
SD_Error CmdResp2Error()
{
  u32 status ;
  u32 timeout = 0x00010000 ;
   while( timeout-- )
  {
    status = SDIO->STA ;
    if( ( status&0x45 )!=0 )                                    //接收到R2响应
      break ;
  }
  //响应超时
    if( ( timeout==0 )||( ( status&0x04 )==0x04 ) )
  {
    SDIO->ICR |= 1<<2 ;                                        //清除命令响应超时标志
    return SD_CMD_RSP_TIMEOUT ;
  }
  //CRC错误
  if( ( status&0x01 )==0x01 )
  {
    SDIO->ICR |= 1<<0 ;                                        //清除响应标志
    return SD_CMD_CRC_FAIL ;
   }
  SDIO->ICR = 0x5FF ;                                          //清除标记
   return SD_OK ;
}
/***************************************************
Name    :CmdResp6Error
Function  :检查R6响应的错误状态
Paramater  :
      cmd:之前发送的命令
      prca:卡返回的RCA地址
Return    :错误代码
***************************************************/
SD_Error CmdResp6Error( u8 cmd, u16 *prca )
{
  SD_Error errorstatus=SD_OK ;
  u32 rspr1, status;
   while(1)
  {
    status = SDIO->STA ;
    //CRC错误/命令响应超时/已经收到响应(CRC校验成功)
    if( status&( (1<<0)|(1<<2)|(1<<6) ) )
      break ;
  }
  //响应超时
  if( status&( 1<<2 ) )
  {
     SDIO->ICR |= 1<<2 ;                                        //清除命令响应超时标志
    return SD_CMD_RSP_TIMEOUT ;
  }
  //CRC错误
  if( status&1<<0 )
  {
    SDIO->ICR |= 1<<0 ;                                        //清除响应标志
     return SD_CMD_CRC_FAIL ;
  }
  //判断是否响应cmd命令
  if( SDIO->RESPCMD!=cmd )
     return SD_ILLEGAL_CMD ;
  SDIO->ICR = 0x5FF ;                                          //清除所有标记
  rspr1 = SDIO->RESP1 ;                                        //得到响应
  if( SD_ALLZERO==( rspr1&( SD_R6_GENERAL_UNKNOWN_ERROR|SD_R6_ILLEGAL_CMD|SD_R6_COM_CRC_FAILED ) ) )
  {
    *prca = ( u16 )( rspr1>>16 ) ;                                  //右移16位得到,rca
    return errorstatus ;
  }
     if( rspr1&SD_R6_GENERAL_UNKNOWN_ERROR )
    return SD_GENERAL_UNKNOWN_ERROR ;
     if( rspr1&SD_R6_ILLEGAL_CMD )
    return SD_ILLEGAL_CMD ;
     if( rspr1&SD_R6_COM_CRC_FAILED )
    return SD_COM_CRC_FAILED ;
  return errorstatus ;
}
/***************************************************
Name    :SDIO_IRQHandler
Function  :SDIO中断服务函数
Paramater  :None
Return    :错误代码
***************************************************/
void SDIO_IRQHandler()
{
   //接收完成中断
  if( SDIO->STA&( 1<<8 ) )
  {
    SDIO_Send_Cmd( SD_CMD_STOP_TRANSMISSION, 1, 0 ) ;                        //发送CMD12,结束传输
     SDIO->ICR |= 1<<8 ;                                        //清除完成中断标记
    SDIO->MASK &= ~( ( 1<<1 )|( 1<<3 )|( 1<<8 )|( 1<<14 )|( 1<<15 )|( 1<<4 )|( 1<<5 )|( 1<<9 ) ) ;  //关闭相关中断
  }
  //数据CRC错误
   if( SDIO->STA&( 1<<1 ) )
  {
    SDIO->ICR |= 1<<1 ;                                        //清除中断标记
    SDIO->MASK &= ~( ( 1<<1 )|( 1<<3 )|( 1<<8 )|( 1<<14 )|( 1<<15 )|( 1<<4 )|( 1<<5 )|( 1<<9 ) ) ;  //关闭相关中断
  }
  //数据超时错误
   if( SDIO->STA&( 1<<3 ) )
  {
    SDIO->ICR |= 1<<3 ;                                        //清除中断标记
    SDIO->MASK &= ~( ( 1<<1 )|( 1<<3 )|( 1<<8 )|( 1<<14 )|( 1<<15 )|( 1<<4 )|( 1<<5 )|( 1<<9 ) ) ;  //关闭相关中断
  }
  //FIFO上溢错误
    if( SDIO->STA&( 1<<5 ) )
  {
    SDIO->ICR |= 1<<5 ;                                        //清除中断标记
    SDIO->MASK &= ~( ( 1<<1 )|( 1<<3 )|( 1<<8 )|( 1<<14 )|( 1<<15 )|( 1<<4 )|( 1<<5 )|( 1<<9 ) ) ;  //关闭相关中断
  }
  //FIFO下溢错误
     if( SDIO->STA&( 1<<4 ) )
  {
    SDIO->ICR |= 1<<4 ;                                        //清除中断标记
    SDIO->MASK &= ~( ( 1<<1 )|( 1<<3 )|( 1<<8 )|( 1<<14 )|( 1<<15 )|( 1<<4 )|( 1<<5 )|( 1<<9 ) ) ;  //关闭相关中断
  }
  //起始位错误
  if( SDIO->STA&( 1<<9 ) )
  {
    SDIO->ICR |= 1<<9 ;                                        //清除中断标记
    SDIO->MASK &= ~( ( 1<<1 )|( 1<<3 )|( 1<<8 )|( 1<<14 )|( 1<<15 )|( 1<<4 )|( 1<<5 )|( 1<<9 ) ) ;  //关闭相关中断
  }
}
/***************************************************
Name    :SD_PowerON
Function  :卡上电
Paramater  :None
Return    :错误代码
***************************************************/
SD_Error SD_PowerON()
{
  u8 i=0 ;
  SD_Error errorstatus=SD_OK ;
  u32 response=0, count=0, validvoltage=0 ;
  u32 SDType=SD_STD_CAPACITY ;
  //配置CLKCR寄存器
  SDIO->CLKCR = 0 ;                                          //清空CLKCR之前的设置
  SDIO->CLKCR |= 0<<9 ;                                        //非省电模式
  SDIO->CLKCR |= 0<<10 ;                                        //关闭旁路,CK根据分频设置输出
  SDIO->CLKCR |= 0<<11 ;                                        //1位数据宽度
  SDIO->CLKCR |= 0<<13 ;                                        //SDIOCLK上升沿产生SDIOCK
  SDIO->CLKCR |= 0<<14 ;                                        //关闭硬件流控制
  SDIO_Clock_Set( SDIO_INIT_CLK_DIV ) ;                                //设置时钟频率(初始化的时候,不能超过400Khz)
  SDIO->POWER = 0x03 ;                                        //上电状态,开启卡时钟
  SDIO->CLKCR |= 1<<8 ;                                        //SDIOCK使能
  for( i=0; i<74; i++ )
  {
    SDIO_Send_Cmd( SD_CMD_GO_IDLE_STATE, 0, 0 ) ;                          //发送CMD0进入IDLE STAGE模式命令
    errorstatus = CmdError() ;
    if( errorstatus==SD_OK )
      break ;
  }
  //返回错误状态
  if( errorstatus )
    return errorstatus ;
  SDIO_Send_Cmd( SDIO_SEND_IF_COND, 1, SD_CHECK_PATTERN ) ;                      //发送CMD8,短响应,检查SD卡接口特性
  errorstatus = CmdResp7Error() ;                                    //等待R7响应
  //R7响应正常
  if( errorstatus==SD_OK )
  {
    CardType = SDIO_STD_CAPACITY_SD_CARD_V2_0 ;                            //SD 2.0卡
    SDType = SD_HIGH_CAPACITY ;                                    //高容量卡
  }
  SDIO_Send_Cmd( SD_CMD_APP_CMD, 1, 0 ) ;                                //发送CMD55,短响应
  errorstatus = CmdResp1Error( SD_CMD_APP_CMD ) ;                            //等待R1响应
  //SD2.0/SD 1.1,否则为MMC卡
  if( errorstatus==SD_OK )
  {
    //SD卡,发送ACMD41 SD_APP_OP_COND,参数为:0x80100000
    while( ( !validvoltage )&&( count1, 0 ) ;                            //发送CMD55,短响应
      errorstatus = CmdResp1Error( SD_CMD_APP_CMD ) ;                        //等待R1响应
      //响应错误
      if( errorstatus!=SD_OK )
      return errorstatus ;
      SDIO_Send_Cmd( SD_CMD_SD_APP_OP_COND, 1, SD_VOLTAGE_WINDOW_SD|SDType );            //发送ACMD41,短响应
      errorstatus = CmdResp3Error() ;                                //等待R3响应
      //响应错误
      if( errorstatus!=SD_OK )
      return errorstatus ;
      response = SDIO->RESP1 ;                                  //得到响应
      validvoltage = ( ( ( response>>31 )==1 )?1:0 ) ;                      //判断SD卡上电是否完成
      count ++ ;
    }
    if( count>=SD_MAX_VOLT_TRIAL )
    {
      errorstatus = SD_INVALID_VOLTRANGE ;
      return errorstatus ;
    }
    if( response&=SD_HIGH_CAPACITY )
      CardType = SDIO_HIGH_CAPACITY_SD_CARD ;
  }
  return errorstatus ;
}
/***************************************************
Name    :SD_InitializeCards
Function  :初始化所有的卡
Paramater  :None
Return    :错误代码
***************************************************/
u32 CSD_Tab[ 4 ], CID_Tab[ 4 ], RCA=0 ;                                  //SD卡CSD,CID以及相对地址(RCA)数据
SD_Error SD_InitializeCards()
{
   SD_Error errorstatus=SD_OK ;
  u16 rca = 0x01 ;
  //检查电源状态,确保为上电状态
   if( ( SDIO->POWER&0x03 )==0 )
    return SD_REQUEST_NOT_APPLICABLE ;
  //非SECURE_DIGITAL_IO_CARD
   if( SDIO_SECURE_DIGITAL_IO_CARD!=CardType )
  {
    SDIO_Send_Cmd( SD_CMD_ALL_SEND_CID, 3, 0 ) ;                          //发送CMD2,取得CID,长响应
    errorstatus = CmdResp2Error() ;                                  //等待R2响应
    //响应错误
    if( errorstatus!=SD_OK )
      return errorstatus;
     CID_Tab[ 0 ] = SDIO->RESP1 ;
    CID_Tab[ 1 ] = SDIO->RESP2 ;
    CID_Tab[ 2 ] = SDIO->RESP3 ;
    CID_Tab[ 3 ] = SDIO->RESP4 ;
  }
  //判断卡类型
  if( ( SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType )||( SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType )||( SDIO_SECURE_DIGITAL_IO_COMBO_CARD==CardType )||( SDIO_HIGH_CAPACITY_SD_CARD==CardType ) )
  {
    SDIO_Send_Cmd( SD_CMD_SET_REL_ADDR, 1, 0 ) ;                          //发送CMD3,短响应
    errorstatus = CmdResp6Error( SD_CMD_SET_REL_ADDR, &rca ) ;                    //等待R6响应
    //响应错误
    if( errorstatus!=SD_OK )
      return errorstatus ;
  }
    if( SDIO_MULTIMEDIA_CARD==CardType )
    {
     SDIO_Send_Cmd( SD_CMD_SET_REL_ADDR, 1, ( u32 )( rca<<16 ) ) ;                  //发送CMD3,短响应
    errorstatus = CmdResp2Error() ;                                  //等待R2响应
    //响应错误
    if( errorstatus!=SD_OK )
      return errorstatus ;
    }
  //非SECURE_DIGITAL_IO_CARD
  if( SDIO_SECURE_DIGITAL_IO_CARD!=CardType )
  {
    RCA = rca ;
    SDIO_Send_Cmd( SD_CMD_SEND_CSD, 3, ( u32 )( rca<<16 ) ) ;                    //发送CMD9+卡RCA,取得CSD,长响应
    errorstatus = CmdResp2Error() ;                                  //等待R2响应
    //响应错误
    if( errorstatus!=SD_OK )
      return errorstatus ;
      CSD_Tab[ 0 ] = SDIO->RESP1 ;
    CSD_Tab[ 1 ] = SDIO->RESP2 ;
    CSD_Tab[ 2 ] = SDIO->RESP3 ;
    CSD_Tab[ 3 ] = SDIO->RESP4 ;
  }
  return SD_OK ;                                            //卡初始化成功
}
/***************************************************
Name    :SD_GetCardInfo
Function  :得到卡信息
Paramater  :
      cardinfo:卡信息存储区
Return    :错误代码
***************************************************/
SD_Error SD_GetCardInfo( SD_CardInfo *cardinfo )
{
   SD_Error errorstatus = SD_OK ;
  u8 tmp = 0 ;     
  cardinfo->CardType = ( u8 )CardType ;                                //卡类型
  cardinfo->RCA = ( u16 )RCA ;                                    //卡RCA值
  tmp = ( u8 )( ( CSD_Tab[ 0 ]&0xFF000000 )>>24 ) ;
  cardinfo->SD_csd.CSDStruct = ( tmp&0xC0 )>>6 ;                            //CSD结构
  cardinfo->SD_csd.SysSpecVersion = ( tmp&0x3C )>>2 ;                          //2.0协议还没定义这部分(为保留),应该是后续协议定义的
  cardinfo->SD_csd.Reserved1 = tmp&0x03 ;                                //2个保留位  
  tmp = ( u8 )( ( CSD_Tab[ 0 ]&0x00FF0000 )>>16 ) ;                          //第1个字节
  cardinfo->SD_csd.TAAC = tmp ;                                    //数据读时间1
  tmp = ( u8 )( ( CSD_Tab[ 0 ]&0x0000FF00 )>>8 ) ;                          //第2个字节
  cardinfo->SD_csd.NSAC = tmp ;                                    //数据读时间2
  tmp = ( u8 )( CSD_Tab[ 0 ]&0x000000FF ) ;                              //第3个字节
  cardinfo->SD_csd.MaxBusClkFrec = tmp ;                                //传输速度     
  tmp = ( u8 )( ( CSD_Tab[ 1 ]&0xFF000000 )>>24 ) ;                          //第4个字节
  cardinfo->SD_csd.CardComdClasses = tmp<<4 ;                              //卡指令类高四位
  tmp = ( u8 )( ( CSD_Tab[ 1 ]&0x00FF0000 )>>16 ) ;                          //第5个字节
  cardinfo->SD_csd.CardComdClasses |= ( tmp&0xF0 )>>4 ;                        //卡指令类低四位
  cardinfo->SD_csd.RdBlockLen = tmp&0x0F ;                              //最大读取数据长度
  tmp = ( u8 )( ( CSD_Tab[ 1 ]&0x0000FF00 )>>8 ) ;                          //第6个字节
  cardinfo->SD_csd.PartBlockRead = ( tmp&0x80 )>>7 ;                          //允许分块读
  cardinfo->SD_csd.WrBlockMisalign = ( tmp&0x40 )>>6 ;                        //写块错位
  cardinfo->SD_csd.RdBlockMisalign = ( tmp&0x20 )>>5 ;                        //读块错位
  cardinfo->SD_csd.DSRImpl = ( tmp&0x10 )>>4 ;
  cardinfo->SD_csd.Reserved2 = 0 ;                                  //保留
  //标准1.1/2.0卡/MMC卡
   if( ( CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1 )||( CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0 )||( SDIO_MULTIMEDIA_CARD==CardType ) )
  {
    cardinfo->SD_csd.DeviceSize = ( tmp&0x03 )<<10 ;                        //C_SIZE(12位)
     tmp = ( u8 )( CSD_Tab[ 1 ]&0x000000FF ) ;                            //第7个字节
    cardinfo->SD_csd.DeviceSize |= tmp<<2 ;
     tmp = ( u8 )( ( CSD_Tab[ 2 ]&0xFF000000 )>>24 );                        //第8个字节
    cardinfo->SD_csd.DeviceSize |= ( tmp&0xC0 )>>6 ;
     cardinfo->SD_csd.MaxRdCurrentVDDMin = ( tmp&0x38 )>>3 ;
    cardinfo->SD_csd.MaxRdCurrentVDDMax = ( tmp&0x07 ) ;
     tmp = ( u8 )( ( CSD_Tab[ 2 ]&0x00FF0000 )>>16 ) ;                        //第9个字节
    cardinfo->SD_csd.MaxWrCurrentVDDMin = ( tmp&0xE0 )>>5 ;
    cardinfo->SD_csd.MaxWrCurrentVDDMax = ( tmp&0x1C )>>2 ;
    cardinfo->SD_csd.DeviceSizeMul = ( tmp&0x03 )<<1 ;                        //C_SIZE_MULT
     tmp = ( u8 )( ( CSD_Tab[ 2 ]&0x0000FF00 )>>8 ) ;                        //第10个字节
    cardinfo->SD_csd.DeviceSizeMul |= ( tmp&0x80 )>>7 ;
     cardinfo->CardCapacity = ( cardinfo->SD_csd.DeviceSize+1 ) ;                  //计算卡容量
    cardinfo->CardCapacity *= ( 1<<( cardinfo->SD_csd.DeviceSizeMul+2 ) ) ;
    cardinfo->CardBlockSize = 1<<( cardinfo->SD_csd.RdBlockLen ) ;                  //块大小
    cardinfo->CardCapacity *= cardinfo->CardBlockSize ;
  }
  //高容量卡
  else if( CardType==SDIO_HIGH_CAPACITY_SD_CARD )
  {
     tmp = ( u8 )( CSD_Tab[ 1 ]&0x000000FF  );                            //第7个字节  
    cardinfo->SD_csd.DeviceSize = ( tmp&0x3F )<<16 ;                        //C_SIZE
     tmp = ( u8 )( ( CSD_Tab[ 2 ]&0xFF000000 )>>24 ) ;                        //第8个字节  
     cardinfo->SD_csd.DeviceSize |= ( tmp<<8 ) ;
     tmp = ( u8 )( ( CSD_Tab[ 2 ]&0x00FF0000 )>>16 ) ;                        //第9个字节  
     cardinfo->SD_csd.DeviceSize |= tmp ;
     tmp = ( u8 )( ( CSD_Tab[ 2 ]&0x0000FF00 )>>8 ) ;                        //第10个字节  
     cardinfo->CardCapacity = ( long long )( cardinfo->SD_csd.DeviceSize+1 )*512*1024 ;        //计算卡容量
    cardinfo->CardBlockSize = 512 ;                                  //块大小固定为512字节
  }
  cardinfo->SD_csd.EraseGrSize = ( tmp&0x40 )>>6 ;
  cardinfo->SD_csd.EraseGrMul = ( tmp&0x3F )<<1 ;     
  tmp = ( u8 )( CSD_Tab[ 2 ]&0x000000FF ) ;                              //第11个字节
  cardinfo->SD_csd.EraseGrMul |= ( tmp&0x80 )>>7 ;
  cardinfo->SD_csd.WrProtectGrSize=( tmp&0x7F ) ;
   tmp = ( u8 )( ( CSD_Tab[ 3 ]&0xFF000000 )>>24 ) ;                          //第12个字节
  cardinfo->SD_csd.WrProtectGrEnable = ( tmp&0x80 )>>7 ;
  cardinfo->SD_csd.ManDeflECC = ( tmp&0x60 )>>5 ;
  cardinfo->SD_csd.WrSpeedFact = ( tmp&0x1C )>>2 ;
  cardinfo->SD_csd.MaxWrBlockLen=( tmp&0x03 )<<2 ;
  tmp = ( u8 )( ( CSD_Tab[ 3 ]&0x00FF0000 )>>16 ) ;                          //第13个字节
  cardinfo->SD_csd.MaxWrBlockLen |= ( tmp&0xC0 )>>6 ;
  cardinfo->SD_csd.WriteBlockPaPartial = ( tmp&0x20 )>>5 ;
  cardinfo->SD_csd.Reserved3 = 0 ;
  cardinfo->SD_csd.ContentProtectAppli=(tmp&0x01);
  tmp = ( u8 )( ( CSD_Tab[ 3 ]&0x0000FF00 )>>8 ) ;                          //第14个字节
  cardinfo->SD_csd.FileFormatGrouop = ( tmp&0x80 )>>7 ;
  cardinfo->SD_csd.CopyFlag = ( tmp&0x40 )>>6 ;
  cardinfo->SD_csd.PermWrProtect = ( tmp&0x20 )>>5 ;
  cardinfo->SD_csd.TempWrProtect = ( tmp&0x10 )>>4 ;
  cardinfo->SD_csd.FileFormat = ( tmp&0x0C )>>2 ;
  cardinfo->SD_csd.ECC = ( tmp&0x03 ) ;
  tmp = ( u8 )( CSD_Tab[ 3 ]&0x000000FF ) ;                              //第15个字节
  cardinfo->SD_csd.CSD_CRC = ( tmp&0xFE )>>1 ;
  cardinfo->SD_csd.Reserved4 = 1 ;
  tmp = ( u8 )( ( CID_Tab[ 0 ]&0xFF000000 )>>24 ) ;                          //第0个字节
  cardinfo->SD_cid.ManufacturerID = tmp ;
  tmp = ( u8 )( ( CID_Tab[ 0 ]&0x00FF0000 )>>16 ) ;                          //第1个字节
  cardinfo->SD_cid.OEM_AppliID=tmp<<8;
  tmp = ( u8 )( ( CID_Tab[ 0 ]&0x000000FF00 )>>8 ) ;                          //第2个字节
  cardinfo->SD_cid.OEM_AppliID |= tmp ;
  tmp = ( u8 )( CID_Tab[ 0 ]&0x000000FF ) ;                              //第3个字节  
  cardinfo->SD_cid.ProdName1 = tmp<<24 ;
  tmp = ( u8 )( ( CID_Tab[ 1 ]&0xFF000000 )>>24 ) ;                           //第4个字节
  cardinfo->SD_cid.ProdName1 |= tmp<<16 ;
  tmp = ( u8 )( ( CID_Tab[ 1 ]&0x00FF0000 )>>16 ) ;                             //第5个字节
  cardinfo->SD_cid.ProdName1 |= tmp<<8 ;
  tmp = ( u8 )( ( CID_Tab[ 1 ]&0x0000FF00 )>>8 ) ;                          //第6个字节
  cardinfo->SD_cid.ProdName1 |= tmp ;
  tmp = ( u8 )( CID_Tab[ 1 ]&0x000000FF ) ;                              //第7个字节
  cardinfo->SD_cid.ProdName2 = tmp ;
  tmp = ( u8 )( ( CID_Tab[ 2 ]&0xFF000000 )>>24 ) ;                          //第8个字节
  cardinfo->SD_cid.ProdRev = tmp ;
  tmp = ( u8 )( ( CID_Tab[ 2 ]&0x00FF0000 )>>16 ) ;                          //第9个字节
  cardinfo->SD_cid.ProdSN = tmp<<24 ;
  tmp = ( u8 )( ( CID_Tab[ 2 ]&0x0000FF00 )>>8 ) ;                          //第10个字节
  cardinfo->SD_cid.ProdSN |= tmp<<16 ;
  tmp = ( u8 )( CID_Tab[ 2 ]&0x000000FF );                              //第11个字节
  cardinfo->SD_cid.ProdSN |= tmp<<8 ;
  tmp = ( u8 )( ( CID_Tab[ 3 ]&0xFF000000 )>>24 ) ;                          //第12个字节
  cardinfo->SD_cid.ProdSN |= tmp ;
  tmp = ( u8 )( ( CID_Tab[ 3 ]&0x00FF0000 )>>16 ) ;                          //第13个字节
  cardinfo->SD_cid.Reserved1 |= ( tmp&0xF0 )>>4 ;
  cardinfo->SD_cid.ManufactDate = ( tmp&0x0F )<<8 ;
  tmp = ( u8 )( ( CID_Tab[ 3 ]&0x0000FF00 )>>8 ) ;                          //第14个字节
  cardinfo->SD_cid.ManufactDate |= tmp ;
  tmp = ( u8 )( CID_Tab[ 3 ]&0x000000FF ) ;                              //第15个字节
  cardinfo->SD_cid.CID_CRC = ( tmp&0xFE )>>1 ;
  cardinfo->SD_cid.Reserved2 = 1 ;
  return errorstatus ;
}
/***************************************************
Name    :FindSCR
Function  :查找SD卡的SCR寄存器值
Paramater  :
      rca:卡相对地址
      pscr:数据缓存区(存储SCR内容)
Return    :错误代码
***************************************************/     
SD_Error FindSCR( u16 rca, u32 *pscr )
{ 
  u32 index = 0 ; 
  SD_Error errorstatus = SD_OK ;
  u32 tempscr[ 2 ] = { 0, 0 } ;
   SDIO_Send_Cmd( SD_CMD_SET_BLOCKLEN, 1, 8 ) ;                            //发送CMD16,短响应,设置Block Size为8字节
   errorstatus = CmdResp1Error( SD_CMD_SET_BLOCKLEN ) ;
   if( errorstatus!=SD_OK )
    return errorstatus ;
    SDIO_Send_Cmd( SD_CMD_APP_CMD, 1, ( u32 )rca<<16 ) ;                        //发送CMD55,短响应
   errorstatus = CmdResp1Error( SD_CMD_APP_CMD ) ;
   if( errorstatus!=SD_OK )
    return errorstatus ;
  SDIO_Send_Data_Cfg( SD_DATATIMEOUT, 8, 3, 1 ) ;                            //8个字节长度,block为8字节,SD卡到SDIO
     SDIO_Send_Cmd( SD_CMD_SD_APP_SEND_SCR, 1, 0 ) ;                            //发送ACMD51,短响应,参数为0
   errorstatus = CmdResp1Error( SD_CMD_SD_APP_SEND_SCR ) ;
   if( errorstatus!=SD_OK )
    return errorstatus ;
   while( !( SDIO->STA&( SDIO_FLAG_RXOVERR|SDIO_FLAG_DCRCFAIL|SDIO_FLAG_DTIMEOUT|SDIO_FLAG_DBCKEND|SDIO_FLAG_STBITERR ) ) )
  {
    //接收FIFO数据可用
    if( SDIO->STA&( 1<<21 ) )
    {
      *( tempscr+index ) = SDIO->FIFO ;                              //读取FIFO内容
      index ++ ;
      if( index>=2 )
        break ;
    }
  }
  //接收数据超时
   if( SDIO->STA&( 1<<3 ) )
  {
     SDIO->ICR |= 1<<3 ;                                        //清除标记
    return SD_DATA_TIMEOUT ;
  }
  //已发送/接收的数据块CRC校验错误
  else if( SDIO->STA&( 1<<1 ) )
  {
     SDIO->ICR |= 1<<1 ;                                        //清除标记
    return SD_DATA_CRC_FAIL ;
  }
  //接收FIFO溢出
  else if( SDIO->STA&( 1<<5 ) )
  {
     SDIO->ICR |= 1<<5 ;                                        //清除标记
    return SD_RX_OVERRUN ;
  }
  //起始位检测错误
  else if( SDIO->STA&( 1<<9 ) )
  {
     SDIO->ICR |= 1<<9 ;                                        //清除标记
    return SD_START_BIT_ERR ;    
  }
     SDIO->ICR = 0X5FF ;                                          //清除标记   
  //把数据顺序按8位为单位倒过来.
  *( pscr+1 ) = ( ( tempscr[ 0 ]&SD_0TO7BITS )<<24 )|( ( tempscr[ 0 ]&SD_8TO15BITS )<<8 )|( ( tempscr[ 0 ]&SD_16TO23BITS )>>8 )|( ( tempscr[ 0 ]&SD_24TO31BITS )>>24 ) ;
  *( pscr )   = ( ( tempscr[ 1 ]&SD_0TO7BITS )<<24 )|( ( tempscr[ 1 ]&SD_8TO15BITS )<<8 )|( ( tempscr[ 1 ]&SD_16TO23BITS )>>8 )|( ( tempscr[ 1 ]&SD_24TO31BITS )>>24 ) ;
   return errorstatus ;
}
/***************************************************
Name    :SDEnWideBus
Function  :SDIO使能宽总线模式
Paramater  :
      enx:使能开关
        0:不使能
        1:使能
Return    :错误代码
***************************************************/
SD_Error SDEnWideBus( u8 enx )
{
  SD_Error errorstatus = SD_OK ;
   u32 scr[ 2 ] = { 0, 0 } ;
  u8 arg = 0x00 ;
  if( enx )
    arg = 0x02 ;
  else
    arg = 0x00 ;
  //SD卡处于LOCKED状态
   if( SDIO->RESP1&SD_CARD_LOCKED )
    return SD_LOCK_UNLOCK_FAILED ;
   errorstatus = FindSCR( RCA, scr );                                  //得到SCR寄存器数据
   if( errorstatus!=SD_OK )
    return errorstatus ;
  //支持宽总线
  if( ( scr[ 1 ]&SD_WIDE_BUS_SUPPORT )!=SD_ALLZERO )
  {
     SDIO_Send_Cmd( SD_CMD_APP_CMD, 1, ( u32 )RCA<<16 );                        //发送CMD55+RCA,短响应
     errorstatus = CmdResp1Error( SD_CMD_APP_CMD ) ;
     if( errorstatus!=SD_OK )
      return errorstatus ;
     SDIO_Send_Cmd( SD_CMD_APP_SD_SET_BUSWIDTH, 1, arg ) ;                      //发送ACMD6,短响应,参数:10,4位;00,1位
    errorstatus = CmdResp1Error( SD_CMD_APP_SD_SET_BUSWIDTH ) ;
    return errorstatus ;
  }
  else
    return SD_REQUEST_NOT_APPLICABLE ;                                //不支持宽总线设置
}
/***************************************************
Name    :SD_EnableWideBusOperation
Function  :设置SDIO总线宽度
Paramater  :
      wmode:位宽模式
        0->1位数据宽度
        1->4位数据宽度
        2->8位数据宽度
Return    :错误代码
***************************************************/
SD_Error SD_EnableWideBusOperation( u32 wmode )
{
    SD_Error errorstatus = SD_OK ;
   if( SDIO_MULTIMEDIA_CARD==CardType )
    return SD_UNSUPPORTED_FEATURE ;                                  //MMC卡不支持
   else if( ( SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType )||( SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType )||( SDIO_HIGH_CAPACITY_SD_CARD==CardType ) )
  {
    if( wmode>=2 )
      return SD_UNSUPPORTED_FEATURE ;                                //不支持8位模式
     else   
    {
      errorstatus = SDEnWideBus( wmode ) ;
       if( SD_OK==errorstatus )
      {
        SDIO->CLKCR &= ~( 3<<11 ) ;                                //清除之前的位宽设置    
        SDIO->CLKCR |= ( u16 )wmode<<11 ;                            //1位/4位总线宽度 
        SDIO->CLKCR |= 0<<14 ;                                  //不开启硬件流控制
      }
    }  
  }
  return errorstatus ;
}
/***************************************************
Name    :SD_Init
Function  :初始化SD卡
Paramater  :None
Return    :错误代码
***************************************************/
SD_Error SD_Init()
{
  u8 clkdiv=0 ;
  SD_Error errorstatus=SD_OK ;
  //SDIO IO口初始化
  RCC->APB2ENR |= 1<<4 ;                                        //使能PC时钟
  RCC->APB2ENR |= 1<<5 ;                                        //使能PD时钟
  RCC->AHBENR |= 1<<10 ;                                        //使能SDIO时钟
  RCC->AHBENR |= 1<<1 ;                                        //使能DMA2时钟
  GPIOC->CRH &= 0xFFF00000 ;
  GPIOC->CRH |= 0x000BBBBB ;                                      //PC.8~12 复用输出
  GPIOD->CRL &= 0xFFFFF0FF ;
  GPIOD->CRL |= 0x00000B00 ;                                      //PD2复用输出
  //SDIO外设寄存器设置为默认值
  SDIO->POWER = 0x00000000 ;
  SDIO->CLKCR = 0x00000000 ;
  SDIO->ARG = 0x00000000 ;
  SDIO->CMD = 0x00000000 ;
  SDIO->DTIMER = 0x00000000 ;
  SDIO->DLEN = 0x00000000 ;
  SDIO->DCTRL = 0x00000000 ;
  SDIO->ICR = 0x00C007FF ;
  SDIO->MASK = 0x00000000 ;
  NVIC_Init( 0, 0, SDIO_IRQn, 2 ) ;                                  //SDIO中断配置
     errorstatus = SD_PowerON() ;                                    //SD卡上电
   if( errorstatus==SD_OK )
    errorstatus=SD_InitializeCards() ;                                //初始化SD卡                              
    if( errorstatus==SD_OK )
    errorstatus=SD_GetCardInfo( &SDCardInfo ) ;                            //获取卡信息
   if( errorstatus==SD_OK )
  {
    SDIO_Send_Cmd( SD_CMD_SEL_DESEL_CARD, 1, SDCardInfo.RCA<<16 ) ;                  //发送CMD7,选择卡,短响应        
    errorstatus = CmdResp1Error( SD_CMD_SEL_DESEL_CARD ) ;
  }
     if( errorstatus==SD_OK )
    errorstatus=SD_EnableWideBusOperation( 1 ) ;                          //4位宽度,如果是MMC卡,则不能用4位模式 
    if( ( errorstatus==SD_OK )||( SDIO_MULTIMEDIA_CARD==CardType ) )
  {
    if( ( SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1 )||( SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0 ) )
      clkdiv = SDIO_TRANSFER_CLK_DIV+6 ;                              //V1.1/V2.0卡,设置最高72/12=6Mhz
    else
      clkdiv = SDIO_TRANSFER_CLK_DIV ;                              //SDHC等其他卡,设置最高72/6=12Mhz
    SDIO_Clock_Set( clkdiv );                                    //设置时钟频率
   }
  return errorstatus ;
}
/***************************************************
Name    :convert_from_bytes_to_power_of_two
Function  :得到NumberOfBytes以2为底的指数
Paramater  :
      NumberOfBytes:字节数
Return    :以2为底的指数值
***************************************************/
u8 convert_from_bytes_to_power_of_two( u16 NumberOfBytes )
{
  u8 count=0 ;
  while( NumberOfBytes!=1 )
  {
    NumberOfBytes >>= 1 ;
    count ++ ;
  }
  return count ;
}
/***************************************************
Name    :SD_ReadBlock
Function  :读取一个块
Paramater  :
      buf:读数据缓存区(必须4字节对齐)
      addr:读取地址
      blksize:块大小
Return    :错误代码
***************************************************/
SD_Error SD_ReadBlock( u8 *buf, long long addr, u16 blksize )
{    
  SD_Error errorstatus = SD_OK ;
  u8 power ;
     u32 count=0, *tempbuff=( u32* )buf ;                                //转换为u32指针
  u32 timeout = SDIO_DATATIMEOUT ;
     if( NULL==buf )
    return SD_INVALID_PARAMETER ;
     SDIO->DCTRL = 0x0 ;                                          //数据控制寄存器清零(关DMA)
  //大容量卡
  if( CardType==SDIO_HIGH_CAPACITY_SD_CARD )
  {
    blksize = 512 ;
    addr >>= 9 ;
  }   
    SDIO_Send_Data_Cfg( SD_DATATIMEOUT, 0, 0, 0 ) ;                            //清除DPSM状态机配置
  //卡锁了
  if( SDIO->RESP1&SD_CARD_LOCKED )
    return SD_LOCK_UNLOCK_FAILED ;
  if( ( blksize>0 )&&( blksize<=2048 )&&( ( blksize&( blksize-1 ) )==0 ) )
  {
    power = convert_from_bytes_to_power_of_two( blksize ) ;
    SDIO_Send_Cmd( SD_CMD_SET_BLOCKLEN, 1, blksize ) ;                        //发送CMD16+设置数据长度为blksize,短响应
    errorstatus = CmdResp1Error( SD_CMD_SET_BLOCKLEN ) ;                      //等待R1响应
    //响应错误
    if( errorstatus!=SD_OK )
      return errorstatus ;
  }
  else
    return SD_INVALID_PARAMETER ;                              
    SDIO_Send_Data_Cfg( SD_DATATIMEOUT, blksize, power, 1 ) ;                      //blksize,卡到控制器
     SDIO_Send_Cmd( SD_CMD_READ_SINGLE_BLOCK, 1, addr ) ;                        //发送CMD17+从addr地址出读取数据,短响应
  errorstatus = CmdResp1Error( SD_CMD_READ_SINGLE_BLOCK ) ;                      //等待R1响应
  //响应错误
  if( errorstatus!=SD_OK )
    return errorstatus ;
  __asm volatile( "cpsid i" ) ;                                    //关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)
  //无上溢/CRC/超时/完成(标志)/起始位错误
  while( !( SDIO->STA&( ( 1<<5 )|( 1<<1 )|( 1<<3 )|( 1<<10 )|( 1<<9 ) ) ) )
  {
    //接收区半满,表示至少存了8个字
    if( SDIO->STA&( 1<<15 ) )
    {
      for( count=0; count<8; count++ )                              //循环读取数据
        *( tempbuff+count ) = SDIO->FIFO ;
      tempbuff += 8 ;   
      timeout = 0x7FFFFF ;                                    //读数据溢出时间
    }
    //处理超时
    else
    {
      if( timeout==0 )
        return SD_DATA_TIMEOUT ;
      timeout -- ;
    }
  }
  //数据超时错误
  if( SDIO->STA&( 1<<3 ) )
  {
    SDIO->ICR |= 1<<3 ;                                        //清错误标志
    return SD_DATA_TIMEOUT ;
  }
  //数据块CRC错误
  else if( SDIO->STA&( 1<<1 ) )
  {
    SDIO->ICR |= 1<<1 ;                                        //清错误标志
    return SD_DATA_CRC_FAIL ;
  }
  //接收FIFO上溢错误
  else if( SDIO->STA&( 1<<5 ) )
  {
    SDIO->ICR |= 1<<5 ;                                        //清错误标志
    return SD_RX_OVERRUN ;
  }
  //接收起始位错误
  else if( SDIO->STA&( 1<<9 ) )
  {
    SDIO->ICR |= 1<<9 ;                                        //清错误标志
    return SD_START_BIT_ERR ;
  }
  //FIFO里面,还存在可用数据
  while( SDIO->STA&( 1<<21 ) )
  {
    *tempbuff = SDIO->FIFO ;                                    //循环读取数据
    tempbuff ++ ;
  }
  __asm volatile( "cpsie i" ) ;                                    //开启总中断
  SDIO->ICR = 0x5FF ;                                          //清除所有标记
   return errorstatus ;
}
/***************************************************
Name    :SD_ReadMultiBlocks
Function  :读取多个块
Paramater  :
      buf:读数据缓存区(必须4字节对齐)
      addr:读取地址
      blksize:块大小
      nblks:要读取的块数
Return    :错误代码
***************************************************/
__align(4) u32 *tempbuff ;
SD_Error SD_ReadMultiBlocks( u8 *buf, long long addr, u16 blksize, u32 nblks )
{
    SD_Error errorstatus = SD_OK ;
  u8 power ;
     u32 count = 0 ;
  u32 timeout = SDIO_DATATIMEOUT ;
  tempbuff = ( u32* )buf ;                                      //转换为u32指针
    SDIO->DCTRL = 0x0 ;                                          //数据控制寄存器清零(关DMA)
  //大容量卡
  if( CardType==SDIO_HIGH_CAPACITY_SD_CARD )
  {
    blksize = 512 ;
    addr >>= 9 ;
  }
     SDIO_Send_Data_Cfg( SD_DATATIMEOUT, 0, 0, 0 ) ;                            //清除DPSM状态机配置
  //卡锁了
  if( SDIO->RESP1&SD_CARD_LOCKED )
    return SD_LOCK_UNLOCK_FAILED ;
  if( ( blksize>0 )&&( blksize<=2048 )&&( ( blksize&( blksize-1 ) )==0 ) )
  {
    power = convert_from_bytes_to_power_of_two( blksize ) ;
    SDIO_Send_Cmd( SD_CMD_SET_BLOCKLEN, 1, blksize ) ;                        //发送CMD16+设置数据长度为blksize,短响应
    errorstatus = CmdResp1Error( SD_CMD_SET_BLOCKLEN ) ;                      //等待R1响应
    //响应错误
    if( errorstatus!=SD_OK )
      return errorstatus ;
  }
  else
    return SD_INVALID_PARAMETER ;
  //多块读
  if( nblks>1 )
  {
    //判断是否超过最大接收长度
       if( nblks*blksize>SD_MAX_DATA_LENGTH )
      return SD_INVALID_PARAMETER ;
    SDIO_Send_Data_Cfg( SD_DATATIMEOUT, nblks*blksize, power, 1 ) ;                  //nblks*blksize,512块大小,卡到控制器
      SDIO_Send_Cmd( SD_CMD_READ_MULT_BLOCK, 1, addr ) ;                        //发送CMD18+从addr地址出读取数据,短响应
    errorstatus = CmdResp1Error( SD_CMD_READ_MULT_BLOCK ) ;                      //等待R1响应
    //响应错误
    if( errorstatus!=SD_OK )
      return errorstatus ;
    __asm volatile( "cpsid i" ) ;                                  //关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)
    //无上溢/CRC/超时/完成(标志)/起始位错误
    while( !( SDIO->STA&( ( 1<<5 )|( 1<<1 )|( 1<<3 )|( 1<<8 )|( 1<<9 ) ) ) )
    {
      //接收区半满,表示至少存了8个字
      if( SDIO->STA&( 1<<15 ) )
      {
        //循环读取数据
        for( count=0; count<8; count++ )
          *( tempbuff+count ) = SDIO->FIFO ;
        tempbuff += 8 ;
        timeout = 0X7FFFFF ;                                  //读数据溢出时间
      }
      //处理超时
      else
      {
        if( timeout==0 )
          return SD_DATA_TIMEOUT ;
        timeout -- ;
      }
    }
    //数据超时错误
    if( SDIO->STA&( 1<<3 ) )
    {
      SDIO->ICR |= 1<<3 ;                                      //清错误标志
      return SD_DATA_TIMEOUT;
    }
    //数据块CRC错误
    else if( SDIO->STA&( 1<<1 ) )
    {
      SDIO->ICR |= 1<<1 ;                                      //清错误标志
      return SD_DATA_CRC_FAIL ;
    }
    //接收fifo上溢错误
    else if( SDIO->STA&( 1<<5 ) )
    {
      SDIO->ICR |= 1<<5 ;                                      //清错误标志
      return SD_RX_OVERRUN;
    }
    //接收起始位错误
    else if( SDIO->STA&( 1<<9 ) )
    {
      SDIO->ICR |= 1<<9 ;                                      //清错误标志
      return SD_START_BIT_ERR ;
    }
    //FIFO里面,还存在可用数据
    while( SDIO->STA&( 1<<21 ) )
    {
      *tempbuff = SDIO->FIFO ;                                  //循环读取数据
      tempbuff ++ ;
    }
    //接收结束
    if( SDIO->STA&( 1<<8 ) )
    {
      if( ( SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType )||( SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType )||( SDIO_HIGH_CAPACITY_SD_CARD==CardType ) )
      {
        SDIO_Send_Cmd( SD_CMD_STOP_TRANSMISSION, 1, 0 ) ;                    //发送CMD12+结束传输
        errorstatus = CmdResp1Error( SD_CMD_STOP_TRANSMISSION ) ;                //等待R1响应
        if( errorstatus!=SD_OK )
          return errorstatus ;
      }
    }
    __asm volatile( "cpsie i" ) ;                                  //开启总中断
    SDIO->ICR = 0x5FF ;                                        //清除所有标记 
    }
  return errorstatus ;
}
/***************************************************
Name    :IsCardProgramming
Function  :检查卡是否正在执行写操作
Paramater  :
      pstatus:当前状态
Return    :错误代码
***************************************************/
SD_Error IsCardProgramming( u8 *pstatus )
{
   volatile u32 respR1=0, status=0 ;
    SDIO_Send_Cmd( SD_CMD_SEND_STATUS, 1, ( u32 )RCA<<16 ) ;                      //发送CMD13
    status = SDIO->STA ;
  while( !( status&( ( 1<<0 )|( 1<<6 )|( 1<<2 ) ) ) )
    status = SDIO->STA ;                                      //等待操作完成
  //CRC检测失败
     if( status&( 1<<0 ) )
  {
    SDIO->ICR |= 1<<0 ;                                        //清除错误标记
    return SD_CMD_CRC_FAIL ;
  }
  //命令超时
     if( status&( 1<<2 ) )
  {
    SDIO->ICR |= 1<<2 ;                                        //清除错误标记
    return SD_CMD_RSP_TIMEOUT ;
  }
   if( SDIO->RESPCMD!=SD_CMD_SEND_STATUS )
    return SD_ILLEGAL_CMD ;
  SDIO->ICR = 0X5FF ;                                          //清除所有标记
  respR1 = SDIO->RESP1 ;
  *pstatus = ( u8 )( ( respR1>>9 )&0x0000000F ) ;
  return SD_OK ;
}
/***************************************************
Name    :SD_WriteBlock
Function  :写1个块
Paramater  :
      buf:数据缓存区
      addr:写地址
      blksize:块大小
Return    :错误代码
***************************************************/
SD_Error SD_WriteBlock( u8 *buf, long long addr, u16 blksize )
{
  SD_Error errorstatus = SD_OK ;
  u8  power=0, cardstate=0 ;
  u32 timeout=0, bytestransferred=0 ;
  u32 cardstatus=0, count=0, restwords=0 ;
  u32  tlen = blksize ;                                        //总长度(字节)
  u32*tempbuff = ( u32* )buf ;
  //参数错误
   if( buf==NULL )
    return SD_INVALID_PARAMETER ;
    SDIO->DCTRL = 0x0 ;                                          //数据控制寄存器清零(关DMA)
    SDIO_Send_Data_Cfg( SD_DATATIMEOUT, 0, 0, 0 ) ;                            //清除DPSM状态机配置
  //卡锁了
  if( SDIO->RESP1&SD_CARD_LOCKED )
    return SD_LOCK_UNLOCK_FAILED ;
  //大容量卡
   if( CardType==SDIO_HIGH_CAPACITY_SD_CARD )
  {
    blksize = 512 ;
    addr >>= 9 ;
  }
  if( ( blksize>0 )&&( blksize<=2048 )&&( ( blksize&( blksize-1 ) )==0 ) )
  {
    power = convert_from_bytes_to_power_of_two( blksize ) ;
    SDIO_Send_Cmd( SD_CMD_SET_BLOCKLEN, 1, blksize ) ;                        //发送CMD16+设置数据长度为blksize,短响应
    errorstatus = CmdResp1Error( SD_CMD_SET_BLOCKLEN ) ;                      //等待R1响应
    //响应错误
    if( errorstatus!=SD_OK )
      return errorstatus ;
  }
  else
    return SD_INVALID_PARAMETER ;
     SDIO_Send_Cmd( SD_CMD_SEND_STATUS, 1, ( u32 )RCA<<16 ) ;                      //发送CMD13,查询卡的状态,短响应
  errorstatus = CmdResp1Error( SD_CMD_SEND_STATUS ) ;                          //等待R1响应
  if( errorstatus!=SD_OK )
    return errorstatus ;
  cardstatus = SDIO->RESP1 ;
  timeout = SD_DATATIMEOUT ;
  //检查READY_FOR_DATA位是否置位
     while( ( ( cardstatus&0x00000100 )==0 )&&( timeout>0 ) )
  {
    timeout -- ;
       SDIO_Send_Cmd( SD_CMD_SEND_STATUS, 1, ( u32 )RCA<<16 ) ;                    //发送CMD13,查询卡的状态,短响应
    errorstatus = CmdResp1Error( SD_CMD_SEND_STATUS ) ;                        //等待R1响应
    if( errorstatus!=SD_OK )
      return errorstatus ;
    cardstatus = SDIO->RESP1 ;
  }
  if( timeout==0 )
    return SD_ERROR ;
     SDIO_Send_Cmd( SD_CMD_WRITE_SINGLE_BLOCK, 1, addr ) ;                        //发送CMD24,写单块指令,短响应
  errorstatus = CmdResp1Error( SD_CMD_WRITE_SINGLE_BLOCK ) ;                      //等待R1响应
  if( errorstatus!=SD_OK )
    return errorstatus ;
   SDIO_Send_Data_Cfg( SD_DATATIMEOUT, blksize, power, 0 ) ;                      //blksize, 控制器到卡
  timeout = SDIO_DATATIMEOUT ;
  __asm volatile( "cpsid i" ) ;                                    //关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)
  //数据块发送成功/下溢/CRC/超时/起始位错误
  while( !( SDIO->STA&( ( 1<<10 )|( 1<<4 )|( 1<<1 )|( 1<<3 )|( 1<<9 ) ) ) )
  {
    //发送区半空,表示至少存了8个字
    if( SDIO->STA&( 1<<14 ) )
    {
      //不够32字节了
      if( ( tlen-bytestransferred )4==0 )?( ( tlen-bytestransferred )/4 ):( ( tlen-bytestransferred )/4+1 ) ;
        for( count=0; count4 )
          SDIO->FIFO = *tempbuff ;
      }
      else
      {
        for( count=0; count<8; count++ )
          SDIO->FIFO = *( tempbuff+count ) ;
        tempbuff += 8 ;
        bytestransferred += 32 ;
      }
      timeout = 0x3FFFFFFF ;                                    //写数据溢出时间
    }
    else
    {
      if( timeout==0 )
        return SD_DATA_TIMEOUT ;
      timeout -- ;
    }
  }
  //数据超时错误
  if( SDIO->STA&( 1<<3 ) )
  {
    SDIO->ICR |= 1<<3 ;                                        //清错误标志
    return SD_DATA_TIMEOUT ;
  }
  //数据块CRC错误
  else if( SDIO->STA&( 1<<1 ) )
  {
    SDIO->ICR |= 1<<1 ;                                        //清错误标志
    return SD_DATA_CRC_FAIL ;
  }
  //接收fifo下溢错误
  else if( SDIO->STA&( 1<<4 ) )
  {
    SDIO->ICR |= 1<<4 ;                                        //清错误标志
    return SD_TX_UNDERRUN ;
  }
  //接收起始位错误
  else if( SDIO->STA&( 1<<9 ) )
  {
    SDIO->ICR |= 1<<9 ;                                        //清错误标志
    return SD_START_BIT_ERR ;
  }   
  __asm volatile( "cpsie i" ) ;                                    //开启总中断
  SDIO->ICR = 0x5FF ;                                          //清除所有标记
   SDIO->ICR = 0x5FF ;                                          //清除所有标记
   errorstatus = IsCardProgramming( &cardstate ) ;
   while( ( errorstatus==SD_OK )&&( ( cardstate==SD_CARD_PROGRAMMING )||( cardstate==SD_CARD_RECEIVING ) ) )
    errorstatus = IsCardProgramming( &cardstate ) ;
  return errorstatus ;
}
/***************************************************
Name    :SD_WriteMultiBlocks
Function  :写多个块
Paramater  :
      buf:数据缓存区
      addr:写地址
      blksize:块大小
      nblks:要写入的块数
Return    :错误代码
***************************************************/
SD_Error SD_WriteMultiBlocks( u8 *buf, long long addr, u16 blksize, u32 nblks )
{
  SD_Error errorstatus = SD_OK ;
  u8  power = 0, cardstate = 0 ;
  u32 timeout=0, bytestransferred=0 ;
  u32 count = 0, restwords = 0 ;
  u32 tlen= nblks*blksize ;                                      //总长度(字节)
  u32 *tempbuff = ( u32* )buf ;
  //参数错误
    if( buf==NULL )
    return SD_INVALID_PARAMETER ;
    SDIO->DCTRL = 0x0 ;                                          //数据控制寄存器清零(关DMA)   
    SDIO_Send_Data_Cfg( SD_DATATIMEOUT, 0, 0, 0 );                            //清除DPSM状态机配置
  //卡锁了
  if( SDIO->RESP1&SD_CARD_LOCKED )
    return SD_LOCK_UNLOCK_FAILED ;
  //大容量卡
   if( CardType==SDIO_HIGH_CAPACITY_SD_CARD )
  {
    blksize = 512 ;
    addr >>= 9 ;
  }    
  if( ( blksize>0 )&&( blksize<=2048 )&&( ( blksize&( blksize-1 ) )==0 ) )
  {
    power = convert_from_bytes_to_power_of_two( blksize ) ;      
    SDIO_Send_Cmd( SD_CMD_SET_BLOCKLEN, 1, blksize ) ;                        //发送CMD16+设置数据长度为blksize,短响应
    errorstatus = CmdResp1Error( SD_CMD_SET_BLOCKLEN ) ;                      //等待R1响应
    //响应错误
    if( errorstatus!=SD_OK )
      return errorstatus ;
  }
  else
    return SD_INVALID_PARAMETER ;
  if( nblks>1 )
  {            
    if( nblks*blksize>SD_MAX_DATA_LENGTH )
      return SD_INVALID_PARAMETER ;
       if( ( SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType )||( SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType )||( SDIO_HIGH_CAPACITY_SD_CARD==CardType ) )
      {
      //提高性能
          SDIO_Send_Cmd( SD_CMD_APP_CMD, 1, ( u32 )RCA<<16 );                      //发送ACMD55,短响应
      errorstatus = CmdResp1Error( SD_CMD_APP_CMD ) ;                        //等待R1响应
      if( errorstatus!=SD_OK )
        return errorstatus ;
          SDIO_Send_Cmd( SD_CMD_SET_BLOCK_COUNT, 1, nblks ) ;                      //发送CMD23,设置块数量,短响应
      errorstatus = CmdResp1Error( SD_CMD_SET_BLOCK_COUNT ) ;                    //等待R1响应
      if( errorstatus!=SD_OK )
        return errorstatus ;
    }
    SDIO_Send_Cmd( SD_CMD_WRITE_MULT_BLOCK, 1, addr ) ;                        //发送CMD25,多块写指令,短响应
    errorstatus = CmdResp1Error( SD_CMD_WRITE_MULT_BLOCK ) ;                    //等待R1响应
    if( errorstatus!=SD_OK )
      return errorstatus ;
      SDIO_Send_Data_Cfg( SD_DATATIMEOUT, nblks*blksize, power, 0 ) ;                  //blksize控制器到卡
    timeout = SDIO_DATATIMEOUT ;
    __asm volatile( "cpsid i" ) ;                                  //关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)
    //下溢/CRC/数据结束/超时/起始位错误
    while( !( SDIO->STA&( ( 1<<4 )|( 1<<1) |( 1<<8 )|( 1<<3 )|( 1<<9 ) ) ) )
    {
      //发送区半空,表示至少存了8字(32字节)
      if( SDIO->STA&( 1<<14 ) )
      {
        //不够32字节了
        if( ( tlen-bytestransferred )4==0 )?( ( tlen-bytestransferred )/4 ):( ( tlen-bytestransferred )/4+1 );
          for( count=0; count4 )
            SDIO->FIFO = *tempbuff ;
        }
        //发送区半空,可以发送至少8字(32字节)数据
        else
        {
          for( count=0; countFIFO = *( tempbuff+count ) ;
          tempbuff += SD_HALFFIFO ;
          bytestransferred += SD_HALFFIFOBYTES ;
        }
        timeout = 0x3FFFFFFF ;                                  //写数据溢出时间
      }
      else
      {
        if( timeout==0 )
          return SD_DATA_TIMEOUT ;
        timeout -- ;
      }
    }
    //数据超时错误
    if(SDIO->STA&(1<<3))
    {
      SDIO->ICR |= 1<<3 ;                                      //清错误标志
      return SD_DATA_TIMEOUT ;
    }
    //数据块CRC错误
    else if( SDIO->STA&( 1<<1 ) )
    {
      SDIO->ICR |= 1<<1 ;                                      //清错误标志
      return SD_DATA_CRC_FAIL ;
    }
    //接收fifo下溢错误
    else if( SDIO->STA&( 1<<4 ) )
    {
      SDIO->ICR |= 1<<4 ;                                      //清错误标志
      return SD_TX_UNDERRUN ;
    }
    //接收起始位错误
    else if( SDIO->STA&( 1<<9 ) )
    {
      SDIO->ICR |= 1<<9 ;                                      //清错误标志
      return SD_START_BIT_ERR ;
    }
    //发送结束
    if( SDIO->STA&( 1<<8 ) )
    {
      if( ( SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType )||( SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType )||( SDIO_HIGH_CAPACITY_SD_CARD==CardType ) )
      {
        SDIO_Send_Cmd( SD_CMD_STOP_TRANSMISSION, 1, 0 ) ;                    //发送CMD12+结束传输
        errorstatus = CmdResp1Error( SD_CMD_STOP_TRANSMISSION ) ;                //等待R1响应
        if( errorstatus!=SD_OK )
          return errorstatus ;   
      }
    }
    __asm volatile( "cpsie i" ) ;                                  //开启总中断
    SDIO->ICR=0x5FF ;                                        //清除所有标记
    }
   SDIO->ICR = 0x5FF ;                                          //清除所有标记
   errorstatus = IsCardProgramming( &cardstate ) ;
   while( ( errorstatus==SD_OK )&&( ( cardstate==SD_CARD_PROGRAMMING )||( cardstate==SD_CARD_RECEIVING ) ) )
    errorstatus = IsCardProgramming( &cardstate ) ;
  return errorstatus ;     
}
/***************************************************
Name    :SD_ReadDisk
Function  :读SD卡
Paramater  :
      buf:数据缓存区
      sector:扇区地址
      cnt:扇区个数
Return    :错误代码
***************************************************/
__align(4) u8 SDIO_DATA_BUFFER[ 512 ] ;
u8 SD_ReadDisk( u8*buf, u32 sector, u8 cnt )
{
  u8 sta = SD_OK ;
  long long lsector = sector ;
  u8 n ;
  if( CardType!=SDIO_STD_CAPACITY_SD_CARD_V1_1 )
    lsector <<= 9 ;
  if( ( ( u32 )buf%4 )!=0 )
  {
     for( n=0; n512*n, 512 ) ;                //单个sector的读操作
      memcpy( buf , SDIO_DATA_BUFFER , 512 ) ;
      buf += 512 ;
    }
  }
  else
  {
    if( cnt==1 )
      sta = SD_ReadBlock( buf, lsector, 512 ) ;                          //单个sector的读操作
    else
      sta = SD_ReadMultiBlocks( buf, lsector, 512, cnt ) ;                    //多个sector
  }
  return sta ;
}
/***************************************************
Name    :SD_WriteDisk
Function  :写SD卡
Paramater  :
      buf:数据缓存区
      sector:扇区地址
      cnt:扇区个数
Return    :错误代码
***************************************************/
u8 SD_WriteDisk( u8*buf, u32 sector, u8 cnt )
{
  u8 sta = SD_OK ;
  u8 n ;
  long long lsector = sector ;
  if( CardType!=SDIO_STD_CAPACITY_SD_CARD_V1_1 )
    lsector <<= 9 ;
  if( ( ( u32 )buf%4 )!=0 )
  {
     for( n=0; n512 ) ;
       sta = SD_WriteBlock( SDIO_DATA_BUFFER, lsector+512*n, 512 ) ;                //单个sector的写操作
      buf += 512 ;
    }
  }
  else
  {
    if( cnt==1 )
      sta = SD_WriteBlock( buf, lsector, 512 ) ;                          //单个sector的写操作
    else
      sta = SD_WriteMultiBlocks( buf, lsector, 512, cnt ) ;                    //多个sector  
  }
  return sta ;
}

（3）创建1.c文件，并输入以下代码。

#include "sys.h"
#include "delay.h"
#include "usart1.h"
#include "lcd.h"
#include "sdio_sdcard.h"


int main()
{
  u8 Str[ 30 ] ;
  u16 temp ;
   STM32_Clock_Init( 9 ) ;                                        //系统时钟设置
  SysTick_Init( 72 ) ;                                        //延时初始化
  USART1_Init( 72, 115200 ) ;                                      //串口初始化为115200
  LCD_Init() ;                                            //初始化LCD
  while( SD_Init() ) ;                                        //初始化SD卡
  temp = SDCardInfo.CardCapacity>>20 ;                                //单位换算
  sprintf( ( char * )Str, "SD Size: %4d MB", temp ) ;
  LCD_ShowString( 30, 170, Str ) ;                                  //显示SD卡容量
   while(1)
  {

  }
}