一、前言
在现代科技飞速发展的背景下，存储解决方案的创新与进步成为了推动各行各业发展的重要力量。这篇文章讲解雷龙公司出品的CS SD NAND贴片式TF卡的深度测评。这款产品不仅以其小巧精致的设计脱颖而出，更凭借其卓越的性能和可靠性，在众多存储介质中独树一帜。本文将详细探讨CS SD NAND贴片式TF卡的特点、技术参数及其与传统TF卡的区别，并通过实际使用案例展示其在不同应用场景中的表现。
二、实物
前段时间有幸免费得到了雷龙出品的贴片式的TF卡的芯片及转接板，两片贴片式nand芯片＋一个转接板，一种一个已让官方焊接完好；如下图所示：
从获得的相关资料看，雷龙出品的贴片式芯片分为两类，即BOW型和AOW型，其中BOW型为第一代产品，属商业级；AOW型则是第二代产品，属工业级或接近工业级。
本次收到的具体型号是CSNP16GCR01-AOW使用pSLC技术，拥有高容量的同时兼具SLC的特性，不用写驱动程序自带坏块管理的NAND Flash（贴片式TF卡），尺寸小巧，简单易用，兼容性强，稳定可靠，固件可定制，LGA-8封装，标准SDIO接口，兼容SPI，兼容拔插式TF卡/SD卡，可替代普通TF卡/SD卡，尺寸6.2x8mm，内置平均读写算法，通过1万次随机掉电测试，耐高低温，机贴手贴都非常方便，速度级别Class10，标准的SD 2.0协议使得用户可以直接移植标准驱动代码，省去了驱动代码编程环节。支持TF卡启动的SOC都可以用SD NAND，提供STM32参考例程及原厂技术支持，容量：2GB，比TF卡稳定，比eMMC易用。
雷龙CS SD NAND要远远比TF卡小。芯片能支持两种读写方式，即SD模式和SPI模式在使用时，它有2种工作模式，即默认模式和高速模式。
三、SD NAND特征
3.1 SD卡简介
雷龙公司推出的SD NAND存储解决方案，如CSNP4GCR01-AMW与CSNP32GCR01-AOW等型号，是专为满足现代嵌入式系统需求而设计的一种高效存储介质。这些SD NAND存储芯片结合了高性能NAND闪存与先进的SD控制器技术，能够在确保数据完整性的同时提供出色的读写速度。特别是它们具备强大的坏块管理能力和先进的纠错算法，即使在遭遇意外断电的情况下也能有效保护数据免受损失。
从技术规格来看，这些SD NAND产品兼容SD2.0标准，支持2线或4线接口配置，适用于各种不同的应用场景。它们的工作电压范围为2.7V至3.6V，这使得它们非常适合作为便携式设备或电池供电系统的理想选择。此外，这些芯片提供了两种工作模式以适应不同的性能需求：默认模式下，最大接口传输速度可达12.5MB/s；而在高速模式下，这一数值翻倍达到25MB/s，极大地提升了数据处理效率。值得注意的是，无论处于哪种模式，均需配合4条并行数据线来实现最佳性能表现。
雷龙的SD NAND存储方案还特别强调了环境适应性，其工作温度范围宽泛，从-40°C到+85°C，确保了即便是在极端条件下也能稳定运行。同时，这些芯片拥有极低的待机电流消耗（<250uA），有助于延长移动设备的电池寿命。安全性方面，除了基本的数据保护措施外，该系列产品还集成了符合SDMI最高安全标准的内容保护机制，支持通过CMD42命令实现SDNAND密码保护，增强了用户数据的安全性。另外，物理层面的写保护功能可以通过外部机械开关激活，而内部则同时提供了永久性和临时性的写保护选项，进一步增加了灵活性。
在通信协议的支持上，雷龙SD NAND芯片既支持SDIO读写也兼容SPI协议，这为开发者提供了更多样化的接入方式选择。尽管官方标称的最大读写速度可达25MB/s，但实际能达到的速度水平将取决于具体的MCU性能及所用接口类型等因素。对于那些对读写速率没有过高要求的应用场景而言，采用SPI协议往往是一个更为简便且成本效益更高的解决方案。无论是采取哪种协议，都必须严格遵循相关规范，以确保正确地建立文件系统并维持良好的数据交换质量。凭借其卓越的性能指标、丰富的功能特性以及广泛的应用潜力，雷龙SD NAND存储解决方案无疑成为了当今嵌入式领域内极具竞争力的产品之一。
3.2 SD卡Block图
该SD卡封装为LGA-8；引脚分配与定义如下；在这里插入图片描述:
四、编写SD NAND驱动代码
SD NAND 的驱动代码与正常的SD卡协议是一样的，支持标准的SD 2.0协议，下面我就直接贴出写好的驱动代码。
4.1 SPI模拟时序驱动方式
（1）整体工程代码
这是当前工程的截图: 代码采用寄存器风格编写，非常简洁。
当前工程完成SD NAND卡初始化，扇区的读写，测试芯片基本的使用情况。
（2） sd.c
#include "sdcard.h"
static u8 SD_Type=0; //存放SD卡的类型/*
函数功能：SD卡底层接口,通过SPI时序向SD卡读写一个字节
函数参数：data是要写入的数据
返 回 值：读到的数据
*/
u8 SDCardReadWriteOneByte(u8 DataTx)
{ u8 i;u8 data=0;for(i=0;i<8;i++){SDCARD_SCK=0;if(DataTx&0x80)SDCARD_MOSI=1;else SDCARD_MOSI=0;SDCARD_SCK=1;DataTx<<=1;data<<=1;if(SDCARD_MISO)data|=0x01;}return data;
}//4种: 边沿两种、电平是两种
/*
函数功能：底层SD卡接口初始化本程序SPI接口如下：
PC11 片选 SDCardCS
PC12 时钟 SDCardSCLK
PD2 输出 SPI_MOSI--主机输出从机输入
PC8 输入 SPI_MISO--主机输入从机输出
*/
void SDCardSpiInit(void)
{/*1. 开启时钟*/RCC->APB2ENR|=1<<5; //使能PORTD时钟RCC->APB2ENR|=1<<4; //使能PORTC时钟/*2. 配置GPIO口模式*/GPIOC->CRH&=0xFFF00FF0;GPIOC->CRH|=0x00033008;GPIOD->CRL&=0xFFFFF0FF;GPIOD->CRL|=0x00000300;/*3. 上拉*/GPIOC->ODR|=1<<8;GPIOC->ODR|=1<<11;GPIOC->ODR|=1<<12;GPIOD->ODR|=1<<2;
}/*
函数功能：取消选择,释放SPI总线
*/
void SDCardCancelCS(void)
{SDCARD_CS=1;SDCardReadWriteOneByte(0xff);//提供额外的8个时钟
}/*
函数 功 能：选择sd卡,并且等待卡准备OK
函数返回值：0,成功;1,失败;
*/
void SDCardSelectCS(void)
{SDCARD_CS=0;SDCardWaitBusy();//等待成功
}/*
函数 功 能：等待卡准备好
函数返回值：0,准备好了;其他,错误代码
*/
void SDCardWaitBusy(void)
{while(SDCardReadWriteOneByte(0XFF)!=0XFF){}
}/*
函数功能：等待SD卡回应
函数参数：Response:要得到的回应值
返 回 值：0,成功得到了该回应值其他,得到回应值失败
*/
u8 SDCardGetAck(u8 Response)
{u16 Count=0xFFFF;//等待次数 while((SDCardReadWriteOneByte(0XFF)!=Response)&&Count)Count--;//等待得到准确的回应 if(Count==0)return SDCard_RESPONSE_FAILURE;//得到回应失败 else return SDCard_RESPONSE_NO_ERROR;//正确回应
}/*
函数功能：从sd卡读取一个数据包的内容
函数参数：buf:数据缓存区len:要读取的数据长度.
返回值：0,成功;其他,失败;
*/
u8 SDCardRecvData(u8*buf,u16 len)
{ if(SDCardGetAck(0xFE))return 1;//等待SD卡发回数据起始令牌0xFEwhile(len--)//开始接收数据{*buf=SDCardReadWriteOneByte(0xFF);buf++;}//下面是2个伪CRC（dummy CRC）SDCardReadWriteOneByte(0xFF);SDCardReadWriteOneByte(0xFF); return 0;//读取成功
}/*
函数功能：向sd卡写入一个数据包的内容 512字节
函数参数：buf 数据缓存区cmd 指令
返 回 值：0表示成功;其他值表示失败;
*/
u8 SDCardSendData(u8*buf,u8 cmd)
{ u16 t; SDCardWaitBusy(); //等待忙状态SDCardReadWriteOneByte(cmd);if(cmd!=0XFD)//不是结束指令{for(t=0;t<512;t++)SDCardReadWriteOneByte(buf[t]);//提高速度,减少函数传参时间SDCardReadWriteOneByte(0xFF); //忽略crcSDCardReadWriteOneByte(0xFF);t=SDCardReadWriteOneByte(0xFF); //接收响应if((t&0x1F)!=0x05)return 2; //响应错误 } return 0;//写入成功
}/*
函数功能：向SD卡发送一个命令
函数参数：u8 cmd 命令 u32 arg 命令参数u8 crc crc校验值
返回值:SD卡返回的响应
*/
u8 SendSDCardCmd(u8 cmd, u32 arg, u8 crc)
{u8 r1; SDCardCancelCS(); //取消上次片选SDCardSelectCS(); //选中SD卡//发送数据SDCardReadWriteOneByte(cmd | 0x40);//分别写入命令SDCardReadWriteOneByte(arg >> 24);SDCardReadWriteOneByte(arg >> 16);SDCardReadWriteOneByte(arg >> 8);SDCardReadWriteOneByte(arg); SDCardReadWriteOneByte(crc); if(cmd==SDCard_CMD12)SDCardReadWriteOneByte(0xff);//Skip a stuff byte when stop readingdo{r1=SDCardReadWriteOneByte(0xFF);}while(r1&0x80); //等待响应，或超时退出return r1; //返回状态值
}/*
函数功能：获取SD卡的CID信息，包括制造商信息
函数参数：u8 *cid_data(存放CID的内存，至少16Byte）
返 回 值：0：成功，1：错误
*/
u8 GetSDCardCISDCardOutnfo(u8 *cid_data)
{u8 r1; //发SDCard_CMD10命令，读CIDr1=SendSDCardCmd(SDCard_CMD10,0,0x01);if(r1==0x00){r1=SDCardRecvData(cid_data,16);//接收16个字节的数据 }SDCardCancelCS();//取消片选if(r1)return 1;else return 0;
} /*
函数说明：获取SD卡的CSD信息，包括容量和速度信息
函数参数：u8 *cid_data(存放CID的内存，至少16Byte）
返 回 值：0：成功，1：错误
*/
u8 GetSDCardCSSDCardOutnfo(u8 *csd_data)
{u8 r1; r1=SendSDCardCmd(SDCard_CMD9,0,0x01); //发SDCard_CMD9命令，读CSDif(r1==0){r1=SDCardRecvData(csd_data, 16);//接收16个字节的数据 }SDCardCancelCS();//取消片选if(r1)return 1;else return 0;
} /*
函数功能：获取SD卡的总扇区数（扇区数）
返 回 值：0表示容量检测出错，其他值表示SD卡的容量(扇区数/512字节)
说 明：每扇区的字节数必为512字节，如果不是512字节，则初始化不能通过.
*/
u32 GetSDCardSectorCount(void)
{u8 csd[16];u32 Capacity; u16 csize; if(GetSDCardCSSDCardOutnfo(csd)!=0) return 0; //取CSD信息，如果期间出错，返回0if((csd[0]&0xC0)==0x40) //SDHC卡，按照下面方式计算{ csize = csd[9] + ((u16)csd[8] << 8) + 1;Capacity = (u32)csize << 10;//得到扇区数 }return Capacity;
}/*
函数功能： 初始化SD卡
返 回 值： 非0表示初始化失败!
*/
u8 SDCardDeviceInit(void)
{u8 r1; // 存放SD卡的返回值u8 buf[4]; u16 i;SDCardSpiInit();//初始化底层IO口for(i=0;i<10;i++)SDCardReadWriteOneByte(0xFF); //发送最少74个脉冲do{r1=SendSDCardCmd(SDCard_CMD0,0,0x95);//进入IDLE状态 闲置}while(r1!=0X01);SD_Type=0; //默认无卡if(r1==0X01){if(SendSDCardCmd(SDCard_CMD8,0x1AA,0x87)==1) //SD V2.0{for(i=0;i<4;i++)buf[i]=SDCardReadWriteOneByte(0XFF);if(buf[2]==0X01&&buf[3]==0XAA) //卡是否支持2.7~3.6V{do{SendSDCardCmd(SDCard_CMD55,0,0X01); //发送SDCard_CMD55r1=SendSDCardCmd(SDCard_CMD41,0x40000000,0X01);//发送SDCard_CMD41}while(r1);if(SendSDCardCmd(SDCard_CMD58,0,0X01)==0)//鉴别SD2.0卡版本开始{for(i=0;i<4;i++)buf[i]=SDCardReadWriteOneByte(0XFF);//得到OCR值if(buf[0]&0x40)SD_Type=SDCard_TYPE_V2HC; //检查CCSelse SD_Type=SDCard_TYPE_V2; }}}}printf("SD_Type=0x%X\r\n",SD_Type);SDCardCancelCS(); //取消片选if(SD_Type)return 0; //初始化成功返回0else if(r1)return r1; //返回值错误值 return 0xaa; //其他错误
}/*
函数功能：读SD卡
函数参数：buf:数据缓存区sector:扇区cnt:扇区数
返回值:0,ok;其他,失败.
说 明：SD卡一个扇区大小512字节
*/
u8 SDCardReadData(u8*buf,u32 sector,u32 cnt)
{u8 r1;if(SD_Type!=SDCard_TYPE_V2HC)sector<<=9;//转换为字节地址if(cnt==1){r1=SendSDCardCmd(SDCard_CMD17,sector,0X01);//读命令if(r1==0) //指令发送成功{r1=SDCardRecvData(buf,512); //接收512个字节 }}else{r1=SendSDCardCmd(SDCard_CMD18,sector,0X01);//连续读命令do{r1=SDCardRecvData(buf,512);//接收512个字节 buf+=512; }while(--cnt && r1==0); SendSDCardCmd(SDCard_CMD12,0,0X01); //发送停止命令} SDCardCancelCS();//取消片选return r1;//
}/*
函数功能：向SD卡写数据
函数参数：buf:数据缓存区sector:起始扇区cnt:扇区数
返回值：0,ok;其他,失败.
说 明：SD卡一个扇区大小512字节
*/
u8 SDCardWriteData(u8*buf,u32 sector,u32 cnt)
{u8 r1;if(SD_Type!=SDCard_TYPE_V2HC)sector *= 512;//转换为字节地址if(cnt==1){r1=SendSDCardCmd(SDCard_CMD24,sector,0X01);//读命令if(r1==0)//指令发送成功{r1=SDCardSendData(buf,0xFE);//写512个字节 }}else{if(SD_Type!=SDCard_TYPE_MMC){SendSDCardCmd(SDCard_CMD55,0,0X01); SendSDCardCmd(SDCard_CMD23,cnt,0X01);//发送指令 }r1=SendSDCardCmd(SDCard_CMD25,sector,0X01);//连续读命令if(r1==0){do{r1=SDCardSendData(buf,0xFC);//接收512个字节 buf+=512; }while(--cnt && r1==0);r1=SDCardSendData(0,0xFD);//接收512个字节 }} SDCardCancelCS();//取消片选return r1;//
}
（3） sd.h
#ifndef SD_H
#define SD_H_
#include "stm32f10x.h"
#include "led.h"
#include "usart.h"/*----------------------------------------------
本程序SPI接口如下：
PC11 片选 SDCardCS
PC12 时钟 SDCardSCLK
PD2 输出 SPI_MOSI--主机输出从机输入
PC8 输入 SPI_MISO--主机输入从机输出
------------------------------------------------*/
#define SDCARD_CS PCout(11)
#define SDCARD_SCK PCout(12)
#define SDCARD_MOSI PDout(2)
#define SDCARD_MISO PCin(8)// SD卡类型定义
#define SDCard_TYPE_ERR 0X00 //卡类型错误
#define SDCard_TYPE_MMC 0X01 //MMC卡
#define SDCard_TYPE_V1 0X02
#define SDCard_TYPE_V2 0X04
#define SDCard_TYPE_V2HC 0X06 // SD卡指令表
#define SDCard_CMD0 0 //卡复位
#define SDCard_CMD1 1
#define SDCard_CMD8 8 //命令8 ，SEND_IF_COND
#define SDCard_CMD9 9 //命令9 ，读CSD数据
#define SDCard_CMD10 10 //命令10，读CID数据
#define SDCard_CMD12 12 //命令12，停止数据传输
#define SDCard_CMD13 16 //命令16，设置扇区大小 应返回0x00
#define SDCard_CMD17 17 //命令17，读扇区
#define SDCard_CMD18 18 //命令18，读Multi 扇区
#define SDCard_CMD23 23 //命令23，设置多扇区写入前预先擦除N个block
#define SDCard_CMD24 24 //命令24，写扇区
#define SDCard_CMD25 25 //命令25，写多个扇区
#define SDCard_CMD41 41 //命令41，应返回0x00
#define SDCard_CMD55 55 //命令55，应返回0x01
#define SDCard_CMD58 58 //命令58，读OCR信息
#define SDCard_CMD59 59 //命令59，使能/禁止CRC，应返回0x00、/*SD卡回应标记字*/
#define SDCard_RESPONSE_NO_ERROR 0x00 //正确回应
#define SDCard_SD_IN_IDLE_STATE 0x01 //闲置状态
#define SDCard_SD_ERASE_RESET 0x02 //擦除复位
#define SDCard_RESPONSE_FAILURE 0xFF //响应失败//函数声明
u8 SDCardReadWriteOneByte(u8 data); //底层接口，SPI读写字节函数
void SDCardWaitBusy(void); //等待SD卡准备
u8 SDCardGetAck(u8 Response); //获得应答
u8 SDCardDeviceInit(void); //初始化
u8 SDCardReadData(u8*buf,u32 sector,u32 cnt); //读块(扇区)
u8 SDCardWriteData(u8*buf,u32 sector,u32 cnt); //写块(扇区)
u32 GetSDCardSectorCount(void); //读扇区数
u8 GetSDCardCISDCardOutnfo(u8 *cid_data); //读SD卡CID
u8 GetSDCardCSSDCardOutnfo(u8 *csd_data); //读SD卡CSD
#endif
（4）运行效果
4.2 SDIO方式
如果想提高SD NAND的读写速度，可以采用SDIO协议，STM32本身有SDIO的硬件支持，配置好SDIO的寄存器即可完成SD NAND的操作。 SDIO的数据线都比SPI多，读写速度自然没法比的。
下面贴出STM32F103ZE上面编写的SDIO协议读写SD NAND的驱动代码。
（1）整体工程代码
（2）sdio.c
#include "sdio_sdcard.h"
#include "string.h"
#include "sys.h"
#include "usart.h" static u8 CardType=SDIO_STD_CAPACITY_SD_CARD_V1_1; //SD卡类型（默认为1.x卡）
static u32 CSD_Tab[4],CID_Tab[4],RCA=0; //SD卡CSD,CID以及相对地址(RCA)数据
static u8 DeviceMode=SD_DMA_MODE; //工作模式,注意,工作模式必须通过SDIO_SdCardSetDeviceMode,后才算数.这里只是定义一个默认的模式(SD_DMA_MODE)
static u8 StopCondition=0; //是否发送停止传输标志位,DMA多块读写的时候用到
volatile SDIO_SD_ERROR_INFO TransferError=SD_OK; //数据传输错误标志,DMA读写时使用
volatile u8 TransferEnd=0; //传输结束标志,DMA读写时使用
SD_CardInfo SDCardInfo; //SD卡信息//SDIO_SdCardReadDiskSector/SDIO_SdCardWriteDiskSector函数专用buf,当这两个函数的数据缓存区地址不是4字节对齐的时候,
//需要用到该数组,确保数据缓存区地址是4字节对齐的.
__align(4) u8 SDIO_DATA_BUFFER[512]; /*
SD卡与开发板的SDIO方式接线关系如下:DATA0---PC8DATA1---PC9DATA2---PC10DATA3---PC11CLK-----PC1CMD-----PD2
*//*
函数功能:SDIO方式初始化SD卡
返回值 :错误代码;(0,无错误)
*/
SDIO_SD_ERROR_INFO SDIO_SdCardInit(void)
{u8 clkdiv=0;SDIO_SD_ERROR_INFO errorstatus=SD_OK; //SDIO IO口初始化RCC->APB2ENR|=1<<4; //使能PORTC时钟 RCC->APB2ENR|=1<<5; //使能PORTD时钟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复用输出,PD7 上拉输入//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; STM32_NVIC_SetPriority(SDIO_IRQn,0,0); //SDIO中断配置errorstatus=SDIO_SdPowerON(); //SD卡上电SDIO_SdCardInitializeCards(); //初始化SD卡 SDIO_SdCardGetInfo(&SDCardInfo); //获取卡信息SDIO_SdCardSelectAddr((u32)(SDCardInfo.RCA<<16));//选中SD卡 SDIO_SdCardEnableWideBusOperation(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=12MhzSDIO_ClockSet(clkdiv); //设置时钟频率,SDIO时钟计算公式:SDIO_CK时钟=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定为48Mhz errorstatus=SDIO_SdCardSetDeviceMode(SD_POLLING_MODE); //设置为查询模式}return errorstatus;
}/*
函数功能: SDIO时钟初始化设置
函数参数:clkdiv:时钟分频系数CK时钟=SDIOCLK/[clkdiv+2];(SDIOCLK时钟固定为48Mhz)
*/
void SDIO_ClockSet(u8 clkdiv)
{u32 tmpreg=SDIO->CLKCR; tmpreg&=0XFFFFFF00; tmpreg|=clkdiv; SDIO->CLKCR=tmpreg;
} /*
函数功能: SDIO发送命令函数
函数参数:cmdindex:命令索引,低六位有效waitrsp:期待的相应.00/10,无响应;01,短响应;11,长响应arg:参数
*/
void SDIO_SendCmd(u8 cmdindex,u8 waitrsp,u32 arg)
{ u32 tmpreg;SDIO->ARG=arg;tmpreg=SDIO->CMD; tmpreg&=0XFFFFF800; //清除index和waitrsptmpreg|=cmdindex&0X3F; //设置新的index tmpreg|=waitrsp<<6; //设置新的wait rsp tmpreg|=0<<8; //无等待tmpreg|=1<<10; //命令通道状态机使能SDIO->CMD=tmpreg;
}/*
函数功能: SDIO发送数据配置函数
函数参数:datatimeout:超时时间设置datalen:传输数据长度,低25位有效,必须为块大小的整数倍blksize:块大小.实际大小为:2^blksize字节dir:数据传输方向:0,控制器到卡;1,卡到控制器;
*/
void SDIO_SendDataConfig(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;
} /*
函数功能:卡上电查询所有SDIO接口上的卡设备,并查询其电压和配置时钟
返回值:错误代码;(0,无错误)
*/
SDIO_SD_ERROR_INFO SDIO_SdPowerON(void)
{u8 i=0;SDIO_SD_ERROR_INFO 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上升沿产生SDIOCKSDIO->CLKCR|=0<<14; //关闭硬件流控制 SDIO_ClockSet(SDIO_INIT_CLK_DIV);//设置时钟频率(初始化的时候,不能超过400Khz) SDIO->POWER=0X03; //上电状态,开启卡时钟 SDIO->CLKCR|=1<<8; //SDIOCK使能 for(i=0;i<74;i++){SDIO_SendCmd(SD_CMD_GO_IDLE_STATE,0,0);//发送CMD0进入IDLE STAGE模式命令. errorstatus=SDIO_CmdErrorCheck();if(errorstatus==SD_OK)break;}if(errorstatus)return errorstatus;//返回错误状态SDIO_SendCmd(SDIO_SEND_IF_COND,1,SD_CHECK_PATTERN);//发送CMD8,短响应,检查SD卡接口特性.//arg[11:8]:01,支持电压范围,2.7~3.6V//arg[7:0]:默认0XAA//返回响应7errorstatus=SDIO_CmdResp7Error(); //等待R7响应if(errorstatus==SD_OK) //R7响应正常{CardType=SDIO_STD_CAPACITY_SD_CARD_V2_0; //SD 2.0卡SDType=SD_HIGH_CAPACITY; //高容量卡}SDIO_SendCmd(SD_CMD_APP_CMD,1,0); //发送CMD55,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应 if(errorstatus==SD_OK)//SD2.0/SD 1.1{ //SD卡,发送ACMD41 SD_APP_OP_COND,参数为:0x80100000 while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL)){ SDIO_SendCmd(SD_CMD_APP_CMD,1,0); //发送CMD55,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应 if(errorstatus!=SD_OK)return errorstatus; //响应错误SDIO_SendCmd(SD_CMD_SD_APP_OP_COND,1,SD_VOLTAGE_WINDOW_SD|SDType);//发送ACMD41,短响应 errorstatus=SDIO_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);
}/*
函数功能: SD卡断电
返回值:错误代码;(0,无错误)
*/
SDIO_SD_ERROR_INFO SD_PowerOFF(void)
{SDIO->POWER&=~(3<<0);//SDIO电源关闭,时钟停止 return SD_OK;
} /*
函数功能:初始化所有的卡,并让卡进入就绪状态
返回值:错误代码
*/
SDIO_SD_ERROR_INFO SDIO_SdCardInitializeCards(void)
{SDIO_SD_ERROR_INFO errorstatus=SD_OK;u16 rca = 0x01;if((SDIO->POWER&0X03)==0)return SD_REQUEST_NOT_APPLICABLE;//检查电源状态,确保为上电状态if(SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD{SDIO_SendCmd(SD_CMD_ALL_SEND_CID,3,0); //发送CMD2,取得CID,长响应 errorstatus=SDIO_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_SendCmd(SD_CMD_SET_REL_ADDR,1,0); //发送CMD3,短响应 errorstatus=SDIO_CmdResp6Error(SD_CMD_SET_REL_ADDR,&rca);//等待R6响应 if(errorstatus!=SD_OK)return errorstatus; //响应错误 } if(SDIO_MULTIMEDIA_CARD==CardType){SDIO_SendCmd(SD_CMD_SET_REL_ADDR,1,(u32)(rca<<16));//发送CMD3,短响应 errorstatus=SDIO_CmdResp2Error(); //等待R2响应 if(errorstatus!=SD_OK)return errorstatus; //响应错误 }if(SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD{RCA = rca;SDIO_SendCmd(SD_CMD_SEND_CSD,3,(u32)(rca<<16));//发送CMD9+卡RCA,取得CSD,长响应 errorstatus=SDIO_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;//卡初始化成功
}/*
函数功能:得到卡信息
函数参数:cardinfo:卡信息存储区
返回值:错误状态
*/
SDIO_SD_ERROR_INFO SDIO_SdCardGetInfo(SD_CardInfo *cardinfo)
{SDIO_SD_ERROR_INFO 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; //数据读时间1tmp=(u8)((CSD_Tab[0]&0x0000FF00)>>8); //第2个字节cardinfo->SD_csd.NSAC=tmp; //数据读时间2tmp=(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; //保留if((CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1)||(CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0)||(SDIO_MULTIMEDIA_CARD==CardType))//标准1.1/2.0卡/MMC卡{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_MULTtmp=(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_SIZEtmp=(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;
}/*
函数功能: 设置SDIO总线宽度
函数参数:wmode:位宽模式.0,1位数据宽度;1,4位数据宽度;2,8位数据宽度
返回值:SD卡错误状态
*/
SDIO_SD_ERROR_INFO SDIO_SdCardEnableWideBusOperation(u32 wmode)
{SDIO_SD_ERROR_INFO errorstatus=SD_OK;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=SDIO_SdCardEnWideBus(wmode);if(SD_OK==errorstatus){SDIO->CLKCR&=~(3<<11); //清除之前的位宽设置 SDIO->CLKCR|=(u16)wmode<<11;//1位/4位总线宽度 SDIO->CLKCR|=0<<14; //不开启硬件流控制}} }return errorstatus;
}/*
函数功能:设置SD卡工作模式
返回值:错误状态
*/
SDIO_SD_ERROR_INFO SDIO_SdCardSetDeviceMode(u32 Mode)
{SDIO_SD_ERROR_INFO errorstatus = SD_OK;if((Mode==SD_DMA_MODE)||(Mode==SD_POLLING_MODE))DeviceMode=Mode;else errorstatus=SD_INVALID_PARAMETER;return errorstatus;
}/*
函数功能:选卡,发送CMD7,选择相对地址(rca)为addr的卡,取消其他卡.如果为0,则都不选择.
函数参数:addr:卡的RCA地址
*/
SDIO_SD_ERROR_INFO SDIO_SdCardSelectAddr(u32 addr)
{SDIO_SendCmd(SD_CMD_SEL_DESEL_CARD,1,addr); //发送CMD7,选择卡,短响应 return SDIO_CmdResp1Error(SD_CMD_SEL_DESEL_CARD);
}/*
函数功能: SD卡读取一个块
函数参数: buf:读数据缓存区(必须4字节对齐!!)addr:读取地址blksize:块大小
*/
SDIO_SD_ERROR_INFO SDIO_SdCardReadBlock(u8 *buf,long long addr,u16 blksize)
{ SDIO_SD_ERROR_INFO 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_SendDataConfig(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_SendCmd(SD_CMD_SET_BLOCKLEN,1,blksize); //发送CMD16+设置数据长度为blksize,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1响应 if(errorstatus!=SD_OK)return errorstatus; //响应错误 }else return SD_INVALID_PARAMETER; SDIO_SendDataConfig(SD_DATATIMEOUT,blksize,power,1); //blksize,卡到控制器 SDIO_SendCmd(SD_CMD_READ_SINGLE_BLOCK,1,addr); //发送CMD17+从addr地址出读取数据,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_READ_SINGLE_BLOCK);//等待R1响应 if(errorstatus!=SD_OK)return errorstatus; //响应错误 if(DeviceMode==SD_POLLING_MODE) //查询模式,轮询数据 {// INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<10)|(1<<9))))//无上溢/CRC/超时/完成(标志)/起始位错误{if(SDIO->STA&(1<<15)) //接收区半满,表示至少存了8个字{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;}else if(SDIO->STA&(1<<1)) //数据块CRC错误{SDIO->ICR|=1<<1; //清错误标志return SD_DATA_CRC_FAIL; }else if(SDIO->STA&(1<<5)) //接收fifo上溢错误{SDIO->ICR|=1<<5; //清错误标志return SD_RX_OVERRUN; }else if(SDIO->STA&(1<<9)) //接收起始位错误{SDIO->ICR|=1<<9; //清错误标志return SD_START_BIT_ERR; } while(SDIO->STA&(1<<21)) //FIFO里面,还存在可用数据{*tempbuff=SDIO->FIFO; //循环读取数据tempbuff++;}// INTX_ENABLE();//开启总中断SDIO->ICR=0X5FF; //清除所有标记}else if(DeviceMode==SD_DMA_MODE){SDIO_SdCard_DMAConfig((u32*)buf,blksize,0); TransferError=SD_OK;StopCondition=0; //单块读,不需要发送停止传输指令TransferEnd=0; //传输结束标置位，在中断服务置1SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中断 SDIO->DCTRL|=1<<3; //SDIO DMA使能 while(((DMA2->ISR&0X2000)==RESET)&&(TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;//等待传输完成 if(timeout==0)return SD_DATA_TIMEOUT;//超时if(TransferError!=SD_OK)errorstatus=TransferError; } return errorstatus;
}/*
函数功能: SD卡读取多个块
函数参数: buf:读数据缓存区addr:读取地址blksize:块大小nblks:要读取的块数
返回值:错误状态
*/
__align(4) u32 *tempbuff;
SDIO_SD_ERROR_INFO SDIO_SdCardReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
{SDIO_SD_ERROR_INFO 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_SendDataConfig(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_SendCmd(SD_CMD_SET_BLOCKLEN,1,blksize); //发送CMD16+设置数据长度为blksize,短响应 errorstatus=SDIO_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_SendDataConfig(SD_DATATIMEOUT,nblks*blksize,power,1);//nblks*blksize,512块大小,卡到控制器 SDIO_SendCmd(SD_CMD_READ_MULT_BLOCK,1,addr); //发送CMD18+从addr地址出读取数据,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_READ_MULT_BLOCK);//等待R1响应 if(errorstatus!=SD_OK)return errorstatus; //响应错误 if(DeviceMode==SD_POLLING_MODE){
// INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<8)|(1<<9))))//无上溢/CRC/超时/完成(标志)/起始位错误{if(SDIO->STA&(1<<15)) //接收区半满,表示至少存了8个字{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;}else if(SDIO->STA&(1<<1)) //数据块CRC错误{SDIO->ICR|=1<<1; //清错误标志return SD_DATA_CRC_FAIL; }else if(SDIO->STA&(1<<5)) //接收fifo上溢错误{SDIO->ICR|=1<<5; //清错误标志return SD_RX_OVERRUN; }else if(SDIO->STA&(1<<9)) //接收起始位错误{SDIO->ICR|=1<<9; //清错误标志return SD_START_BIT_ERR; } while(SDIO->STA&(1<<21)) //FIFO里面,还存在可用数据{*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_SendCmd(SD_CMD_STOP_TRANSMISSION,1,0); //发送CMD12+结束传输 errorstatus=SDIO_CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1响应 if(errorstatus!=SD_OK)return errorstatus; }}// INTX_ENABLE();//开启总中断SDIO->ICR=0X5FF; //清除所有标记 }else if(DeviceMode==SD_DMA_MODE){SDIO_SdCard_DMAConfig((u32*)buf,nblks*blksize,0); TransferError=SD_OK;StopCondition=1; //多块读,需要发送停止传输指令 TransferEnd=0; //传输结束标置位，在中断服务置1SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中断 SDIO->DCTRL|=1<<3; //SDIO DMA使能 while(((DMA2->ISR&0X2000)==RESET)&&timeout)timeout--;//等待传输完成 if(timeout==0)return SD_DATA_TIMEOUT;//超时while((TransferEnd==0)&&(TransferError==SD_OK)); if(TransferError!=SD_OK)errorstatus=TransferError; } }return errorstatus;
} /*
函数功能:SD卡写1个块
函数参数:buf:数据缓存区addr:写地址blksize:块大小
返回值:错误状态
*/
SDIO_SD_ERROR_INFO SDIO_SdCardWriteBlock(u8 *buf,long long addr, u16 blksize)
{SDIO_SD_ERROR_INFO 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_SendDataConfig(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_SendCmd(SD_CMD_SET_BLOCKLEN,1,blksize); //发送CMD16+设置数据长度为blksize,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1响应 if(errorstatus!=SD_OK)return errorstatus; //响应错误 }else return SD_INVALID_PARAMETER; SDIO_SendCmd(SD_CMD_SEND_STATUS,1,(u32)RCA<<16); //发送CMD13,查询卡的状态,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_SEND_STATUS); //等待R1响应 if(errorstatus!=SD_OK)return errorstatus;cardstatus=SDIO->RESP1; timeout=SD_DATATIMEOUT;while(((cardstatus&0x00000100)==0)&&(timeout>0)) //检查READY_FOR_DATA位是否置位{timeout--;SDIO_SendCmd(SD_CMD_SEND_STATUS,1,(u32)RCA<<16);//发送CMD13,查询卡的状态,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_SEND_STATUS); //等待R1响应 if(errorstatus!=SD_OK)return errorstatus; cardstatus=SDIO->RESP1; }if(timeout==0)return SD_ERROR;SDIO_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK,1,addr); //发送CMD24,写单块指令,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_WRITE_SINGLE_BLOCK);//等待R1响应 if(errorstatus!=SD_OK)return errorstatus; StopCondition=0; //单块写,不需要发送停止传输指令 SDIO_SendDataConfig(SD_DATATIMEOUT,blksize,power,0); //blksize, 控制器到卡 timeout=SDIO_DATATIMEOUT;if(DeviceMode == SD_POLLING_MODE){// INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)while(!(SDIO->STA&((1<<10)|(1<<4)|(1<<1)|(1<<3)|(1<<9))))//数据块发送成功/下溢/CRC/超时/起始位错误{if(SDIO->STA&(1<<14)) //发送区半空,表示至少存了8个字{if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不够32字节了{restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4){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;}else if(SDIO->STA&(1<<1)) //数据块CRC错误{SDIO->ICR|=1<<1; //清错误标志return SD_DATA_CRC_FAIL; }else if(SDIO->STA&(1<<4)) //接收fifo下溢错误{SDIO->ICR|=1<<4; //清错误标志return SD_TX_UNDERRUN; }else if(SDIO->STA&(1<<9)) //接收起始位错误{SDIO->ICR|=1<<9; //清错误标志return SD_START_BIT_ERR; }
// INTX_ENABLE();//开启总中断SDIO->ICR=0X5FF; //清除所有标记 }else if(DeviceMode==SD_DMA_MODE){SDIO_SdCard_DMAConfig((u32*)buf,blksize,1);//SDIO DMA配置TransferError=SD_OK;StopCondition=0; //单块写,不需要发送停止传输指令 TransferEnd=0; //传输结束标置位，在中断服务置1SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置产生数据接收完成中断SDIO->DCTRL|=1<<3; //SDIO DMA使能. while(((DMA2->ISR&0X2000)==RESET)&&timeout)timeout--;//等待传输完成 if(timeout==0){SDIO_SdCardInit(); //重新初始化SD卡,可以解决写入死机的问题return SD_DATA_TIMEOUT; //超时 }timeout=SDIO_DATATIMEOUT;while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;if(timeout==0)return SD_DATA_TIMEOUT; //超时 if(TransferError!=SD_OK)return TransferError;} SDIO->ICR=0X5FF; //清除所有标记errorstatus=SDIO_SdCardProgrammingState(&cardstate);while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING))){errorstatus=SDIO_SdCardProgrammingState(&cardstate);} return errorstatus;
}/*
函数功能:SD卡写多个块
函数参数:buf:数据缓存区addr:写地址blksize:块大小nblks:要写入的块数
返回值:错误状态
*/
SDIO_SD_ERROR_INFO SDIO_SdCardWriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
{SDIO_SD_ERROR_INFO 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_SendDataConfig(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_SendCmd(SD_CMD_SET_BLOCKLEN,1,blksize); //发送CMD16+设置数据长度为blksize,短响应 errorstatus=SDIO_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_SendCmd(SD_CMD_APP_CMD,1,(u32)RCA<<16); //发送ACMD55,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应 if(errorstatus!=SD_OK)return errorstatus; SDIO_SendCmd(SD_CMD_SET_BLOCK_COUNT,1,nblks); //发送CMD23,设置块数量,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_SET_BLOCK_COUNT);//等待R1响应 if(errorstatus!=SD_OK)return errorstatus; } SDIO_SendCmd(SD_CMD_WRITE_MULT_BLOCK,1,addr); //发送CMD25,多块写指令,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_WRITE_MULT_BLOCK); //等待R1响应 if(errorstatus!=SD_OK)return errorstatus;SDIO_SendDataConfig(SD_DATATIMEOUT,nblks*blksize,power,0);//blksize, 控制器到卡 if(DeviceMode==SD_POLLING_MODE){timeout=SDIO_DATATIMEOUT;while(!(SDIO->STA&((1<<4)|(1<<1)|(1<<8)|(1<<3)|(1<<9))))//下溢/CRC/数据结束/超时/起始位错误{if(SDIO->STA&(1<<14)) //发送区半空,表示至少存了8字(32字节){ if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不够32字节了{restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4){SDIO->FIFO=*tempbuff;}}else //发送区半空,可以发送至少8字(32字节)数据{for(count=0;count<SD_HALFFIFO;count++){SDIO->FIFO=*(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;}else if(SDIO->STA&(1<<1)) //数据块CRC错误{SDIO->ICR|=1<<1; //清错误标志return SD_DATA_CRC_FAIL; }else if(SDIO->STA&(1<<4)) //接收fifo下溢错误{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_SendCmd(SD_CMD_STOP_TRANSMISSION,1,0); //发送CMD12+结束传输 errorstatus=SDIO_CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1响应 if(errorstatus!=SD_OK)return errorstatus; }}
// INTX_ENABLE();//开启总中断SDIO->ICR=0X5FF; //清除所有标记 }else if(DeviceMode==SD_DMA_MODE){SDIO_SdCard_DMAConfig((u32*)buf,nblks*blksize,1);//SDIO DMA配置TransferError=SD_OK;StopCondition=1; //多块写,需要发送停止传输指令 TransferEnd=0; //传输结束标置位，在中断服务置1SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置产生数据接收完成中断SDIO->DCTRL|=1<<3; //SDIO DMA使能. timeout=SDIO_DATATIMEOUT;while(((DMA2->ISR&0X2000)==RESET)&&timeout)timeout--;//等待传输完成 if(timeout==0) //超时{ SDIO_SdCardInit(); //重新初始化SD卡,可以解决写入死机的问题return SD_DATA_TIMEOUT; //超时 }timeout=SDIO_DATATIMEOUT;while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;if(timeout==0)return SD_DATA_TIMEOUT; //超时 if(TransferError!=SD_OK)return TransferError; }}SDIO->ICR=0X5FF; //清除所有标记errorstatus=SDIO_SdCardProgrammingState(&cardstate);while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING))){errorstatus=SDIO_SdCardProgrammingState(&cardstate);} return errorstatus;
}/*
函数功能: SDIO中断服务函数
*/
void SDIO_IRQHandler(void)
{ SDIO_SdCardProcessIRQSrc();//处理所有SDIO相关中断
}/*
函数功能: SDIO中断处理函数
函数参数: 处理SDIO传输过程中的各种中断事务
返回值:错误代码
*/
SDIO_SD_ERROR_INFO SDIO_SdCardProcessIRQSrc(void)
{if(SDIO->STA&(1<<8))//接收完成中断{ if(StopCondition==1){SDIO_SendCmd(SD_CMD_STOP_TRANSMISSION,1,0); //发送CMD12,结束传输 TransferError=SDIO_CmdResp1Error(SD_CMD_STOP_TRANSMISSION);}else TransferError = SD_OK; SDIO->ICR|=1<<8;//清除完成中断标记SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断TransferEnd = 1;return(TransferError);}if(SDIO->STA&(1<<1))//数据CRC错误{SDIO->ICR|=1<<1;//清除中断标记SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断TransferError = SD_DATA_CRC_FAIL;return(SD_DATA_CRC_FAIL);}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));//关闭相关中断TransferError = SD_DATA_TIMEOUT;return(SD_DATA_TIMEOUT);}if(SDIO->STA&(1<<5))//FIFO上溢错误{SDIO->ICR|=1<<5;//清除中断标记SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断TransferError = SD_RX_OVERRUN;return(SD_RX_OVERRUN);}if(SDIO->STA&(1<<4))//FIFO下溢错误{SDIO->ICR|=1<<4;//清除中断标记SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断TransferError = SD_TX_UNDERRUN;return(SD_TX_UNDERRUN);}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));//关闭相关中断TransferError = SD_START_BIT_ERR;return(SD_START_BIT_ERR);}return(SD_OK);
}/*
函数功能: 检查CMD0的执行状态
返回值: sd卡错误码
*/
SDIO_SD_ERROR_INFO SDIO_CmdErrorCheck(void)
{SDIO_SD_ERROR_INFO 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;
}/*
函数功能: 检查R7响应的错误状态
函数参数: 返回值:sd卡错误码
*/
SDIO_SD_ERROR_INFO SDIO_CmdResp7Error(void)
{SDIO_SD_ERROR_INFO errorstatus=SD_OK;u32 status;u32 timeout=SDIO_CMD0TIMEOUT;while(timeout--){status=SDIO->STA;if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功) }if((timeout==0)||(status&(1<<2))) //响应超时{ errorstatus=SD_CMD_RSP_TIMEOUT; //当前卡不是2.0兼容卡,或者不支持设定的电压范围SDIO->ICR|=1<<2; //清除命令响应超时标志return errorstatus;} if(status&1<<6) //成功接收到响应{ errorstatus=SD_OK;SDIO->ICR|=1<<6; //清除响应标志}return errorstatus;
}/*
函数功能:检查R1响应的错误状态
函数参数:cmd:当前命令
返回值:sd卡错误码
*/
SDIO_SD_ERROR_INFO SDIO_CmdResp1Error(u8 cmd)
{ u32 status; while(1){status=SDIO->STA;if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功)} if(status&(1<<2)) //响应超时{ SDIO->ICR=1<<2; //清除命令响应超时标志return SD_CMD_RSP_TIMEOUT;} if(status&(1<<0)) //CRC错误{ SDIO->ICR=1<<0; //清除标志return SD_CMD_CRC_FAIL;} if(SDIO->RESPCMD!=cmd)return SD_ILLEGAL_CMD;//命令不匹配 SDIO->ICR=0X5FF; //清除标记return (SDIO_SD_ERROR_INFO)(SDIO->RESP1&SD_OCR_ERRORBITS);//返回卡响应
}/*
函数功能: 检查R3响应的错误状态
返回值: 错误状态
*/
SDIO_SD_ERROR_INFO SDIO_CmdResp3Error(void)
{u32 status; while(1){status=SDIO->STA;if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功) }if(status&(1<<2)) //响应超时{ SDIO->ICR|=1<<2; //清除命令响应超时标志return SD_CMD_RSP_TIMEOUT;} SDIO->ICR=0X5FF; //清除标记return SD_OK;
}/*
函数功能: 检查R2响应的错误状态
返回值:错误状态
*/
SDIO_SD_ERROR_INFO SDIO_CmdResp2Error(void)
{SDIO_SD_ERROR_INFO errorstatus=SD_OK;u32 status;u32 timeout=SDIO_CMD0TIMEOUT;while(timeout--){status=SDIO->STA;if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功) }if((timeout==0)||(status&(1<<2))) //响应超时{ errorstatus=SD_CMD_RSP_TIMEOUT; SDIO->ICR|=1<<2; //清除命令响应超时标志return errorstatus;} if(status&1<<0) //CRC错误{ errorstatus=SD_CMD_CRC_FAIL;SDIO->ICR|=1<<0; //清除响应标志}SDIO->ICR=0X5FF; //清除标记return errorstatus;
}/*
函数功能: 检查R6响应的错误状态
函数参数:cmd:之前发送的命令prca:卡返回的RCA地址
返回值:错误状态
*/
SDIO_SD_ERROR_INFO SDIO_CmdResp6Error(u8 cmd,u16*prca)
{SDIO_SD_ERROR_INFO errorstatus=SD_OK;u32 status; u32 rspr1;while(1){status=SDIO->STA;if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功) }if(status&(1<<2)) //响应超时{ SDIO->ICR|=1<<2; //清除命令响应超时标志return SD_CMD_RSP_TIMEOUT;} if(status&1<<0) //CRC错误{ SDIO->ICR|=1<<0; //清除响应标志return SD_CMD_CRC_FAIL;}if(SDIO->RESPCMD!=cmd) //判断是否响应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位得到,rcareturn 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;
}/*
函数功能:SDIO使能宽总线模式
函数参数:enx:0,不使能;1,使能;
返回值:错误状态
*/
SDIO_SD_ERROR_INFO SDIO_SdCardEnWideBus(u8 enx)
{SDIO_SD_ERROR_INFO errorstatus = SD_OK;u32 scr[2]={0,0};u8 arg=0X00;if(enx)arg=0X02;else arg=0X00;if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//SD卡处于LOCKED状态 errorstatus=SDIO_SdCardFindSCR(RCA,scr); //得到SCR寄存器数据if(errorstatus!=SD_OK)return errorstatus;if((scr[1]&SD_WIDE_BUS_SUPPORT)!=SD_ALLZERO) //支持宽总线{SDIO_SendCmd(SD_CMD_APP_CMD,1,(u32)RCA<<16); //发送CMD55+RCA,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_CMD);if(errorstatus!=SD_OK)return errorstatus; SDIO_SendCmd(SD_CMD_APP_SD_SET_BUSWIDTH,1,arg);//发送ACMD6,短响应,参数:10,4位;00,1位. errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_SD_SET_BUSWIDTH);return errorstatus;}else return SD_REQUEST_NOT_APPLICABLE; //不支持宽总线设置
}/*
函数功能: 检查卡是否正在执行写操作
函数参数: pstatus:当前状态
返回值:错误代码
*/
SDIO_SD_ERROR_INFO SDIO_SdCardProgrammingState(u8 *pstatus)
{vu32 respR1 = 0, status = 0; SDIO_SendCmd(SD_CMD_SEND_STATUS,1,(u32)RCA<<16); //发送CMD13 status=SDIO->STA;while(!(status&((1<<0)|(1<<6)|(1<<2))))status=SDIO->STA;//等待操作完成if(status&(1<<0)) //CRC检测失败{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;
}/*
函数功能: 读取当前卡状态
函数参数: pcardstatus:卡状态
返回值 :错误代码
*/
SDIO_SD_ERROR_INFO SDIO_SdCardSendStatus(uint32_t *pcardstatus)
{SDIO_SD_ERROR_INFO errorstatus = SD_OK;if(pcardstatus==NULL){errorstatus=SD_INVALID_PARAMETER;return errorstatus;}SDIO_SendCmd(SD_CMD_SEND_STATUS,1,RCA<<16); //发送CMD13,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_SEND_STATUS); //查询响应状态 if(errorstatus!=SD_OK)return errorstatus;*pcardstatus=SDIO->RESP1;//读取响应值return errorstatus;
}/*
函数功能: 返回SD卡的状态
返回值 : SD卡状态
*/
SDCardState SDIO_SdCardGetState(void)
{u32 resp1=0;if(SDIO_SdCardSendStatus(&resp1)!=SD_OK)return SD_CARD_ERROR;else return (SDCardState)((resp1>>9) & 0x0F);
}/*
函数功能:查找SD卡的SCR寄存器值
函数参数:rca:卡相对地址pscr:数据缓存区(存储SCR内容)
返回值:错误状态
*/
SDIO_SD_ERROR_INFO SDIO_SdCardFindSCR(u16 rca,u32 *pscr)
{ u32 index = 0; SDIO_SD_ERROR_INFO errorstatus = SD_OK;u32 tempscr[2]={0,0}; SDIO_SendCmd(SD_CMD_SET_BLOCKLEN,1,8); //发送CMD16,短响应,设置Block Size为8字节 errorstatus=SDIO_CmdResp1Error(SD_CMD_SET_BLOCKLEN);if(errorstatus!=SD_OK)return errorstatus; SDIO_SendCmd(SD_CMD_APP_CMD,1,(u32)rca<<16); //发送CMD55,短响应 errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_CMD);if(errorstatus!=SD_OK)return errorstatus;SDIO_SendDataConfig(SD_DATATIMEOUT,8,3,1); //8个字节长度,block为8字节,SD卡到SDIO.SDIO_SendCmd(SD_CMD_SD_APP_SEND_SCR,1,0); //发送ACMD51,短响应,参数为0 errorstatus=SDIO_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))){ if(SDIO->STA&(1<<21))//接收FIFO数据可用{*(tempscr+index)=SDIO->FIFO; //读取FIFO内容index++;if(index>=2)break;}}if(SDIO->STA&(1<<3)) //接收数据超时{ SDIO->ICR|=1<<3; //清除标记return SD_DATA_TIMEOUT;}else if(SDIO->STA&(1<<1)) //已发送/接收的数据块CRC校验错误{SDIO->ICR|=1<<1; //清除标记return SD_DATA_CRC_FAIL; }else if(SDIO->STA&(1<<5)) //接收FIFO溢出{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;
}/*
函数功能: 得到NumberOfBytes以2为底的指数
函数参数: NumberOfBytes:字节数
返回值:以2为底的指数值
*/
u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes)
{u8 count=0;while(NumberOfBytes!=1){NumberOfBytes>>=1;count++;}return count;
}/*
函数功能: 配置SDIO DMA
函数参数: mbuf:存储器地址bufsize:传输数据量dir:方向;1,存储器-->SDIO(写数据);0,SDIO-->存储器(读数据);
*/
void SDIO_SdCard_DMAConfig(u32*mbuf,u32 bufsize,u8 dir)
{ DMA2->IFCR|=(0XF<<12); //清除DMA2通道4的各种标记DMA2_Channel4->CCR&=~(1<<0); //关闭DMA 通道4DMA2_Channel4->CCR&=~(0X7FF<<4); //清除之前的设置,DIR,CIRC,PINC,MINC,PSIZE,MSIZE,PL,MEM2MEMDMA2_Channel4->CCR|=dir<<4; //从存储器读 DMA2_Channel4->CCR|=0<<5; //普通模式DMA2_Channel4->CCR|=0<<6; //外设地址非增量模式DMA2_Channel4->CCR|=1<<7; //存储器增量模式DMA2_Channel4->CCR|=2<<8; //外设数据宽度为32位DMA2_Channel4->CCR|=2<<10; //存储器数据宽度32位DMA2_Channel4->CCR|=2<<12; //高优先级 DMA2_Channel4->CNDTR=bufsize/4; //DMA2,传输数据量 DMA2_Channel4->CPAR=(u32)&SDIO->FIFO;//DMA2 外设地址 DMA2_Channel4->CMAR=(u32)mbuf; //DMA2,存储器地址DMA2_Channel4->CCR|=1<<0; //开启DMA通道
}/*
函数功能: 读SD卡
函数参数:buf:读数据缓存区sector:扇区地址cnt:扇区个数
返回值:错误状态;0,正常;其他,错误代码;
*/
u8 SDIO_SdCardReadDiskSector(u8*buf,u32 sector,u8 cnt)
{u8 sta=SD_OK;long long lsector=sector;u8 n;lsector<<=9;if((u32)buf%4!=0){for(n=0;n<cnt;n++){sta=SDIO_SdCardReadBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//单个sector的读操作memcpy(buf,SDIO_DATA_BUFFER,512);buf+=512;} }else{if(cnt==1)sta=SDIO_SdCardReadBlock(buf,lsector,512); //单个sector的读操作else sta=SDIO_SdCardReadMultiBlocks(buf,lsector,512,cnt);//多个sector }return sta;
}/*
函数功能:写SD卡
函数参数:buf:写数据缓存区sector:扇区地址cnt:扇区个数
返回值:错误状态;0,正常;其他,错误代码;
*/
u8 SDIO_SdCardWriteDiskSector(u8*buf,u32 sector,u8 cnt)
{u8 sta=SD_OK;u8 n;long long lsector=sector;lsector<<=9;if((u32)buf%4!=0){for(n=0;n<cnt;n++){memcpy(SDIO_DATA_BUFFER,buf,512);sta=SDIO_SdCardWriteBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//单个sector的写操作buf+=512;} }else{if(cnt==1)sta=SDIO_SdCardWriteBlock(buf,lsector,512); //单个sector的写操作else sta=SDIO_SdCardWriteMultiBlocks(buf,lsector,512,cnt); //多个sector }return sta;
}（3）sdio.h
#ifndef __SDIO_SDCARD_H
#define __SDIO_SDCARD_H
#include "stm32f10x.h" //SDIO相关标志位
#define SDIO_FLAG_CCRCFAIL ((uint32_t)0x00000001)
#define SDIO_FLAG_DCRCFAIL ((uint32_t)0x00000002)
#define SDIO_FLAG_CTIMEOUT ((uint32_t)0x00000004)
#define SDIO_FLAG_DTIMEOUT ((uint32_t)0x00000008)
#define SDIO_FLAG_TXUNDERR ((uint32_t)0x00000010)
#define SDIO_FLAG_RXOVERR ((uint32_t)0x00000020)
#define SDIO_FLAG_CMDREND ((uint32_t)0x00000040)
#define SDIO_FLAG_CMDSENT ((uint32_t)0x00000080)
#define SDIO_FLAG_DATAEND ((uint32_t)0x00000100)
#define SDIO_FLAG_STBITERR ((uint32_t)0x00000200)
#define SDIO_FLAG_DBCKEND ((uint32_t)0x00000400)
#define SDIO_FLAG_CMDACT ((uint32_t)0x00000800)
#define SDIO_FLAG_TXACT ((uint32_t)0x00001000)
#define SDIO_FLAG_RXACT ((uint32_t)0x00002000)
#define SDIO_FLAG_TXFIFOHE ((uint32_t)0x00004000)
#define SDIO_FLAG_RXFIFOHF ((uint32_t)0x00008000)
#define SDIO_FLAG_TXFIFOF ((uint32_t)0x00010000)
#define SDIO_FLAG_RXFIFOF ((uint32_t)0x00020000)
#define SDIO_FLAG_TXFIFOE ((uint32_t)0x00040000)
#define SDIO_FLAG_RXFIFOE ((uint32_t)0x00080000)
#define SDIO_FLAG_TXDAVL ((uint32_t)0x00100000)
#define SDIO_FLAG_RXDAVL ((uint32_t)0x00200000)
#define SDIO_FLAG_SDIOIT ((uint32_t)0x00400000)
#define SDIO_FLAG_CEATAEND ((uint32_t)0x00800000)//用户配置区
//SDIO时钟计算公式:SDIO_CK时钟=SDIOCLK/[clkdiv+2];其中,SDIOCLK一般为72Mhz
//使用DMA模式的时候,传输速率可以到24Mhz,不过如果你的卡不是高速卡,可能也会出错
//出错就请降低时钟,使用查询模式的话,推荐SDIO_TRANSFER_CLK_DIV设置为3或者更大
#define SDIO_INIT_CLK_DIV 0xB2 //SDIO初始化频率，最大400Kh
#define SDIO_TRANSFER_CLK_DIV 0x04 //SDIO传输频率,该值太小可能会导致读写文件出错
//SDIO工作模式定义,通过SDIO_SdCardSetDeviceMode函数设置.
#define SD_POLLING_MODE 0 //查询模式,该模式下,如果读写有问题,建议增大SDIO_TRANSFER_CLK_DIV的设置.
#define SD_DMA_MODE 1 //DMA模式,该模式下,如果读写有问题,建议增大SDIO_TRANSFER_CLK_DIV的设置. //SDIO 各种错误枚举定义
typedef enum
{ //特殊错误定义 SD_CMD_CRC_FAIL = (1), /*!< Command response received (but CRC check failed) */SD_DATA_CRC_FAIL = (2), /*!< Data bock sent/received (CRC check Failed) */SD_CMD_RSP_TIMEOUT = (3), /*!< Command response timeout */SD_DATA_TIMEOUT = (4), /*!< Data time out */SD_TX_UNDERRUN = (5), /*!< Transmit FIFO under-run */SD_RX_OVERRUN = (6), /*!< Receive FIFO over-run */SD_START_BIT_ERR = (7), /*!< Start bit not detected on all data signals in widE bus mode */SD_CMD_OUT_OF_RANGE = (8), /*!< CMD's argument was out of range.*/SD_ADDR_MISALIGNED = (9), /*!< Misaligned address */SD_BLOCK_LEN_ERR = (10), /*!< Transferred block length is not allowed for the card or the number of transferred bytes does not match the block length */SD_ERASE_SEQ_ERR = (11), /*!< An error in the sequence of erase command occurs.*/SD_BAD_ERASE_PARAM = (12), /*!< An Invalid selection for erase groups */SD_WRITE_PROT_VIOLATION = (13), /*!< Attempt to program a write protect block */SD_LOCK_UNLOCK_FAILED = (14), /*!< Sequence or password error has been detected in unlock command or if there was an attempt to access a locked card */SD_COM_CRC_FAILED = (15), /*!< CRC check of the previous command failed */SD_ILLEGAL_CMD = (16), /*!< Command is not legal for the card state */SD_CARD_ECC_FAILED = (17), /*!< Card internal ECC was applied but failed to correct the data */SD_CC_ERROR = (18), /*!< Internal card controller error */SD_GENERAL_UNKNOWN_ERROR = (19), /*!< General or Unknown error */SD_STREAM_READ_UNDERRUN = (20), /*!< The card could not sustain data transfer in stream read operation. */SD_STREAM_WRITE_OVERRUN = (21), /*!< The card could not sustain data programming in stream mode */SD_CID_CSD_OVERWRITE = (22), /*!< CID/CSD overwrite error */SD_WP_ERASE_SKIP = (23), /*!< only partial address space was erased */SD_CARD_ECC_DISABLED = (24), /*!< Command has been executed without using internal ECC */SD_ERASE_RESET = (25), /*!< Erase sequence was cleared before executing because an out of erase sequence command was received */SD_AKE_SEQ_ERROR = (26), /*!< Error in sequence of authentication. */SD_INVALID_VOLTRANGE = (27),SD_ADDR_OUT_OF_RANGE = (28),SD_SWITCH_ERROR = (29),SD_SDIO_DISABLED = (30),SD_SDIO_FUNCTION_BUSY = (31),SD_SDIO_FUNCTION_FAILED = (32),SD_SDIO_UNKNOWN_FUNCTION = (33),//标准错误定义SD_INTERNAL_ERROR, SD_NOT_CONFIGURED,SD_REQUEST_PENDING, SD_REQUEST_NOT_APPLICABLE, SD_INVALID_PARAMETER, SD_UNSUPPORTED_FEATURE, SD_UNSUPPORTED_HW, SD_ERROR, SD_OK = 0
} SDIO_SD_ERROR_INFO; //SD卡CSD寄存器数据
typedef struct
{u8 CSDStruct; /*!< CSD structure */u8 SysSpecVersion; /*!< System specification version */u8 Reserved1; /*!< Reserved */u8 TAAC; /*!< Data read access-time 1 */u8 NSAC; /*!< Data read access-time 2 in CLK cycles */u8 MaxBusClkFrec; /*!< Max. bus clock frequency */u16 CardComdClasses; /*!< Card command classes */u8 RdBlockLen; /*!< Max. read data block length */u8 PartBlockRead; /*!< Partial blocks for read allowed */u8 WrBlockMisalign; /*!< Write block misalignment */u8 RdBlockMisalign; /*!< Read block misalignment */u8 DSRImpl; /*!< DSR implemented */u8 Reserved2; /*!< Reserved */u32 DeviceSize; /*!< Device Size */u8 MaxRdCurrentVDDMin; /*!< Max. read current @ VDD min */u8 MaxRdCurrentVDDMax; /*!< Max. read current @ VDD max */u8 MaxWrCurrentVDDMin; /*!< Max. write current @ VDD min */u8 MaxWrCurrentVDDMax; /*!< Max. write current @ VDD max */u8 DeviceSizeMul; /*!< Device size multiplier */u8 EraseGrSize; /*!< Erase group size */u8 EraseGrMul; /*!< Erase group size multiplier */u8 WrProtectGrSize; /*!< Write protect group size */u8 WrProtectGrEnable; /*!< Write protect group enable */u8 ManDeflECC; /*!< Manufacturer default ECC */u8 WrSpeedFact; /*!< Write speed factor */u8 MaxWrBlockLen; /*!< Max. write data block length */u8 WriteBlockPaPartial; /*!< Partial blocks for write allowed */u8 Reserved3; /*!< Reserded */u8 ContentProtectAppli; /*!< Content protection application */u8 FileFormatGrouop; /*!< File format group */u8 CopyFlag; /*!< Copy flag (OTP) */u8 PermWrProtect; /*!< Permanent write protection */u8 TempWrProtect; /*!< Temporary write protection */u8 FileFormat; /*!< File Format */u8 ECC; /*!< ECC code */u8 CSD_CRC; /*!< CSD CRC */u8 Reserved4; /*!< always 1*/
} SD_CSD; //SD卡CID寄存器数据
typedef struct
{u8 ManufacturerID; /*!< ManufacturerID */u16 OEM_AppliID; /*!< OEM/Application ID */u32 ProdName1; /*!< Product Name part1 */u8 ProdName2; /*!< Product Name part2*/u8 ProdRev; /*!< Product Revision */u32 ProdSN; /*!< Product Serial Number */u8 Reserved1; /*!< Reserved1 */u16 ManufactDate; /*!< Manufacturing Date */u8 CID_CRC; /*!< CID CRC */u8 Reserved2; /*!< always 1 */
} SD_CID; //SD卡状态
typedef enum
{SD_CARD_READY = ((uint32_t)0x00000001),SD_CARD_IDENTIFICATION = ((uint32_t)0x00000002),SD_CARD_STANDBY = ((uint32_t)0x00000003),SD_CARD_TRANSFER = ((uint32_t)0x00000004),SD_CARD_SENDING = ((uint32_t)0x00000005),SD_CARD_RECEIVING = ((uint32_t)0x00000006),SD_CARD_PROGRAMMING = ((uint32_t)0x00000007),SD_CARD_DISCONNECTED = ((uint32_t)0x00000008),SD_CARD_ERROR = ((uint32_t)0x000000FF)
}SDCardState;//SD卡信息,包括CSD,CID等数据
typedef struct
{SD_CSD SD_csd;SD_CID SD_cid;long long CardCapacity; //SD卡容量,单位:字节,最大支持2^64字节大小的卡.u32 CardBlockSize; //SD卡块大小 u16 RCA; //卡相对地址u8 CardType; //卡类型
} SD_CardInfo;
extern SD_CardInfo SDCardInfo;//SD卡信息
//SDIO 指令集
#define SD_CMD_GO_IDLE_STATE ((u8)0)
#define SD_CMD_SEND_OP_COND ((u8)1)
#define SD_CMD_ALL_SEND_CID ((u8)2)
#define SD_CMD_SET_REL_ADDR ((u8)3) /*!< SDIO_SEND_REL_ADDR for SD Card */
#define SD_CMD_SET_DSR ((u8)4)
#define SD_CMD_SDIO_SEN_OP_COND ((u8)5)
#define SD_CMD_HS_SWITCH ((u8)6)
#define SD_CMD_SEL_DESEL_CARD ((u8)7)
#define SD_CMD_HS_SEND_EXT_CSD ((u8)8)
#define SD_CMD_SEND_CSD ((u8)9)
#define SD_CMD_SEND_CID ((u8)10)
#define SD_CMD_READ_DAT_UNTIL_STOP ((u8)11) /*!< SD Card doesn't support it */
#define SD_CMD_STOP_TRANSMISSION ((u8)12)
#define SD_CMD_SEND_STATUS ((u8)13)
#define SD_CMD_HS_BUSTEST_READ ((u8)14)
#define SD_CMD_GO_INACTIVE_STATE ((u8)15)
#define SD_CMD_SET_BLOCKLEN ((u8)16)
#define SD_CMD_READ_SINGLE_BLOCK ((u8)17)
#define SD_CMD_READ_MULT_BLOCK ((u8)18)
#define SD_CMD_HS_BUSTEST_WRITE ((u8)19)
#define SD_CMD_WRITE_DAT_UNTIL_STOP ((u8)20)
#define SD_CMD_SET_BLOCK_COUNT ((u8)23)
#define SD_CMD_WRITE_SINGLE_BLOCK ((u8)24)
#define SD_CMD_WRITE_MULT_BLOCK ((u8)25)
#define SD_CMD_PROG_CID ((u8)26)
#define SD_CMD_PROG_CSD ((u8)27)
#define SD_CMD_SET_WRITE_PROT ((u8)28)
#define SD_CMD_CLR_WRITE_PROT ((u8)29)
#define SD_CMD_SEND_WRITE_PROT ((u8)30)
#define SD_CMD_SD_ERASE_GRP_START ((u8)32) /*!< To set the address of the first writeblock to be erased. (For SD card only) */
#define SD_CMD_SD_ERASE_GRP_END ((u8)33) /*!< To set the address of the last write block of thecontinuous range to be erased. (For SD card only) */
#define SD_CMD_ERASE_GRP_START ((u8)35) /*!< To set the address of the first write block to be erased.(For MMC card only spec 3.31) */#define SD_CMD_ERASE_GRP_END ((u8)36) /*!< To set the address of the last write block of thecontinuous range to be erased. (For MMC card only spec 3.31) */#define SD_CMD_ERASE ((u8)38)
#define SD_CMD_FAST_IO ((u8)39) /*!< SD Card doesn't support it */
#define SD_CMD_GO_IRQ_STATE ((u8)40) /*!< SD Card doesn't support it */
#define SD_CMD_LOCK_UNLOCK ((u8)42)
#define SD_CMD_APP_CMD ((u8)55)
#define SD_CMD_GEN_CMD ((u8)56)
#define SD_CMD_NO_CMD ((u8)64)/** * @brief Following commands are SD Card Specific commands.* SDIO_APP_CMD ：CMD55 should be sent before sending these commands. */
#define SD_CMD_APP_SD_SET_BUSWIDTH ((u8)6) /*!< For SD Card only */
#define SD_CMD_SD_APP_STAUS ((u8)13) /*!< For SD Card only */
#define SD_CMD_SD_APP_SEND_NUM_WRITE_BLOCKS ((u8)22) /*!< For SD Card only */
#define SD_CMD_SD_APP_OP_COND ((u8)41) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CLR_CARD_DETECT ((u8)42) /*!< For SD Card only */
#define SD_CMD_SD_APP_SEND_SCR ((u8)51) /*!< For SD Card only */
#define SD_CMD_SDIO_RW_DIRECT ((u8)52) /*!< For SD I/O Card only */
#define SD_CMD_SDIO_RW_EXTENDED ((u8)53) /*!< For SD I/O Card only *//** * @brief Following commands are SD Card Specific security commands.* SDIO_APP_CMD should be sent before sending these commands. */
#define SD_CMD_SD_APP_GET_MKB ((u8)43) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_MID ((u8)44) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CER_RN1 ((u8)45) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_CER_RN2 ((u8)46) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CER_RES2 ((u8)47) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_CER_RES1 ((u8)48) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_READ_MULTIPLE_BLOCK ((u8)18) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_WRITE_MULTIPLE_BLOCK ((u8)25) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_ERASE ((u8)38) /*!< For SD Card only */
#define SD_CMD_SD_APP_CHANGE_SECURE_AREA ((u8)49) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_WRITE_MKB ((u8)48) /*!< For SD Card only *///支持的SD卡定义
#define SDIO_STD_CAPACITY_SD_CARD_V1_1 ((u32)0x00000000)
#define SDIO_STD_CAPACITY_SD_CARD_V2_0 ((u32)0x00000001)
#define SDIO_HIGH_CAPACITY_SD_CARD ((u32)0x00000002)
#define SDIO_MULTIMEDIA_CARD ((u32)0x00000003)
#define SDIO_SECURE_DIGITAL_IO_CARD ((u32)0x00000004)
#define SDIO_HIGH_SPEED_MULTIMEDIA_CARD ((u32)0x00000005)
#define SDIO_SECURE_DIGITAL_IO_COMBO_CARD ((u32)0x00000006)
#define SDIO_HIGH_CAPACITY_MMC_CARD ((u32)0x00000007)//SDIO相关参数定义
#define NULL 0
#define SDIO_STATIC_FLAGS ((u32)0x000005FF)
#define SDIO_CMD0TIMEOUT ((u32)0x00010000)
#define SDIO_DATATIMEOUT ((u32)0xFFFFFFFF)
#define SDIO_FIFO_Address ((u32)0x40018080)//Mask for errors Card Status R1 (OCR Register)
#define SD_OCR_ADDR_OUT_OF_RANGE ((u32)0x80000000)
#define SD_OCR_ADDR_MISALIGNED ((u32)0x40000000)
#define SD_OCR_BLOCK_LEN_ERR ((u32)0x20000000)
#define SD_OCR_ERASE_SEQ_ERR ((u32)0x10000000)
#define SD_OCR_BAD_ERASE_PARAM ((u32)0x08000000)
#define SD_OCR_WRITE_PROT_VIOLATION ((u32)0x04000000)
#define SD_OCR_LOCK_UNLOCK_FAILED ((u32)0x01000000)
#define SD_OCR_COM_CRC_FAILED ((u32)0x00800000)
#define SD_OCR_ILLEGAL_CMD ((u32)0x00400000)
#define SD_OCR_CARD_ECC_FAILED ((u32)0x00200000)
#define SD_OCR_CC_ERROR ((u32)0x00100000)
#define SD_OCR_GENERAL_UNKNOWN_ERROR ((u32)0x00080000)
#define SD_OCR_STREAM_READ_UNDERRUN ((u32)0x00040000)
#define SD_OCR_STREAM_WRITE_OVERRUN ((u32)0x00020000)
#define SD_OCR_CID_CSD_OVERWRIETE ((u32)0x00010000)
#define SD_OCR_WP_ERASE_SKIP ((u32)0x00008000)
#define SD_OCR_CARD_ECC_DISABLED ((u32)0x00004000)
#define SD_OCR_ERASE_RESET ((u32)0x00002000)
#define SD_OCR_AKE_SEQ_ERROR ((u32)0x00000008)
#define SD_OCR_ERRORBITS ((u32)0xFDFFE008)//Masks for R6 Response
#define SD_R6_GENERAL_UNKNOWN_ERROR ((u32)0x00002000)
#define SD_R6_ILLEGAL_CMD ((u32)0x00004000)
#define SD_R6_COM_CRC_FAILED ((u32)0x00008000)#define SD_VOLTAGE_WINDOW_SD ((u32)0x80100000)
#define SD_HIGH_CAPACITY ((u32)0x40000000)
#define SD_STD_CAPACITY ((u32)0x00000000)
#define SD_CHECK_PATTERN ((u32)0x000001AA)
#define SD_VOLTAGE_WINDOW_MMC ((u32)0x80FF8000)#define SD_MAX_VOLT_TRIAL ((u32)0x0000FFFF)
#define SD_ALLZERO ((u32)0x00000000)#define SD_WIDE_BUS_SUPPORT ((u32)0x00040000)
#define SD_SINGLE_BUS_SUPPORT ((u32)0x00010000)
#define SD_CARD_LOCKED ((u32)0x02000000)
#define SD_CARD_PROGRAMMING ((u32)0x00000007)
#define SD_CARD_RECEIVING ((u32)0x00000006)
#define SD_DATATIMEOUT ((u32)0xFFFFFFFF)
#define SD_0TO7BITS ((u32)0x000000FF)
#define SD_8TO15BITS ((u32)0x0000FF00)
#define SD_16TO23BITS ((u32)0x00FF0000)
#define SD_24TO31BITS ((u32)0xFF000000)
#define SD_MAX_DATA_LENGTH ((u32)0x01FFFFFF)#define SD_HALFFIFO ((u32)0x00000008)
#define SD_HALFFIFOBYTES ((u32)0x00000020)//Command Class Supported
#define SD_CCCC_LOCK_UNLOCK ((u32)0x00000080)
#define SD_CCCC_WRITE_PROT ((u32)0x00000040)
#define SD_CCCC_ERASE ((u32)0x00000020)//CMD8指令
#define SDIO_SEND_IF_COND ((u32)0x00000008)
//相关函数定义
SDIO_SD_ERROR_INFO SDIO_SdCardInit(void);
void SDIO_ClockSet(u8 clkdiv);
void SDIO_SendCmd(u8 cmdindex,u8 waitrsp,u32 arg);
void SDIO_SendDataConfig(u32 datatimeout,u32 datalen,u8 blksize,u8 dir);
SDIO_SD_ERROR_INFO SDIO_SdPowerON(void);
SDIO_SD_ERROR_INFO SD_PowerOFF(void);
SDIO_SD_ERROR_INFO SDIO_SdCardInitializeCards(void);
SDIO_SD_ERROR_INFO SDIO_SdCardGetInfo(SD_CardInfo *cardinfo);
SDIO_SD_ERROR_INFO SDIO_SdCardEnableWideBusOperation(u32 wmode);
SDIO_SD_ERROR_INFO SDIO_SdCardSetDeviceMode(u32 mode);
SDIO_SD_ERROR_INFO SDIO_SdCardSelectAddr(u32 addr);
SDIO_SD_ERROR_INFO SDIO_SdCardSendStatus(uint32_t *pcardstatus);
SDCardState SDIO_SdCardGetState(void);
SDIO_SD_ERROR_INFO SDIO_SdCardReadBlock(u8 *buf,long long addr,u16 blksize);
SDIO_SD_ERROR_INFO SDIO_SdCardReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks);
SDIO_SD_ERROR_INFO SDIO_SdCardWriteBlock(u8 *buf,long long addr, u16 blksize);
SDIO_SD_ERROR_INFO SDIO_SdCardWriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks);
SDIO_SD_ERROR_INFO SDIO_SdCardProcessIRQSrc(void);
SDIO_SD_ERROR_INFO SDIO_CmdErrorCheck(void);
SDIO_SD_ERROR_INFO SDIO_CmdResp7Error(void);
SDIO_SD_ERROR_INFO SDIO_CmdResp1Error(u8 cmd);
SDIO_SD_ERROR_INFO SDIO_CmdResp3Error(void);
SDIO_SD_ERROR_INFO SDIO_CmdResp2Error(void);
SDIO_SD_ERROR_INFO SDIO_CmdResp6Error(u8 cmd,u16*prca);
SDIO_SD_ERROR_INFO SDIO_SdCardEnWideBus(u8 enx);
SDIO_SD_ERROR_INFO SDIO_SdCardProgrammingState(u8 *pstatus);
SDIO_SD_ERROR_INFO SDIO_SdCardFindSCR(u16 rca,u32 *pscr);
u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes);
void SDIO_SdCard_DMAConfig(u32*mbuf,u32 bufsize,u8 dir);
u8 SDIO_SdCardReadDiskSector(u8*buf,u32 sector,u8 cnt); //读SD卡,fatfs/usb调用
u8 SDIO_SdCardWriteDiskSector(u8*buf,u32 sector,u8 cnt); //写SD卡,fatfs/usb调用
#endif
五、总结
综上所述，雷龙公司推出的CS SD NAND贴片式TF卡以其紧凑的设计、卓越的性能和广泛的应用潜力，为现代数字存储解决方案提供了一种全新的选择。通过深入的技术分析可以看出，该产品不仅在尺寸上远小于传统的TF卡，而且在稳定性、读写速度以及环境耐受性方面表现优异。其采用的pSLC技术确保了数据的高度可靠性和较长的使用寿命，而标准SDIO接口和SPI通信模式的支持，则进一步增强了其兼容性和灵活性。实际测试表明，这款CS SD NAND贴片式TF卡无论是在作为大容量存储介质使用，还是应用于如MP3播放器等多媒体设备中，都能稳定高效地工作。它所提供的不仅仅是硬件上的升级，更是对传统存储方式的一种革新。对于寻求高性能、高可靠性存储方案的工程师和技术爱好者而言，雷龙CS SD NAND无疑是一个值得考虑的选择。希望本文的技术探讨能够为大家提供有价值的参考，并激发更多关于未来存储技术发展的思考。
雷龙的官网： http://www.longsto.com/product/35.html
