SD卡底层驱动移植

最近希望了解一下文件系统与存储器读写是怎样勾搭起来的，写两篇文章做个记录，本篇文章简单陈述底层驱动的移植，下一篇文章记录移植文件系统的过程

通信方式

SD卡的通信方式主要有两种：四线SPI接口与SDIO接口，SDIO接口具有四根数据线，可以具有更高的通信速率，但是部分单片机没有SDIO接口，为了可移植性，大多数单片机会用SPI的通信方式与SD卡通信（主要我手上的平台也只能满足SPI协议）

移植过程

SPI接口移植

为了代码的可移植性，我写了一个sd_port.c文件专门作为作为提供给SD驱动文件的接口，用户只用在这个文件中调用自己的SPI初始化和读写函数接口与片选引脚的控制接口，如下：

#include "sd_port.h"
void sd_spi_init(void)
{
//在这里添加你的SPI初始化函数
//SPI速率不要太高，不然可能初始化不通过，刚开始先用2M测试，确认成功后可以适当提高，我测试的可以在30M速率下工作
//SPI配置为MSB和MODE0
}
void sd_cs_select(uint8_t state)
{
    if(state)
    {
//在这里拉高你的片选信号引脚
    }
    else
    {
//在这里拉低你的片选信号引脚
    }
}
uint8_t sd_spi_readwrite_byte(uint8_t data)
{
//在这里实现SPI读写一个字节
    return spi_transfer(data);
}

向SD.c暴露的接口总共有三个

void sd_cs_select(uint8_t state);
void sd_spi_init(void);
uint8_t sd_spi_readwrite_byte(uint8_t data);

sd card驱动代码移植

对sd_port.c中的接口再次封装：

uint8_t SPI_WriteReadByte(uint8_t data)
{
    return sd_spi_readwrite_byte(data);
}
void SD_cs_output(uint8_t state)
{
    sd_cs_select(state);
}
void SD_DisSelect(void)
{
    SD_cs_output(1);
    SPI_WriteReadByte(0xff);//提供额外的8个时钟
}

sd卡写指令代码实现,sd卡的指令参数均为32bit：

uint8_t SD_SendCmd(uint8_t cmd, uint32_t arg, uint8_t crc)
{
    uint8_t r1;
    uint8_t Retry=0;
    SD_DisSelect();//取消上次片选
    if(SD_Select())//return 0XFF;//片选失效
        SD_cs_output(0);
    //发送
    SPI_WriteReadByte(cmd | 0x40);//分别写入命令
    SPI_WriteReadByte(arg >> 24);
    SPI_WriteReadByte(arg >> 16);
    SPI_WriteReadByte(arg >> 8);
    SPI_WriteReadByte(arg);
    SPI_WriteReadByte(crc);
    if(cmd==CMD12)SPI_WriteReadByte(0xff);//Skip a stuff byte when stop reading
    //等待响应，或超时退出
    Retry=0X1F;
    do
    {
        r1=SPI_WriteReadByte(0xFF);
    }while((r1&0X80) && Retry--);
    //返回状态值
    return r1;
}

sd卡初始化代码，初始化主要检测sd卡通信是否正常，以及sd卡的类型标准，不同的sd卡对应不同的读写标准与指令

uint8_t SD_Init(void)
{
    uint8_t r1;      // 存放SD卡的返回值
    uint16_t retry;  // 用来进行超时计数
    uint8_t buf[4];
    uint16_t i;

    sd_spi_init();

    for(i=0;i<20;i++)SPI_WriteReadByte(0XFF);//发送最少74个脉冲
    retry=100;
    do
    {
        r1=SD_SendCmd(CMD0,0,0x95);//进入IDLE状态
    }while((r1!=0X01) && retry--);
    SD_Type=0;//默认无卡
    if(r1==0X01)
    {
        Serial.println("SD_SendCmd(CMD0,0,0x95) SUCCESS!");
        if(SD_SendCmd(CMD8,0x1AA,0x87)==1)//SD V2.0
        {
            for(i=0;i<4;i++)buf[i]=SPI_WriteReadByte(0XFF);  //Get trailing return value of R7 resp
            if(buf[2]==0X01&&buf[3]==0XAA)//卡是否支持2.7~3.6V
            {
                retry=0XFFFE;
                do
                {
                    SD_SendCmd(CMD55,0,0X01);   //发送CMD55
                    r1=SD_SendCmd(CMD41,0x40000000,0X01);//发送CMD41
                }while(r1&&retry--);
                if(retry&&SD_SendCmd(CMD58,0,0X01)==0)//鉴别SD2.0卡版本开始
                {
                    Serial.println("SD_SendCmd(CMD41,0x40000000,0X01) SUCCESS!\r\n");
                    for(i=0;i<4;i++)buf[i]=SPI_WriteReadByte(0XFF);//得到OCR值
                    for(int i = 0;i < 4;i++)
                      {
                        // Serial.print("buf");
                        // Serial.print(i);
                        // Serial.print(":");
                        // Serial.println(buf[i]);
                      }
                    if(buf[0]&0x40)SD_Type=SD_TYPE_V2HC;    //检查CCS
                    else SD_Type=SD_TYPE_V2;
                    Serial.print("SD_Type:");
                    Serial.println(SD_Type);
                }
            }
        }
        else//SD V1.x/ MMC V3
        {
            SD_SendCmd(CMD55,0,0X01);       //发送CMD55
            r1=SD_SendCmd(CMD41,0,0X01);    //发送CMD41
            if(r1<=1)
            {
                SD_Type=SD_TYPE_V1;
                retry=0XFFFE;
                do //等待退出IDLE模式
                {
                    SD_SendCmd(CMD55,0,0X01);   //发送CMD55
                    r1=SD_SendCmd(CMD41,0,0X01);//发送CMD41
                }while(r1&&retry--);
            }else//MMC卡不支持CMD55+CMD41识别
            {
                SD_Type=SD_TYPE_MMC;//MMC V3
                retry=0XFFFE;
                do //等待退出IDLE模式
                {
                    r1=SD_SendCmd(CMD1,0,0X01);//发送CMD1
                }while(r1&&retry--);
            }
            if(retry==0||SD_SendCmd(CMD16,512,0X01)!=0)SD_Type=SD_TYPE_ERR;//错误的卡
        }
    }
    SD_DisSelect();//取消片选
    if(SD_Type)return 0;
    else if(r1)return r1;
    return 0xaa;//其他错误
}

