0、准备工作
在移植FatFs文件系统前，需要准备好一块开发板，和一张SD卡，且需要已经实现开发板正常的读写SD卡或其它硬件设备。
本文笔记教程中使用的硬件设备是STM32F407VET6开发板（板载SD插槽），配备8G和32G SD卡用于移植测试；文件系统版本为FatFs R0.15。
1、FatFs加入工程
(1)、下载FatFs文件系统
进入FatFs官网，根据需要下载FatFs，在写本笔记教程时，最新版本为FatFs R0.15，因此下载使用了最新版本的R0.15进行移植适配。
FatFs - Generic FAT Filesystem Module (elm-chan.org)
http://elm-chan.org/fsw/ff/00index_e.html
(2)、FatFs文件结构
在解压下载了FatFs R0.15库文件后，会有如下三个文件夹和文件documents、source、LICENSE.txt；其中documents可以当作是一个官方的参考手册、说明书来看，里面有对文件系统的各个API的使用进行介绍说明，参考Demo等；source文件夹则是整个文件系统的核心所在，包含了文件系统的全部源文件和头文件。
进入source文件夹后，可以看到如下几个文件，在这些文件中diskio.h、ff.c、ff.h、ffsystem.c和ffunicode.c是不需要更改的；diskio.c这个文件与磁盘底层IO操作接近，其包含了底层存储介质的操作函数，这些函数需要用户自己实现，主要是添加底层驱动函数；ffconf.h这个头文件包含了对FatFs功能配置的宏定义，通过修改这些宏定义就可以裁剪FatFs的功能。ffconf.h和diskio.c是移植FatFs的重点，是后面根据实际情况需要进行修改的文件。
(3)、FatFs库加入MDK工程
①、拷贝源码
在MDK工程目录下新建一个FatFs文件夹，将下载的FatFs R0.15库文件中的source目录下的相关代码文件全部拷贝到该目录下，具体操作结果如下图所示。
②、工程包含FatFs
在MDK KEIL v5中打开工程，新建一个FatFs工程组，并将FatFs库路径下的全部源文件加到工程组中，具体操作步骤如下图所示。
在MDK的头文件路径设置中，将FatFs路径加入到MDK工程中，具体操作如下图所示。
完成上述操作，对整个工程代码进行编译后，出现了如下13个报错信息，通过定位报错信息可以得知，主要是由于文件系统diskio.c中对MMC、RAM、USB设备的初始化、读、写、状态获取API未定义和ff.c中对文件时间戳未定义。
因此，接下来对文件系统的移植操作主要是针对报错信息进行处理，将diskio.c文件中的硬件设备初始化、读、写、状态获取API及ff.c文件时间戳进行适配、定义实现。
3、移植FatFs文件系统
(1)、文件系统时间戳实现
从上面的编译报错信息中，可以看到在与ff.c文件中，get_fattime( )函数没有被定义。get_fattime函数用于获取当前时间戳，在ff.c文件中被调用。
打开ff.h文件可以看到，get_fattime( )接口是需要用户自己定义适配的。FatFs在文件创建、被修改时会记录时间， 调用这个函数，因此这个接口的重要性毋庸置疑，需要去实现。
打开ff.c文件，在该文件的最后，加入类似下面的代码，对FatFs的文件系统时间戳进行实现。
具体文件系统时间戳返回值格式为：
bit31:25 ——从1980至今是多少年，范围是 (0..127) ；
bit24:21 ——月份，范围为 (1..12) ；
bit20:16 ——该月份中的第几日，范围为(1..31) ；
bit15:11——时，范围为 (0..23)；
bit10:5 ——分，范围为 (0..59)；
bit4:0 ——秒/ 2，范围为 (0..29)。
如果还没有掌握RTC时钟的配置，可以暂时拷贝下面的代码直接粘贴到程序中，但这样每次对文件系统操作，都是一个固定的时间值。
__weak DWORD get_fattime(void)
{/* 返回当前时间戳 */return ((DWORD)(2024 - 1980) << 25) /* Year 2024 */| ((DWORD)5 << 21) /* Month 5 */| ((DWORD)30 << 16) /* Mday 30 */| ((DWORD)17 << 11) /* Hour 0 */| ((DWORD)20 << 5) /* Min 0 */| ((DWORD)0 >> 1); /* Sec 0 */
}如果已经掌握了RTC时钟的配置，可以直接将上面所示接口的固定值，进行替换为RTC时钟实际值，这样每次调用这个接口，都会将设备的实时时间传递到文件系统中，请根据实际情况进行修改，前提是已经开启了RTC时钟。
__weak DWORD get_fattime(void)
{RTC_Update(); //更新RTC时钟return ((DWORD)(xRTC.Year - 1980) << 25) /* 年 */| ((DWORD)xRTC.Month << 21) /* 月 */| ((DWORD)xRTC.Day << 16) /* 日 */| ((DWORD)xRTC.Hour << 11) /* 时 */| ((DWORD)xRTC.Minute << 5) /* 分 */| ((DWORD)xRTC.Second >> 1); /* 秒 */
}(2)、diskio.c修改适配
打开diskio.c文件，在包含头文件代码下面，可以看到有三个物理设备的类型编号的宏定义，根据实际的使用情况，这边手动修改了这三个宏定义，如下所示：
#define DEV_SD_CARD 0 //SD Card
#define DEV_SPI_FLASH 1 //SPI FLASH
#define DEV_USB 2 //USB①、disk_status
这个函数的功能是获取设备的状态，只有一个参数pdrv，表示物理编号。因暂时只使用了SD卡，因此除了SD卡返回正常状态，其它类型设备全部返回的是非正常状态。
DSTATUS disk_status (BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{DSTATUS stat;//int result;switch (pdrv) {case DEV_SD_CARD ://result = MMC_disk_status();stat = RES_OK;// translate the reslut code herereturn stat;case DEV_SPI_FLASH ://result = RAM_disk_status();// translate the reslut code herestat = STA_NOINIT;return stat;case DEV_USB ://result = USB_disk_status();// translate the reslut code herestat = STA_NOINIT;return stat;}return STA_NOINIT;
}②、disk_initialize
disk_initialize函数是设备初始化接口，也是有一个参数pdrv，用来指定设备物理编号。因只有一个SD设备，除了SD状态中调用了SD_Init()对SD卡进行了初始化设置，其它类型全部返回了未初始化。提醒：请根据实际情况进行修改SD卡初始化的接口，SD_Init这个接口主要是对芯片引脚GPIO初始化配置以及SDIO的通信参数配置等操作。
DSTATUS disk_initialize (BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{DSTATUS stat;//int result;switch (pdrv) {case DEV_SD_CARD ://result = MMC_disk_initialize();if(SD_Init() == SD_OK) //SD卡初始化{stat = RES_OK;}else{stat = STA_NOINIT;}// translate the reslut code herereturn stat;case DEV_SPI_FLASH ://result = RAM_disk_initialize();// translate the reslut code herestat = STA_NOINIT;return stat;case DEV_USB ://result = USB_disk_initialize();// translate the reslut code herestat = STA_NOINIT;return stat;}return STA_NOINIT;
}③、disk_read
disk_read函数有四个形参。pdrv为设备物理编号。buff是一个BYTE类型指针变量，buff指向用来存放读取到数据的存储区首地址。 sector是一个DWORD类型变量，指定要读取数据的扇区首地址。count是一个UINT类型变量，指定扇区数量。
BYTE类型实际是unsigned char类型，DWORD类型实际是unsigned long类型， UINT类型实际是 unsigned int类型，类型定义在ff.h文件中。
SD_ReadDisk( )为SD设备驱动程序中提供的，不同的驱动代码，需要参考实际设备驱动中的代码程序进行相应的修改。
DRESULT disk_read (BYTE pdrv, /* Physical drive nmuber to identify the drive */BYTE *buff, /* Data buffer to store read data */LBA_t sector, /* Start sector in LBA */UINT count /* Number of sectors to read */
)
{DRESULT res;int result;switch (pdrv) {case DEV_SD_CARD :// translate the arguments here//result = MMC_disk_read(buff, sector, count);// translate the reslut code hereresult = SD_ReadDisk(buff, sector, count);if(result != 0){res = RES_PARERR;}else{res = RES_OK;}return res;case DEV_SPI_FLASH :// translate the arguments here//result = RAM_disk_read(buff, sector, count);// translate the reslut code hereres = RES_PARERR;return res;case DEV_USB :// translate the arguments here//result = USB_disk_read(buff, sector, count);// translate the reslut code hereres = RES_PARERR;return res;}return RES_PARERR;
}④、disk_write
disk_write函数有四个形参，pdrv为设备物理编号。buff指向待写入扇区数据的首地址。sector，指定要读取数据的扇区首地址。 count指定扇区数量。
DRESULT disk_write (BYTE pdrv, /* Physical drive nmuber to identify the drive */const BYTE *buff, /* Data to be written */LBA_t sector, /* Start sector in LBA */UINT count /* Number of sectors to write */
)
{DRESULT res;int result;switch (pdrv) {case DEV_SD_CARD :// translate the arguments here//result = MMC_disk_write(buff, sector, count);// translate the reslut code hereresult = SD_WriteDisk((u8 *)buff, sector, count);if(result != 0){res = RES_PARERR;}else{res = RES_OK;}return res;case DEV_SPI_FLASH :// translate the arguments here//result = RAM_disk_write(buff, sector, count);// translate the reslut code hereres = RES_PARERR;return res;case DEV_USB :// translate the arguments here//result = USB_disk_write(buff, sector, count);// translate the reslut code hereres = RES_PARERR;return res;}return RES_PARERR;
}⑤、disk_ioctl
disk_ioctl函数有三个形参，pdrv为设备物理编号，cmd为控制指令，包括发出同步信号、获取扇区数目、获取扇区大小、 获取擦除块数量等等指令，buff为指令对应的数据指针。
对于SD卡，为支持格式化功能，需要用到获取扇区数量(GET_SECTOR_COUNT)指令和获取块尺寸(GET_BLOCK_SIZE)。另外，SD卡扇区大小为512字节， 串行Flash芯片一般设置扇区大小为4096字节，所以需要用到获取扇区大小(GET_SECTOR_SIZE)指令。
DRESULT disk_ioctl (BYTE pdrv, /* Physical drive nmuber (0..) */BYTE cmd, /* Control code */void *buff /* Buffer to send/receive control data */
)
{DRESULT res;//int result;switch (pdrv){case DEV_SD_CARD :// Process of the command for the MMC/SD cardswitch (cmd) {case GET_SECTOR_COUNT: /* 扇区数量 */*(DWORD * )buff = SDCardInfo.CardCapacity/SDCardInfo.CardBlockSize; break;case GET_SECTOR_SIZE : /* 扇区大小 */*(WORD * )buff = SDCardInfo.CardBlockSize;break;case GET_BLOCK_SIZE : /* 同时擦除扇区个数(单位为扇区) */*(DWORD * )buff = 1;break; }res = RES_OK;return res;case DEV_SPI_FLASH :// Process of the command for the RAM driveres = RES_PARERR;return res;case DEV_USB :// Process of the command the USB driveres = RES_PARERR;return res;}return RES_PARERR;
}(3)、FatFs系统配置
ffconf.h文件是FatFs功能配置文件，通过修改该文件的宏定义开关，可以实现对FatFs的阉割、裁剪等配置，以符合开发者的实际需求。本文的移植测试中，修改了如下几个宏定义。
#define FF_USE_MKFS 1
#define FF_CODE_PAGE 936
#define FF_USE_LFN 2
#define FF_VOLUMES 3
#define FF_MIN_SS 512
#define FF_MAX_SS 40961) FF_USE_MKFS： 格式化功能选择，为使用FatFs格式化功能，需要把它设置为1。
2) FF_CODE_PAGE： 语言功能选择，并要求把相关语言文件添加到工程宏。为支持简体中文文件名需要使用“936”
3) FF_USE_LFN： 长文件名支持，默认不支持长文件名，这里配置为2，支持长文件名，并指定使用栈空间为缓冲区。
4) FF_VOLUMES： 指定物理设备数量，这里设置为3，包括预留SD卡、SPI Flash芯片和USB设备。
5) FF_MIN_SS 、FF_MAX_SS： 指定扇区大小的最小值和最大值。SD卡扇区大小一般都为512字节，SPI Flash芯片扇区大小一般设置为4096字节，所以需要把_MAX_SS改为4096。
4、文件系统功能验证
（1）、验证程序
static FATFS fs; /* FatFs文件系统对象 */
static FIL fnew; /* 文件对象 */
static FRESULT res_sd; /* 文件操作结果 */
static UINT fnum; /* 文件成功读写数量 */
static BYTE ReadBuffer[256]= {0}; /* 读缓冲区 */
static BYTE WriteBuffer[] = /* 写缓冲区*/"Welcome to STM32 FatFs, This is a test file!";void sd_card_fatfs_test(void)
{printf("%s\t%d\r\n", __FUNCTION__ , __LINE__);res_sd = f_mount(&fs,"0:", 1);printf("%s\t%d\r\n", __FUNCTION__ , __LINE__);/*----------------------- 格式化测试 -----------------------*//* 如果没有文件系统就格式化创建创建文件系统 */if (res_sd == FR_NO_FILESYSTEM) {printf(">> SD Card don't have FatFs Type File System!\r\nCreate SD Card FAT32 File System...\r\nPlease Wait some time!\r\n");/* 格式化 *///res_sd=f_mkfs("0:", 0, NULL, 0);MKFS_PARM opt = {0};opt.fmt = FM_FAT32; // 选择FAT32格式opt.n_fat = 2; // 设定FAT副本数量，通常为2opt.align = 1; // 数据区域对齐，默认为1，表示按扇区对齐// opt.n_root 不需要设置，因为我们使用的是FAT32，它没有固定大小的根目录opt.au_size = 512; // 每簇大小，以字节为单位，这里是假设每簇为1个扇区，即512字节//res_sd = f_mkfs("0:", &opt, NULL, 0);#define FORMAT_WORK_BUF_SZ 4096 // 根据需要调整BYTE formatWorkBuf[FORMAT_WORK_BUF_SZ];res_sd = f_mkfs("0:", &opt, formatWorkBuf, FORMAT_WORK_BUF_SZ);//res_sd = f_mkfs("0:", &opt, NULL, 4096); //根据实际需求调整if (res_sd == FR_OK) {printf(">> SD Card Create File System success! \r\n");/* 格式化后，先取消挂载 */res_sd = f_mount(NULL,"0:",0);/* 重新挂载 */res_sd = f_mount(&fs,"0:",1);} else {LED_RED_ON;printf(">> Create file system failed! %d \r\n", res_sd);while (1);}} else if (res_sd!=FR_OK) {printf(">> SD Card Mount File System failed! %d \r\n",res_sd);while (1);} else {printf(">> Mount file system success! \r\n");}/*----------------------- 文件系统测试：写测试 -----------------------*/printf("\r\n---------------FatFs Write Test---------------\r\n"); /* 打开文件，如果文件不存在则创建它 */ res_sd = f_open(&fnew, "0:FatFs_test.txt",FA_CREATE_ALWAYS | FA_WRITE );if ( res_sd == FR_OK ){printf(">> Open Or Create file success, write data...\r\n");/* 将指定存储区内容写入到文件内 */res_sd=f_write(&fnew,WriteBuffer,sizeof(WriteBuffer),&fnum);if(res_sd==FR_OK){printf(">> Write data Success：%d\r\n",fnum);printf(">> Write data:\r\n%s\r\n",WriteBuffer);}else{printf("Write data failed! (%d)\r\n",res_sd);} /* 不再读写，关闭文件 */f_close(&fnew);}else{ LED_RED_ON;printf("Open Or Create file failed!\r\n");}/*----------------------- 文件系统测试：读测试 -----------------------*/printf("--------------- Read file test ---------------\r\n");res_sd = f_open(&fnew, "0:FatFs_test.txt", FA_OPEN_EXISTING | FA_READ); if(res_sd == FR_OK){LED_BLUE_ON;printf(">> Open success...\r\n");res_sd = f_read(&fnew, ReadBuffer, sizeof(ReadBuffer), &fnum); if(res_sd==FR_OK){printf(">>Read file data success%d\r\n",fnum);printf(">>Read data:\r\n%s \r\n", ReadBuffer); }else{printf("Read file failed! (%d)\r\n",res_sd);} }else{LED_RED_ON;printf("Open file failed!\r\n");}/* 不再读写，关闭文件 */f_close(&fnew); /* 不再使用文件系统，取消挂载文件系统 */f_mount(NULL,"0:",1);while(1){}
}（2）、验证结果
32G的SD卡格式化过程中，可能需要较多的时间。
将SD卡插入到PC机中，可以正常识别SD卡及打开查看修改里面的文件，说明文件系统移植成功。
（3）踩坑小提示
FatFs R0.15版本的API与前几代版本的变动较大，使用起来甚至完全不一样，如果参考了以前几个版本的代码，移植运行会出错的话，建议查看程序源码，挨个调试验证。
如f_mkfs函数接口，按照以往的版本，如下使用是可以正常格式化SD卡的文件系统的：
f_mkfs("0:", 0, NULL, 0);//参考老版本的常见的使用例程，错误的使用方式但R0.15版本中会直接返回FR_NOT_ENOUGH_CORE空间不足的提示，这并非全部是设备的堆空间或栈空间不足，使用上面这一行代码，在启动文件中将堆空间和栈空间变大后，还是出现该问题，经过查看源码发现，只是调用f_mkfs接口时，传参错误，修正后，就可以正常格式化文件系统。
如下为查阅源码后编写的R0.15版本的正确使用方式：
//正确的使用方式MKFS_PARM opt = {0};
opt.fmt = FM_FAT32; // 选择FAT32格式
opt.n_fat = 2; // 设定FAT副本数量，通常为2
opt.align = 1; // 数据区域对齐，默认为1，表示按扇区对齐
// opt.n_root 不需要设置，因为我们使用的是FAT32，它没有固定大小的根目录
opt.au_size = 512; // 每簇大小，以字节为单位，这里是假设每簇为1个扇区，即512字节#define FORMAT_WORK_BUF_SZ 4096 // 根据需要调整
BYTE formatWorkBuf[FORMAT_WORK_BUF_SZ];
res_sd = f_mkfs("0:", &opt, formatWorkBuf, FORMAT_WORK_BUF_SZ);5、SDIO驱动程序参考
(1)、sdio_sdcard.h
#ifndef __SDIO_SDCARD_H
#define __SDIO_SDCARD_H
#include "stm32f4xx.h"
// //SDIO 驱动代码
//STM32F4工程模板-库函数版本
//********************************************************************************
//修改说明
//V1.1 20140522
//1,加入超时判断,解决轮询接收死机的问题.
//V1.2 20140715
//1,新增SD_GetState和SD_SendStatus函数.
// //SDIO相关标志位,拷贝自:stm32f4xx_sdio.h
#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固定为48Mhz
//使用DMA模式的时候,传输速率可以到48Mhz(bypass on时),不过如果你的卡不是高速
//卡,可能也会出错,出错就请降低时钟
#define SDIO_INIT_CLK_DIV 0x76 //SDIO初始化频率，最大400Kh
#define SDIO_TRANSFER_CLK_DIV 0x00 //SDIO传输频率,该值太小可能会导致读写文件出错 //SDIO工作模式定义,通过SD_SetDeviceMode函数设置.
#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
} SD_Error; //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)//相关函数定义
SD_Error SD_Init(void);
void SDIO_Clock_Set(u8 clkdiv);SD_Error SD_PowerON(void);
SD_Error SD_PowerOFF(void);
SD_Error SD_InitializeCards(void);
SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo);
SD_Error SD_EnableWideBusOperation(u32 wmode);
SD_Error SD_SetDeviceMode(u32 mode);
SD_Error SD_SelectDeselect(u32 addr);
SD_Error SD_SendStatus(uint32_t *pcardstatus);
SDCardState SD_GetState(void);
SD_Error SD_ReadBlock(u8 *buf,long long addr,u16 blksize);
SD_Error SD_ReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks);
SD_Error SD_WriteBlock(u8 *buf,long long addr, u16 blksize);
SD_Error SD_WriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks);
SD_Error SD_ProcessIRQSrc(void);void SD_DMA_Config(u32*mbuf,u32 bufsize,u32 dir);
//void SD_DMA_Config(u32*mbuf,u32 bufsize,u8 dir); u8 SD_ReadDisk(u8*buf,u32 sector,u8 cnt); //读SD卡,fatfs/usb调用
u8 SD_WriteDisk(u8*buf,u32 sector,u8 cnt); //写SD卡,fatfs/usb调用#endif (2)、sdio_sdcard.h
#include "sdio_sdcard.h"
#include "string.h"
#include "sys.h"
#include "usart.h"
// //SDIO 驱动代码
//STM32F4工程模板-库函数版本
//********************************************************************************
//修改说明
//V1.1 20140522
//1,加入超时判断,解决轮询接收死机的问题.
//V1.2 20140715
//1,新增SD_GetState和SD_SendStatus函数.
// /*用于sdio初始化的结构体*/
SDIO_InitTypeDef SDIO_InitStructure;
SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
SDIO_DataInitTypeDef SDIO_DataInitStructure; SD_Error CmdError(void);
SD_Error CmdResp7Error(void);
SD_Error CmdResp1Error(u8 cmd);
SD_Error CmdResp3Error(void);
SD_Error CmdResp2Error(void);
SD_Error CmdResp6Error(u8 cmd,u16*prca);
SD_Error SDEnWideBus(u8 enx);
SD_Error IsCardProgramming(u8 *pstatus);
SD_Error FindSCR(u16 rca,u32 *pscr);
u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes); 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; //工作模式,注意,工作模式必须通过SD_SetDeviceMode,后才算数.这里只是定义一个默认的模式(SD_DMA_MODE)
static u8 StopCondition=0; //是否发送停止传输标志位,DMA多块读写的时候用到
volatile SD_Error TransferError=SD_OK; //数据传输错误标志,DMA读写时使用
volatile u8 TransferEnd=0; //传输结束标志,DMA读写时使用
SD_CardInfo SDCardInfo; //SD卡信息//SD_ReadDisk/SD_WriteDisk函数专用buf,当这两个函数的数据缓存区地址不是4字节对齐的时候,
//需要用到该数组,确保数据缓存区地址是4字节对齐的.
__align(4) u8 SDIO_DATA_BUFFER[512]; void SDIO_Register_Deinit(void)
{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;
}//初始化SD卡
//返回值:错误代码;(0,无错误)
SD_Error SD_Init(void)
{GPIO_InitTypeDef GPIO_InitStructure;NVIC_InitTypeDef NVIC_InitStructure;SD_Error errorstatus = SD_OK; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOD|RCC_AHB1Periph_DMA2, ENABLE);//使能GPIOC,GPIOD DMA2时钟RCC_APB2PeriphClockCmd(RCC_APB2Periph_SDIO, ENABLE);//SDIO时钟使能RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, ENABLE);//SDIO复位GPIO_InitStructure.GPIO_Pin =GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12; //PC8,9,10,11,12复用功能输出 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//100MGPIO_InitStructure.GPIO_OType = GPIO_OType_PP;GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉GPIO_Init(GPIOC, &GPIO_InitStructure);// PC8,9,10,11,12复用功能输出GPIO_InitStructure.GPIO_Pin =GPIO_Pin_2;GPIO_Init(GPIOD, &GPIO_InitStructure);//PD2复用功能输出//引脚复用映射设置GPIO_PinAFConfig(GPIOC,GPIO_PinSource8,GPIO_AF_SDIO); //PC8,AF12GPIO_PinAFConfig(GPIOC,GPIO_PinSource9,GPIO_AF_SDIO);GPIO_PinAFConfig(GPIOC,GPIO_PinSource10,GPIO_AF_SDIO);GPIO_PinAFConfig(GPIOC,GPIO_PinSource11,GPIO_AF_SDIO);GPIO_PinAFConfig(GPIOC,GPIO_PinSource12,GPIO_AF_SDIO); GPIO_PinAFConfig(GPIOD,GPIO_PinSource2,GPIO_AF_SDIO); RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, DISABLE);//SDIO结束复位//SDIO外设寄存器设置为默认值 SDIO_Register_Deinit();NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;//抢占优先级3NVIC_InitStructure.NVIC_IRQChannelSubPriority =0; //子优先级3NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器、errorstatus = SD_PowerON(); //SD卡上电if(errorstatus==SD_OK){errorstatus=SD_InitializeCards(); //初始化SD卡}if(errorstatus==SD_OK){errorstatus=SD_GetCardInfo(&SDCardInfo); //获取卡信息}if(errorstatus==SD_OK){errorstatus=SD_SelectDeselect((u32)(SDCardInfo.RCA<<16));//选中SD卡 }if(errorstatus==SD_OK){errorstatus=SD_EnableWideBusOperation(SDIO_BusWide_4b); //4位宽度,如果是MMC卡,则不能用4位模式 }if((errorstatus==SD_OK)||(SDIO_MULTIMEDIA_CARD==CardType)){SDIO_Clock_Set(SDIO_TRANSFER_CLK_DIV); //设置时钟频率,SDIO时钟计算公式:SDIO_CK时钟=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定为48Mhz errorstatus=SD_SetDeviceMode(SD_DMA_MODE); //设置为DMA模式//errorstatus=SD_SetDeviceMode(SD_POLLING_MODE);//设置为查询模式}return errorstatus;
}
//SDIO时钟初始化设置
//clkdiv:时钟分频系数
//CK时钟=SDIOCLK/[clkdiv+2];(SDIOCLK时钟固定为48Mhz)
void SDIO_Clock_Set(u8 clkdiv)
{u32 tmpreg = SDIO->CLKCR; tmpreg &= 0XFFFFFF00; tmpreg |= clkdiv; SDIO->CLKCR = tmpreg;
} //卡上电
//查询所有SDIO接口上的卡设备,并查询其电压和配置时钟
//返回值:错误代码;(0,无错误)
SD_Error SD_PowerON(void)
{u8 i=0;SD_Error errorstatus=SD_OK;u32 response=0,count=0,validvoltage=0;u32 SDType=SD_STD_CAPACITY;/*初始化时的时钟不能大于400KHz*/ SDIO_InitStructure.SDIO_ClockDiv = SDIO_INIT_CLK_DIV; /* HCLK = 72MHz, SDIOCLK = 72MHz, SDIO_CK = HCLK/(178 + 2) = 400 KHz */SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable; //不使用bypass模式，直接用HCLK进行分频得到SDIO_CKSDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable; // 空闲时不关闭时钟电源SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b; //1位数据线SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;//硬件流SDIO_Init(&SDIO_InitStructure);SDIO_SetPowerState(SDIO_PowerState_ON); //上电状态,开启卡时钟 SDIO->CLKCR|=1<<8; //SDIOCK使能 for(i=0;i<74;i++){SDIO_CmdInitStructure.SDIO_Argument = 0x0;//发送CMD0进入IDLE STAGE模式命令.SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_GO_IDLE_STATE; //cmd0SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_No; //无响应SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable; //则CPSM在开始发送命令之前等待数据传输结束。 SDIO_SendCommand(&SDIO_CmdInitStructure); //写命令进命令寄存器errorstatus=CmdError();if(errorstatus==SD_OK){break;}}if(errorstatus)return errorstatus;//返回错误状态SDIO_CmdInitStructure.SDIO_Argument = SD_CHECK_PATTERN; //发送CMD8,短响应,检查SD卡接口特性SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_IF_COND; //cmd8SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r7SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No; //关闭等待中断SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);errorstatus=CmdResp7Error(); //等待R7响应if(errorstatus==SD_OK) //R7响应正常{CardType=SDIO_STD_CAPACITY_SD_CARD_V2_0; //SD 2.0卡SDType=SD_HIGH_CAPACITY; //高容量卡}SDIO_CmdInitStructure.SDIO_Argument = 0x00;//发送CMD55,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); //发送CMD55,短响应 errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应 if(errorstatus==SD_OK)//SD2.0/SD 1.1,否则为MMC卡{ //SD卡,发送ACMD41 SD_APP_OP_COND,参数为:0x80100000 while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL)){ SDIO_CmdInitStructure.SDIO_Argument = 0x00;//发送CMD55,短响应SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD; //CMD55SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); //发送CMD55,短响应 errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应 if(errorstatus!=SD_OK){return errorstatus; //响应错误}//acmd41，命令参数由支持的电压范围及HCS位组成，HCS位置一来区分卡是SDSc还是sdhcSDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_SD | SDType; //发送ACMD41,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_OP_COND;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r3SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);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;}}else//MMC卡{//MMC卡,发送CMD1 SDIO_SEND_OP_COND,参数为:0x80FF8000 while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL)){ SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_MMC;//发送CMD1,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_OP_COND;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r3SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);errorstatus=CmdResp3Error(); //等待R3响应 if(errorstatus!=SD_OK){return errorstatus; //响应错误 }response=SDIO->RESP1;; //得到响应validvoltage=(((response>>31)==1)?1:0);count++;}if(count>=SD_MAX_VOLT_TRIAL){errorstatus=SD_INVALID_VOLTRANGE;return errorstatus;} CardType=SDIO_MULTIMEDIA_CARD; } return(errorstatus);
}
//SD卡 Power OFF
//返回值:错误代码;(0,无错误)
SD_Error SD_PowerOFF(void)
{SDIO_SetPowerState(SDIO_PowerState_OFF);//SDIO电源关闭,时钟停止 return SD_OK;
}
//初始化所有的卡,并让卡进入就绪状态
//返回值:错误代码
SD_Error SD_InitializeCards(void)
{SD_Error errorstatus=SD_OK;u16 rca = 0x01;if (SDIO_GetPowerState() == SDIO_PowerState_OFF) //检查电源状态,确保为上电状态{errorstatus = SD_REQUEST_NOT_APPLICABLE;return(errorstatus);}if(SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD{SDIO_CmdInitStructure.SDIO_Argument = 0x0;//发送CMD2,取得CID,长响应SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_ALL_SEND_CID;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);//发送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_CmdInitStructure.SDIO_Argument = 0x00;//发送CMD3,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR; //cmd3SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); //发送CMD3,短响应 errorstatus=CmdResp6Error(SD_CMD_SET_REL_ADDR,&rca);//等待R6响应 if(errorstatus!=SD_OK){return errorstatus; //响应错误 }} if (SDIO_MULTIMEDIA_CARD==CardType){SDIO_CmdInitStructure.SDIO_Argument = (u32)(rca<<16);//发送CMD3,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR; //cmd3SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); //发送CMD3,短响应 errorstatus=CmdResp2Error(); //等待R2响应 if(errorstatus!=SD_OK){return errorstatus; //响应错误 }}if (SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD{RCA = rca;SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)(rca << 16);//发送CMD9+卡RCA,取得CSD,长响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_CSD;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);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;//卡初始化成功
}
//得到卡信息
//cardinfo:卡信息存储区
//返回值:错误状态
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; //数据读时间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总线宽度(MMC卡不支持4bit模式)
//wmode:位宽模式.0,1位数据宽度;1,4位数据宽度;2,8位数据宽度
//返回值:SD卡错误状态//设置SDIO总线宽度(MMC卡不支持4bit模式)
// @arg SDIO_BusWide_8b: 8-bit data transfer (Only for MMC)
// @arg SDIO_BusWide_4b: 4-bit data transfer
// @arg SDIO_BusWide_1b: 1-bit data transfer (默认)
//返回值:SD卡错误状态SD_Error SD_EnableWideBusOperation(u32 WideMode)
{SD_Error errorstatus=SD_OK;if (SDIO_MULTIMEDIA_CARD == CardType){errorstatus = SD_UNSUPPORTED_FEATURE;return(errorstatus);}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 (SDIO_BusWide_8b == WideMode) //2.0 sd不支持8bits{errorstatus = SD_UNSUPPORTED_FEATURE;return(errorstatus);}else {errorstatus=SDEnWideBus(WideMode);if(SD_OK==errorstatus){SDIO->CLKCR&=~(3<<11); //清除之前的位宽设置 SDIO->CLKCR|=WideMode;//1位/4位总线宽度 SDIO->CLKCR|=0<<14; //不开启硬件流控制}} }return errorstatus;
}
//设置SD卡工作模式
//Mode:
//返回值:错误状态
SD_Error SD_SetDeviceMode(u32 Mode)
{SD_Error 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地址
SD_Error SD_SelectDeselect(u32 addr)
{SDIO_CmdInitStructure.SDIO_Argument = addr;//发送CMD7,选择卡,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEL_DESEL_CARD;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);//发送CMD7,选择卡,短响应return CmdResp1Error(SD_CMD_SEL_DESEL_CARD);
}
//SD卡读取一个块
//buf:读数据缓存区(必须4字节对齐!!)
//addr:读取地址
//blksize:块大小
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_DataInitStructure.SDIO_DataBlockSize= SDIO_DataBlockSize_1b ;//清除DPSM状态机配置SDIO_DataInitStructure.SDIO_DataLength= 0 ;SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;SDIO_DataConfig(&SDIO_DataInitStructure);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_CmdInitStructure.SDIO_Argument = blksize;SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);//发送CMD16+设置数据长度为blksize,短响应errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1响应 if(errorstatus!=SD_OK){return errorstatus; //响应错误 }}else {return SD_INVALID_PARAMETER; }SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4 ;//清除DPSM状态机配置SDIO_DataInitStructure.SDIO_DataLength= blksize ;SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO;SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;SDIO_DataConfig(&SDIO_DataInitStructure);SDIO_CmdInitStructure.SDIO_Argument = addr;SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_SINGLE_BLOCK;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);//发送CMD17+从addr地址出读取数据,短响应 errorstatus=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_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET) //接收区半满,表示至少存了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_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //数据超时错误{ SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清错误标志return SD_DATA_TIMEOUT;}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块CRC错误{SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志return SD_DATA_CRC_FAIL; }else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢错误{SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清错误标志return SD_RX_OVERRUN; }else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位错误{SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志return SD_START_BIT_ERR; } while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET) //FIFO里面,还存在可用数据{*tempbuff=SDIO->FIFO; //循环读取数据tempbuff++;}INTX_ENABLE();//开启总中断SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记}else if(DeviceMode==SD_DMA_MODE){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使能 SD_DMA_Config((u32*)buf,blksize,DMA_DIR_PeripheralToMemory); while(((DMA2->LISR&(1<<27))==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;
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_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM状态机配置SDIO_DataInitStructure.SDIO_DataLength= 0 ;SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;SDIO_DataConfig(&SDIO_DataInitStructure);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_CmdInitStructure.SDIO_Argument = blksize;//发送CMD16+设置数据长度为blksize,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);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_DataInitStructure.SDIO_DataBlockSize= power<<4; ;//nblks*blksize,512块大小,卡到控制器SDIO_DataInitStructure.SDIO_DataLength= nblks*blksize ;SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO;SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;SDIO_DataConfig(&SDIO_DataInitStructure);SDIO_CmdInitStructure.SDIO_Argument = addr;//发送CMD18+从addr地址出读取数据,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_MULT_BLOCK;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=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_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET) //接收区半满,表示至少存了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_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //数据超时错误{ SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清错误标志return SD_DATA_TIMEOUT;}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块CRC错误{SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志return SD_DATA_CRC_FAIL; }else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢错误{SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清错误标志return SD_RX_OVERRUN; }else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位错误{SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志return SD_START_BIT_ERR; } while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET) //FIFO里面,还存在可用数据{*tempbuff=SDIO->FIFO; //循环读取数据tempbuff++;}if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET) //接收结束{if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType)){ SDIO_CmdInitStructure.SDIO_Argument = 0;//发送CMD12+结束传输SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1响应 if(errorstatus!=SD_OK)return errorstatus; }}INTX_ENABLE();//开启总中断SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记}else if(DeviceMode==SD_DMA_MODE){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使能 SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_PeripheralToMemory); while(((DMA2->LISR&(1<<27))==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:块大小
//返回值:错误状态
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_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM状态机配置SDIO_DataInitStructure.SDIO_DataLength= 0 ;SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;SDIO_DataConfig(&SDIO_DataInitStructure);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_CmdInitStructure.SDIO_Argument = blksize;//发送CMD16+设置数据长度为blksize,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1响应 if(errorstatus!=SD_OK)return errorstatus; //响应错误 }else return SD_INVALID_PARAMETER; SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;//发送CMD13,查询卡的状态,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=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_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;//发送CMD13,查询卡的状态,短响应SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS); //等待R1响应 if(errorstatus!=SD_OK)return errorstatus; cardstatus=SDIO->RESP1; }if(timeout==0)return SD_ERROR;SDIO_CmdInitStructure.SDIO_Argument = addr;//发送CMD24,写单块指令,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_WRITE_SINGLE_BLOCK);//等待R1响应 if(errorstatus!=SD_OK)return errorstatus; StopCondition=0; //单块写,不需要发送停止传输指令 SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ; //blksize, 控制器到卡 SDIO_DataInitStructure.SDIO_DataLength= blksize ;SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;SDIO_DataConfig(&SDIO_DataInitStructure);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_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET) //发送区半空,表示至少存了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_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //数据超时错误{ SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清错误标志return SD_DATA_TIMEOUT;}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块CRC错误{SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志return SD_DATA_CRC_FAIL; }else if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET) //接收fifo下溢错误{SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清错误标志return SD_TX_UNDERRUN; }else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位错误{SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志return SD_START_BIT_ERR; } INTX_ENABLE();//开启总中断SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 }else if(DeviceMode==SD_DMA_MODE){TransferError=SD_OK;StopCondition=0; //单块写,不需要发送停止传输指令 TransferEnd=0; //传输结束标置位，在中断服务置1SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置产生数据接收完成中断SD_DMA_Config((u32*)buf,blksize,DMA_DIR_MemoryToPeripheral); //SDIO DMA配置SDIO->DCTRL|=1<<3; //SDIO DMA使能. while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待传输完成 if(timeout==0){SD_Init(); //重新初始化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_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记errorstatus=IsCardProgramming(&cardstate);while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING))){errorstatus=IsCardProgramming(&cardstate);} return errorstatus;
}
//SD卡写多个块
//buf:数据缓存区
//addr:写地址
//blksize:块大小
//nblks:要写入的块数
//返回值:错误状态
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_DataInitStructure.SDIO_DataBlockSize= 0; ; //清除DPSM状态机配置 SDIO_DataInitStructure.SDIO_DataLength= 0 ;SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;SDIO_DataConfig(&SDIO_DataInitStructure);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_CmdInitStructure.SDIO_Argument = blksize; //发送CMD16+设置数据长度为blksize,短响应SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); 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_CmdInitStructure.SDIO_Argument = (u32)RCA<<16; //发送ACMD55,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应 if(errorstatus!=SD_OK)return errorstatus; SDIO_CmdInitStructure.SDIO_Argument =nblks; //发送CMD23,设置块数量,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCK_COUNT;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);errorstatus=CmdResp1Error(SD_CMD_SET_BLOCK_COUNT);//等待R1响应 if(errorstatus!=SD_OK)return errorstatus; } SDIO_CmdInitStructure.SDIO_Argument =addr; //发送CMD25,多块写指令,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_MULT_BLOCK;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_WRITE_MULT_BLOCK); //等待R1响应 if(errorstatus!=SD_OK)return errorstatus;SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ; //blksize, 控制器到卡 SDIO_DataInitStructure.SDIO_DataLength= nblks*blksize ;SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;SDIO_DataConfig(&SDIO_DataInitStructure);if(DeviceMode==SD_POLLING_MODE){timeout=SDIO_DATATIMEOUT;INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)while(!(SDIO->STA&((1<<4)|(1<<1)|(1<<8)|(1<<3)|(1<<9))))//下溢/CRC/数据结束/超时/起始位错误{if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET) //发送区半空,表示至少存了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_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //数据超时错误{ SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清错误标志return SD_DATA_TIMEOUT;}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块CRC错误{SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志return SD_DATA_CRC_FAIL; }else if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET) //接收fifo下溢错误{SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清错误标志return SD_TX_UNDERRUN; }else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位错误{SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志return SD_START_BIT_ERR; } if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET) //发送结束{ if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType)){ SDIO_CmdInitStructure.SDIO_Argument =0;//发送CMD12+结束传输 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1响应 if(errorstatus!=SD_OK)return errorstatus; }}INTX_ENABLE();//开启总中断SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记}else if(DeviceMode==SD_DMA_MODE){TransferError=SD_OK;StopCondition=1; //多块写,需要发送停止传输指令 TransferEnd=0; //传输结束标置位，在中断服务置1SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置产生数据接收完成中断SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_MemoryToPeripheral); //SDIO DMA配置SDIO->DCTRL|=1<<3; //SDIO DMA使能. timeout=SDIO_DATATIMEOUT;while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待传输完成 if(timeout==0) //超时{ SD_Init(); //重新初始化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_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记errorstatus=IsCardProgramming(&cardstate);while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING))){errorstatus=IsCardProgramming(&cardstate);} return errorstatus;
}
//SDIO中断服务函数
void SDIO_IRQHandler(void)
{ SD_ProcessIRQSrc();//处理所有SDIO相关中断
}
//SDIO中断处理函数
//处理SDIO传输过程中的各种中断事务
//返回值:错误代码
SD_Error SD_ProcessIRQSrc(void)
{if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)//接收完成中断{ if (StopCondition==1){ SDIO_CmdInitStructure.SDIO_Argument =0;//发送CMD12+结束传输 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); TransferError=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_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)//数据CRC错误{SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志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_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)//数据超时错误{SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清中断标志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_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)//FIFO上溢错误{SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清中断标志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_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET)//FIFO下溢错误{SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清中断标志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_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)//起始位错误{SDIO_ClearFlag(SDIO_FLAG_STBITERR); //清中断标志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卡错误码
SD_Error CmdError(void)
{SD_Error errorstatus = SD_OK;u32 timeout=SDIO_CMD0TIMEOUT; while(timeout--){if(SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT) != RESET)break; //命令已发送(无需响应) } if(timeout==0)return SD_CMD_RSP_TIMEOUT; SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记return errorstatus;
}
//检查R7响应的错误状态
//返回值:sd卡错误码
SD_Error CmdResp7Error(void)
{SD_Error 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_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令响应超时标志return errorstatus;} if(status&1<<6) //成功接收到响应{ errorstatus=SD_OK;SDIO_ClearFlag(SDIO_FLAG_CMDREND); //清除响应标志}return errorstatus;
}
//检查R1响应的错误状态
//cmd:当前命令
//返回值:sd卡错误码
SD_Error CmdResp1Error(u8 cmd)
{ u32 status; while(1){status=SDIO->STA;if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功)} if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //响应超时{ SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令响应超时标志return SD_CMD_RSP_TIMEOUT;} if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC错误{ SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除标志return SD_CMD_CRC_FAIL;} if(SDIO->RESPCMD!=cmd)return SD_ILLEGAL_CMD;//命令不匹配 SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记return (SD_Error)(SDIO->RESP1&SD_OCR_ERRORBITS);//返回卡响应
}
//检查R3响应的错误状态
//返回值:错误状态
SD_Error CmdResp3Error(void)
{u32 status; while(1){status=SDIO->STA;if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功) }if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //响应超时{ SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令响应超时标志return SD_CMD_RSP_TIMEOUT;} SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记return SD_OK;
}
//检查R2响应的错误状态
//返回值:错误状态
SD_Error CmdResp2Error(void)
{SD_Error 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_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令响应超时标志return errorstatus;} if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC错误{ errorstatus=SD_CMD_CRC_FAIL;SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除响应标志}SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记return errorstatus;
}
//检查R6响应的错误状态
//cmd:之前发送的命令
//prca:卡返回的RCA地址
//返回值:错误状态
SD_Error CmdResp6Error(u8 cmd,u16*prca)
{SD_Error errorstatus=SD_OK;u32 status; u32 rspr1;while(1){status=SDIO->STA;if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功) }if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //响应超时{ SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令响应超时标志return SD_CMD_RSP_TIMEOUT;} if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC错误{ SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除响应标志return SD_CMD_CRC_FAIL;}if(SDIO->RESPCMD!=cmd) //判断是否响应cmd命令{return SD_ILLEGAL_CMD; } SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记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,使能;
//返回值:错误状态
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;if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//SD卡处于LOCKED状态 errorstatus=FindSCR(RCA,scr); //得到SCR寄存器数据if(errorstatus!=SD_OK)return errorstatus;if((scr[1]&SD_WIDE_BUS_SUPPORT)!=SD_ALLZERO) //支持宽总线{SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;//发送CMD55+RCA,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);errorstatus=CmdResp1Error(SD_CMD_APP_CMD);if(errorstatus!=SD_OK)return errorstatus; SDIO_CmdInitStructure.SDIO_Argument = arg;//发送ACMD6,短响应,参数:10,4位;00,1位. SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);errorstatus=CmdResp1Error(SD_CMD_APP_SD_SET_BUSWIDTH);return errorstatus;}else return SD_REQUEST_NOT_APPLICABLE; //不支持宽总线设置
}
//检查卡是否正在执行写操作
//pstatus:当前状态.
//返回值:错误代码
SD_Error IsCardProgramming(u8 *pstatus)
{vu32 respR1 = 0, status = 0; SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16; //卡相对地址参数SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;//发送CMD13 SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); status=SDIO->STA;while(!(status&((1<<0)|(1<<6)|(1<<2))))status=SDIO->STA;//等待操作完成if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC检测失败{ SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除错误标记return SD_CMD_CRC_FAIL;}if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //命令超时 {SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除错误标记return SD_CMD_RSP_TIMEOUT;}if(SDIO->RESPCMD!=SD_CMD_SEND_STATUS)return SD_ILLEGAL_CMD;SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记respR1=SDIO->RESP1;*pstatus=(u8)((respR1>>9)&0x0000000F);return SD_OK;
}
//读取当前卡状态
//pcardstatus:卡状态
//返回值:错误代码
SD_Error SD_SendStatus(uint32_t *pcardstatus)
{SD_Error errorstatus = SD_OK;if(pcardstatus==NULL){errorstatus=SD_INVALID_PARAMETER;return errorstatus;}SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;//发送CMD13,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS); //查询响应状态 if(errorstatus!=SD_OK){return errorstatus;}*pcardstatus=SDIO->RESP1;//读取响应值return errorstatus;
}
//返回SD卡的状态
//返回值:SD卡状态
SDCardState SD_GetState(void)
{u32 resp1=0;if(SD_SendStatus(&resp1)!=SD_OK){return SD_CARD_ERROR;}else{return (SDCardState)((resp1>>9) & 0x0F);}
}
//查找SD卡的SCR寄存器值
//rca:卡相对地址
//pscr:数据缓存区(存储SCR内容)
//返回值:错误状态
SD_Error FindSCR(u16 rca,u32 *pscr)
{ u32 index = 0; SD_Error errorstatus = SD_OK;u32 tempscr[2]={0,0}; SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)8; //发送CMD16,短响应,设置Block Size为8字节 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN; // cmd16SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r1SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN);if(errorstatus!=SD_OK)return errorstatus; SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16; SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;//发送CMD55,短响应 SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);errorstatus=CmdResp1Error(SD_CMD_APP_CMD);if(errorstatus!=SD_OK)return errorstatus;SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;SDIO_DataInitStructure.SDIO_DataLength = 8; //8个字节长度,block为8字节,SD卡到SDIO.SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_8b ; //块大小8byte SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;SDIO_DataConfig(&SDIO_DataInitStructure); SDIO_CmdInitStructure.SDIO_Argument = 0x0;SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_SEND_SCR; //发送ACMD51,短响应,参数为0 SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r1SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;SDIO_SendCommand(&SDIO_CmdInitStructure);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))){ if(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)//接收FIFO数据可用{*(tempscr+index)=SDIO->FIFO; //读取FIFO内容index++;if(index>=2)break;}}if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //数据超时错误{ SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清错误标志return SD_DATA_TIMEOUT;}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块CRC错误{SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志return SD_DATA_CRC_FAIL; }else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢错误{SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清错误标志return SD_RX_OVERRUN; }else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位错误{SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志return SD_START_BIT_ERR; } SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记//把数据顺序按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:方向;DMA_DIR_MemoryToPeripheral 存储器-->SDIO(写数据);DMA_DIR_PeripheralToMemory SDIO-->存储器(读数据);
void SD_DMA_Config(u32*mbuf,u32 bufsize,u32 dir)
{ DMA_InitTypeDef DMA_InitStructure;while (DMA_GetCmdStatus(DMA2_Stream3) != DISABLE){}//等待DMA可配置 DMA_DeInit(DMA2_Stream3);//清空之前该stream3上的所有中断标志DMA_InitStructure.DMA_Channel = DMA_Channel_4; //通道选择DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&SDIO->FIFO;//DMA外设地址DMA_InitStructure.DMA_Memory0BaseAddr = (u32)mbuf;//DMA 存储器0地址DMA_InitStructure.DMA_DIR = dir;//存储器到外设模式DMA_InitStructure.DMA_BufferSize = 0;//数据传输量 DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//外设非增量模式DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;//存储器增量模式DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;//外设数据长度:32位DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;//存储器数据长度:32位DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;// 使用普通模式 DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;//最高优先级DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable; //FIFO使能 DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;//全FIFODMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_INC4;//外设突发4次传输DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_INC4;//存储器突发4次传输DMA_Init(DMA2_Stream3, &DMA_InitStructure);//初始化DMA StreamDMA_FlowControllerConfig(DMA2_Stream3,DMA_FlowCtrl_Peripheral);//外设流控制 DMA_Cmd(DMA2_Stream3 ,ENABLE);//开启DMA传输 } //读SD卡
//buf:读数据缓存区
//sector:扇区地址
//cnt:扇区个数
//返回值:错误状态;0,正常;其他,错误代码;
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;n<cnt;n++){sta=SD_ReadBlock(SDIO_DATA_BUFFER,lsector+512*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;
}
//写SD卡
//buf:写数据缓存区
//sector:扇区地址
//cnt:扇区个数
//返回值:错误状态;0,正常;其他,错误代码;
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;n<cnt;n++){memcpy(SDIO_DATA_BUFFER,buf,512);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;
}
![[AVL数四种旋转详细图解]](https://img-blog.csdnimg.cn/direct/9ddd10d3b3284bc7831103b597e73014.png)
![[职场] 质量管理求职简历工作经历范文6篇 #知识分享#经验分享](https://img-blog.csdnimg.cn/img_convert/025a75fbc4b9c1d2811c9fd0afd88461.jpeg)