sd卡扇区读写驱动：
注意：sd卡的最小操作单位为扇区，块大小与扇区大小一致，一个扇区长度为512字节。

uint8_t SD_ReadDisk(uint8_t*buf,uint32_t sector,uint8_t cnt)
{
    uint8_t r1;
    if(SD_Type!=SD_TYPE_V2HC)sector <<= 9;//转换为字节地址
    if(cnt==1)
    {
        r1=SD_SendCmd(CMD17,sector,0X01);//读命令
        if(r1==0)//指令发送成功
        {
            
            r1=SD_RecvData(buf,512);//接收512个字节
            // Serial.print("start recv over");
            // Serial.println(r1);
        }
        else
        {
            Serial.println("read failed");
        }
    }else
    {
        r1=SD_SendCmd(CMD18,sector,0X01);//连续读命令
        do
        {
            r1=SD_RecvData(buf,512);//接收512个字节
            buf+=512;
        }while(--cnt && r1==0);
        SD_SendCmd(CMD12,0,0X01);   //发送停止命令
    }
    SD_DisSelect();//取消片选
    return r1;//
}
uint8_t SD_WriteDisk(const uint8_t*buf,uint32_t sector,uint8_t cnt)
{
    uint8_t r1;
    uint8_t reply = 200;
    uint16_t retry = 0;
    if(SD_Type!=SD_TYPE_V2HC)sector *= 512;//转换为字节地址
    if(cnt==1)
    {
        r1=SD_SendCmd(CMD24,sector,0X01);//读命令
        if(r1==0)//指令发送成功
        {
            r1=SD_SendBlock(buf,0xFE);//写512个字节
        }
    }
    else
    {
        if(SD_Type!=SD_TYPE_MMC)
        {
            do
            {
                SD_SendCmd(CMD55,0,0X01);
//            SD_SendCmd(CMD23,cnt,0X01);//发送指令
               r1 = SD_SendCmd(CMD22,0x00,0X01);
            }while(r1 != 0x00 && reply--);
            for(int i = 0;i < 4;i++)SPI_WriteReadByte(0xff);

        }
        r1=SD_SendCmd(CMD25,sector,0X01);//连续读命令
        if(r1==0)
        {
            do
            {
                r1=SD_SendBlock(buf,0xFC);//发送512个字节
                buf+=512;
            }while(--cnt && r1==0);
            r1=SD_SendBlock(0,0xFD);//发送512个字节
        }
    }

    
      while(!SPI_WriteReadByte(0xff))        
      {
             retry++;
             if(retry>65534)        //如果长时间没有写入完成，退出报错
             {
                SD_DisSelect();
                return 1;           //写入超时，返回1
             }
    }
    SD_DisSelect();//取消片选
    SPI_WriteReadByte(0xff);
    return r1;//
}

在后续的移植过程中，还需要给文件系统一个接口用来读取扇区数,一个接口用来判断sd卡是否忙碌：

uint32_t SD_GetSectorCount(void)
{
    uint8_t csd[16];
    uint32_t Capacity;
    uint8_t n;
    uint16_t csize;
    //取CSD信息，如果期间出错，返回0
    if(SD_GetCSD(csd)!=0) return 0;
    //如果为SDHC卡，按照下面方式计算
    if((csd[0]&0xC0)==0x40)  //V2.00的卡
    {
        csize = csd[9] + ((uint16_t)csd[8] << 8) + 1;
        Capacity = (uint32_t)csize << 10;//得到扇区数
    }else//V1.XX的卡
    {
        n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
        csize = (csd[8] >> 6) + ((uint16_t)csd[7] << 2) + ((uint16_t)(csd[6] & 3) << 10) + 1;
        Capacity= (uint32_t)csize << (n - 9);//得到扇区数
    }
    return Capacity;
}
uint8_t SD_WaitReady(void)
{
    uint32_t t=0;
    SD_cs_output(0);
    do
    {
        if(SPI_WriteReadByte(0XFF)==0XFF)return 0;//OK
        t++;
    }while(t<0XFF);//等待
    SD_cs_output(1);
    return 1;
}

最终，向文件系统暴露的接口总共有：

uint8_t SD_WaitReady(void);
uint8_t SD_Init(void);
uint32_t SD_GetSectorCount(void);
uint8_t SD_ReadDisk(uint8_t*buf,uint32_t sector,uint8_t cnt);
uint8_t SD_WriteDisk(const uint8_t*buf,uint32_t sector,uint8_t cnt);
截至到这里，我们已经完成了sd卡驱动移植，可以将sd卡作为flash芯片读写数据使用，但是我们可能存在某种需求将单片机保存在内存卡中的文件放在windows上读取或者在单片机上读取windows保存在sd卡的文件，因此我们还需要移植文件系统，文件系统可以帮助我们管理文件，实现sd卡跨设备读写。
文章目录