【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(七)-准备移植FatFs
【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡
【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍
【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(三)-SD卡的操作流程
【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(四)-介绍库函数,获取一些SD卡的信息
【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(五)-文件管理初步介绍
【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(六)-FatFs使用的思路介绍
【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(七)-准备移植FatFs
【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(八)-认识内存管理
【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(终)-配合内存管理来遍历SD卡
FatFs官方网站:http://elm-chan.org/fsw/ff/00index_e.html
注意一点,在使用文件管理之前,你应该要保证和你连接的设备,所有你用到的功能都是调通了的
例如
1.你的设备是SD卡,或是Flash之类的
2.功能实现的部分,例如一些《初始化》、《读功能》,或是《写功能》
这些东西都实现了,才来添加FatFs文件管理
因为在《diskio.c》里,需要执行你已经封装好的函数,也就是上两行说的《初始化》《读功能》《写功能》之类的
如果还没调通,就来移植,只怕问题会更多
那如果一切都准备好了,下面就来移植FatFs吧
在我的范例教程里,用的是《ff11a》
我知道目前(2020.12.14)最新版本是《ff14a》,并且和《ff11a》有些出入
但只要懂《ff11a》的思路,往后的版本也能驾轻就熟
《2021.02.02修改:我改用10b版本了,正点和野火也是用这个版本,我是用11a后发现有问题,才改的,我不知道在哪看的,以为他们都是用11a版本》
《但是添加过程都差不多,下面的文字和图片有出入,我就懒得改了。。。抱歉》
在官网的历史版本里面可以下载【Download:Previous Releases】,找到R0.11a下载 找到R0.10b下载
此压缩档里面有两个文件
等等在开Keil,先去自己的项目路径下,新建一个FatFs文件夹(文件分类后,比较方便阅读)
把压缩档里面的src复制到刚建的FatFs文件夹
doc就不用复制了
此时,打开Keil,在project下,新建一个FATFS文件夹,并且添加2个源文件《diskio.c》《ff.c》
再把头文件路径也填上,编译后,让头文件显示出来,有错误没关系,因为我们之后就会修改
首先来看《ffconf.h》,通过这些宏定义,可以设定你不需要什么功能,毕竟这样可以节省空间
另外还可以设置编码(_CODE_PAGE),中文编码的文件略大一些,如果要用中文编码,还需要去option文件夹,找到cc936源文件,添加到自己项目,这里我先设置为1
还有是否要支持长文件名,是否支持格式化...等等
- /*---------------------------------------------------------------------------/
- / FatFs - FAT file system module configuration file R0.11a (C)ChaN, 2015
- /---------------------------------------------------------------------------*/
- #define _FFCONF 64180 /* Revision ID */
- /*---------------------------------------------------------------------------/
- / Function Configurations
- /---------------------------------------------------------------------------*/
- #define _FS_READONLY 0 // 是否只读
- /* This option switches read-only configuration. (0:Read/Write or 1:Read-only)
- / Read-only configuration removes writing API functions, f_write(), f_sync(),
- / f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()
- / and optional writing functions as well. */
- #define _FS_MINIMIZE 0 // 是否使用裁剪文件
- /* This option defines minimization level to remove some basic API functions.
- /
- / 0: All basic functions are enabled.
- / 1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_chmod(), f_utime(),
- / f_truncate() and f_rename() function are removed.
- / 2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
- / 3: f_lseek() function is removed in addition to 2. */
- #define _USE_STRFUNC 0 // 是否允许字符串操作
- /* This option switches string functions, f_gets(), f_putc(), f_puts() and
- / f_printf().
- /
- / 0: Disable string functions.
- / 1: Enable without LF-CRLF conversion.
- / 2: Enable with LF-CRLF conversion. */
- #define _USE_FIND 0 // 切换过滤目录读取功能和相关功能
- /* This option switches filtered directory read feature and related functions,
- / f_findfirst() and f_findnext(). (0:Disable or 1:Enable) */
- #define _USE_MKFS 0 // 是否开启格式化功能
- /* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
- #define _USE_FASTSEEK 0 // 是否开启快速索引
- /* This option switches fast seek feature. (0:Disable or 1:Enable) */
- #define _USE_LABEL 0 // 是否开启切换卷标功能
- /* This option switches volume label functions, f_getlabel() and f_setlabel().
- / (0:Disable or 1:Enable) */
- #define _USE_FORWARD 0 // 是否允许f_forward函数
- /* This option switches f_forward() function. (0:Disable or 1:Enable)
- / To enable it, also _FS_TINY need to be set to 1. */
- /*---------------------------------------------------------------------------/
- / Locale and Namespace Configurations
- /---------------------------------------------------------------------------*/
- // 编码【932为日文】【936为简体中文】【949为韩文】【950为繁体中文】
- #define _CODE_PAGE 1
- /* This option specifies the OEM code page to be used on the target system.
- / Incorrect setting of the code page can cause a file open failure.
- /
- / 1 - ASCII (No extended character. Non-LFN cfg. only)
- / 437 - U.S.
- / 720 - Arabic
- / 737 - Greek
- / 771 - KBL
- / 775 - Baltic
- / 850 - Latin 1
- / 852 - Latin 2
- / 855 - Cyrillic
- / 857 - Turkish
- / 860 - Portuguese
- / 861 - Icelandic
- / 862 - Hebrew
- / 863 - Canadian French
- / 864 - Arabic
- / 865 - Nordic
- / 866 - Russian
- / 869 - Greek 2
- / 932 - Japanese (DBCS)
- / 936 - Simplified Chinese (DBCS)
- / 949 - Korean (DBCS)
- / 950 - Traditional Chinese (DBCS)
- */
- #define _USE_LFN 0 // 是否支持长文件名
- #define _MAX_LFN 255
- /* The _USE_LFN option switches the LFN feature.
- /
- / 0: Disable LFN feature. _MAX_LFN has no effect.
- / 1: Enable LFN with static working buffer on the BSS. Always NOT thread-safe.
- / 2: Enable LFN with dynamic working buffer on the STACK.
- / 3: Enable LFN with dynamic working buffer on the HEAP.
- /
- / When enable the LFN feature, Unicode handling functions (option/unicode.c) must
- / be added to the project. The LFN working buffer occupies (_MAX_LFN + 1) * 2 bytes.
- / When use stack for the working buffer, take care on stack overflow. When use heap
- / memory for the working buffer, memory management functions, ff_memalloc() and
- / ff_memfree(), must be added to the project. */
- #define _LFN_UNICODE 0 // 切换字符编码
- /* This option switches character encoding on the API. (0:ANSI/OEM or 1:Unicode)
- / To use Unicode string for the path name, enable LFN feature and set _LFN_UNICODE
- / to 1. This option also affects behavior of string I/O functions. */
- #define _STRF_ENCODE 3 // 编码相关
- /* When _LFN_UNICODE is 1, this option selects the character encoding on the file to
- / be read/written via string I/O functions, f_gets(), f_putc(), f_puts and f_printf().
- /
- / 0: ANSI/OEM
- / 1: UTF-16LE
- / 2: UTF-16BE
- / 3: UTF-8
- /
- / When _LFN_UNICODE is 0, this option has no effect. */
- #define _FS_RPATH 0 // 是否允许相对路径
- /* This option configures relative path feature.
- /
- / 0: Disable relative path feature and remove related functions.
- / 1: Enable relative path feature. f_chdir() and f_chdrive() are available.
- / 2: f_getcwd() function is available in addition to 1.
- /
- / Note that directory items read via f_readdir() are affected by this option. */
- /*---------------------------------------------------------------------------/
- / Drive/Volume Configurations
- /---------------------------------------------------------------------------*/
- #define _VOLUMES 1 // 磁盘逻辑卷数
- /* Number of volumes (logical drives) to be used. */
- #define _STR_VOLUME_ID 0
- #define _VOLUME_STRS "RAM","NAND","CF","SD1","SD2","USB1","USB2","USB3"
- /* _STR_VOLUME_ID option switches string volume ID feature.
- / When _STR_VOLUME_ID is set to 1, also pre-defined strings can be used as drive
- / number in the path name. _VOLUME_STRS defines the drive ID strings for each
- / logical drives. Number of items must be equal to _VOLUMES. Valid characters for
- / the drive ID strings are: A-Z and 0-9. */
- #define _MULTI_PARTITION 0 // 分区选项,默认为0,即一个分区,若想要多分区可自行设置
- /* This option switches multi-partition feature. By default (0), each logical drive
- / number is bound to the same physical drive number and only an FAT volume found on
- / the physical drive will be mounted. When multi-partition feature is enabled (1),
- / each logical drive number is bound to arbitrary physical drive and partition
- / listed in the VolToPart[]. Also f_fdisk() funciton will be available. */
- #define _MIN_SS 512 // 扇区缓冲最小值
- #define _MAX_SS 512 // 扇区缓冲最大值
- /* These options configure the range of sector size to be supported. (512, 1024,
- / 2048 or 4096) Always set both 512 for most systems, all type of memory cards and
- / harddisk. But a larger value may be required for on-board flash memory and some
- / type of optical media. When _MAX_SS is larger than _MIN_SS, FatFs is configured
- / to variable sector size and GET_SECTOR_SIZE command must be implemented to the
- / disk_ioctl() function. */
- #define _USE_TRIM 0
- /* This option switches ATA-TRIM feature. (0:Disable or 1:Enable)
- / To enable Trim feature, also CTRL_TRIM command should be implemented to the
- / disk_ioctl() function. */
- #define _FS_NOFSINFO 0
- /* If you need to know correct free space on the FAT32 volume, set bit 0 of this
- / option, and f_getfree() function at first time after volume mount will force
- / a full FAT scan. Bit 1 controls the use of last allocated cluster number.
- /
- / bit0=0: Use free cluster count in the FSINFO if available.
- / bit0=1: Do not trust free cluster count in the FSINFO.
- / bit1=0: Use last allocated cluster number in the FSINFO if available.
- / bit1=1: Do not trust last allocated cluster number in the FSINFO.
- */
- /*---------------------------------------------------------------------------/
- / System Configurations
- /---------------------------------------------------------------------------*/
- #define _FS_TINY 0 // 文件系统为标准的还是微型的
- /* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
- / At the tiny configuration, size of the file object (FIL) is reduced _MAX_SS
- / bytes. Instead of private sector buffer eliminated from the file object,
- / common sector buffer in the file system object (FATFS) is used for the file
- / data transfer. */
- #define _FS_NORTC 0
- #define _NORTC_MON 1
- #define _NORTC_MDAY 1
- #define _NORTC_YEAR 2015
- /* The _FS_NORTC option switches timestamp feature. If the system does not have
- / an RTC function or valid timestamp is not needed, set _FS_NORTC to 1 to disable
- / the timestamp feature. All objects modified by FatFs will have a fixed timestamp
- / defined by _NORTC_MON, _NORTC_MDAY and _NORTC_YEAR.
- / When timestamp feature is enabled (_FS_NORTC == 0), get_fattime() function need
- / to be added to the project to read current time form RTC. _NORTC_MON,
- / _NORTC_MDAY and _NORTC_YEAR have no effect.
- / These options have no effect at read-only configuration (_FS_READONLY == 1). */
- #define _FS_LOCK 0
- /* The _FS_LOCK option switches file lock feature to control duplicated file open
- / and illegal operation to open objects. This option must be 0 when _FS_READONLY
- / is 1.
- /
- / 0: Disable file lock feature. To avoid volume corruption, application program
- / should avoid illegal open, remove and rename to the open objects.
- / >0: Enable file lock feature. The value defines how many files/sub-directories
- / can be opened simultaneously under file lock control. Note that the file
- / lock feature is independent of re-entrancy. */
- #define _FS_REENTRANT 0
- #define _FS_TIMEOUT 1000
- #define _SYNC_t HANDLE
- /* The _FS_REENTRANT option switches the re-entrancy (thread safe) of the FatFs
- / module itself. Note that regardless of this option, file access to different
- / volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
- / and f_fdisk() function, are always not re-entrant. Only file/directory access
- / to the same volume is under control of this feature.
- /
- / 0: Disable re-entrancy. _FS_TIMEOUT and _SYNC_t have no effect.
- / 1: Enable re-entrancy. Also user provided synchronization handlers,
- / ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()
- / function, must be added to the project. Samples are available in
- / option/syscall.c.
- /
- / The _FS_TIMEOUT defines timeout period in unit of time tick.
- / The _SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,
- / SemaphoreHandle_t and etc.. A header file for O/S definitions needs to be
- / included somewhere in the scope of ff.c. */
- #define _WORD_ACCESS 0 // 数据递进格式
- /* The _WORD_ACCESS option is an only platform dependent option. It defines
- / which access method is used to the word data on the FAT volume.
- /
- / 0: Byte-by-byte access. Always compatible with all platforms.
- / 1: Word access. Do not choose this unless under both the following conditions.
- /
- / * Address misaligned memory access is always allowed to ALL instructions.
- / * Byte order on the memory is little-endian.
- /
- / If it is the case, _WORD_ACCESS can also be set to 1 to reduce code size.
- / Following table shows allowable settings of some type of processors.
- /
- / ARM7TDMI 0 *2 ColdFire 0 *1 V850E 0 *2
- / Cortex-M3 0 *3 Z80 0/1 V850ES 0/1
- / Cortex-M0 0 *2 x86 0/1 TLCS-870 0/1
- / AVR 0/1 RX600(LE) 0/1 TLCS-900 0/1
- / AVR32 0 *1 RL78 0 *2 R32C 0 *2
- / PIC18 0/1 SH-2 0 *1 M16C 0/1
- / PIC24 0 *2 H8S 0 *1 MSP430 0 *2
- / PIC32 0 *1 H8/300H 0 *1 8051 0/1
- /
- / *1:Big-endian.
- / *2:Unaligned memory access is not supported.
- / *3:Some compilers generate LDM/STM for mem_cpy function.
- */
对应上面部分宏定义,我整理了一个表格,可以一目了然的认识宏定义是做什么事情
《2021.01.16修改:不用自己的表格了,官方有做出一个表格》
接着来看《diskio.c》编译的错误基本都在这了
首先是把几个头文件注释了,这几个头文件是其他范例有的,我们这里要用自己的头文件
下面的三个宏定义《ATA》《MMC》《USB》,可以改成自己想要的名称,例如我的板子上有SD、Flash,干脆就定0和1
- #include "sdio_sdcard.h"
- #define SD 0
- #define FLASH 1
然后把函数《disk_status》《disk_initialize》《disk_read》《disk_write》里面执行的代码注释了,或者删除也可以,未来要添加自己的代码(这里先不添加,先找出所有错误)
对了,由于我上面改了宏定义,这里switch-case也要做一些修改(图片原来的ATA、MMC、USB,要修改成SD和FLASH)
- DSTATUS disk_status (
- BYTE pdrv /* Physical drive nmuber to identify the drive */
- )
- {
- DSTATUS stat;
- int result;
- switch (pdrv) {
- case SD :
- return stat;
- case FLASH :
- return stat;
- }
- return STA_NOINIT;
- }
再次编译,发现错误
解决这个错误有两个方法,但是这两个方法,要用哪个,需要取决于你应用的设计
get_fattime是获取当前时间
如果不需要,在《ffconf.h》里面,找到宏定义《#define _FS_NORTC》,改为1,即可关闭
如果需要这个功能,需要在《diskio.c》里面,实现get_fattime函数,代码如下
- DWORD get_fattime(void) {
- /* 返回当前时间戳 */
- return ((DWORD)(2015 - 1980) << 25) /* Year 2015 */
- | ((DWORD)1 << 21) /* Month 1 */
- | ((DWORD)1 << 16) /* Mday 1 */
- | ((DWORD)0 << 11) /* Hour 0 */
- | ((DWORD)0 << 5) /* Min 0 */
- | ((DWORD)0 >> 1); /* Sec 0 */
- }
我不需要这个功能,我直接设定宏定义为1,然后编译,这时错误就没有了
下面先完成 《diskio.c》代码的添加
源文件《sdio_sdcard.c》和头文件《sdio_sdcard.h》,我会放在文章的最后
里面包含SD_Init函数
另外,这函数又是在做什么事情的?我两篇博客分别提到思路以及实现
我的第三篇博客【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(三)-SD卡的操作流程,里面有提到图形化流程,也是SD_Init需要做的事情
我的第四篇博客【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(四)-介绍库函数,获取一些SD卡的信息,这篇才是真正讲到如何使用库函数,完成SD_Init初始化
但有一点需要注意!我里面提到的9个步骤(第10步骤不是初始化该做的事),我是拆分开来,一部分一部分代码来讲解的,而本篇文章末了的代码,是整合过的,就这一点不同而已
- SD_Error SD_Init(void)
- {
- ...
- ...
- }
FatFs文件管理的宗旨,你不要自己去调用SD的初始化
由文件管理自己去调用,但你还是要给出命令的,例如接口《f_mount》
SD_Init会返回一个状态SD_Error,这个状态会通知文件管理系统,然后《f_mount》也有一个返回值,最终我们就会得知初始化的结果
- DSTATUS disk_initialize (
- BYTE pdrv /* Physical drive nmuber to identify the drive */
- )
- {
- DSTATUS stat;
- int result = 0;
- switch (pdrv) {
- case SD :
- result = SD_Init(); // SD卡初始化
- break;
- case W25Qxx :
- break;
- }
- if(result)return STA_NOINIT;
- else return 0; //初始化成功
- }
完成了设备接口的配置,我们回到自己的应用层,尝试执行《f_mount》,参数2:path,这里给的逻辑编号,是你在《diskio.c》里面的宏定义,SD我定义为0,这里就给 "0:"
最终函数会返回一个状态《FRESULT》,如果返回是0,代表正常
《2021.01.14新增的内容:f_mount就是挂起,挂起后你才可以使用一些功能,例如读取f_open,或是打开文件夹f_opendir,写入数据f_write。。。等等》
- #include "stm32f4xx.h"
- #include "delay.h"
- // 外设
- #include "sdio_sdcard.h"
- #include "usart.h"
- // FatFS
- #include "diskio.h"
- #include "ff.h"
- FATFS *fs[_VOLUMES]; // FatFs文件系统对象
- FRESULT res_sd; // 文件操作结果
- int main(void)
- {
- delay_init(180);
- /* 串口初始化 */
- uart1_init(9600);
- /* 文件管理系统初始化 */
- res_sd = f_mount(fs[0],"0:",1);
- USART_SendData(USART1, res_sd); // 打印处理结果
- while(1);
- }
执行效果如下,记得要用HEX显示
- /* File function return code (FRESULT) */
- typedef enum {
- FR_OK = 0, /* (0) Succeeded */
- FR_DISK_ERR, /* (1) A hard error occurred in the low level disk I/O layer */
- FR_INT_ERR, /* (2) Assertion failed */
- FR_NOT_READY, /* (3) The physical drive cannot work */
- FR_NO_FILE, /* (4) Could not find the file */
- FR_NO_PATH, /* (5) Could not find the path */
- FR_INVALID_NAME, /* (6) The path name format is invalid */
- FR_DENIED, /* (7) Access denied due to prohibited access or directory full */
- FR_EXIST, /* (8) Access denied due to prohibited access */
- FR_INVALID_OBJECT, /* (9) The file/directory object is invalid */
- FR_WRITE_PROTECTED, /* (10) The physical drive is write protected */
- FR_INVALID_DRIVE, /* (11) The logical drive number is invalid */
- FR_NOT_ENABLED, /* (12) The volume has no work area */
- FR_NO_FILESYSTEM, /* (13) There is no valid FAT volume */
- FR_MKFS_ABORTED, /* (14) The f_mkfs() aborted due to any parameter error */
- FR_TIMEOUT, /* (15) Could not get a grant to access the volume within defined period */
- FR_LOCKED, /* (16) The operation is rejected according to the file sharing policy */
- FR_NOT_ENOUGH_CORE, /* (17) LFN working buffer could not be allocated */
- FR_TOO_MANY_OPEN_FILES, /* (18) Number of open files > _FS_LOCK */
- FR_INVALID_PARAMETER /* (19) Given parameter is invalid */
- } FRESULT;
至此,移植FatFs初步算是成功了(因为执行f_mount返回的是00,代表成功)
下一篇,先来研究内存管理,因为FatFs文件管理需要使用到
等内存管理结束后,会回头处理读取SD卡的事情
《2021.01.14新增的内容:这里测试了路径,我把测试结果贴上来,共两张图,以及代码块》
《第一张图是我SD卡的内容,包含几个文件夹,和几张图片,以及文件夹的嵌套关系》
《第二张图就是测试结果了,我把结果都写在注释里面,当前代码的行数,要对照上一行的注释》
《代码块:因为涉及到读取,所以必须修改diskio.c》
- DRESULT disk_read (
- BYTE pdrv, /* Physical drive nmuber (0..) */
- BYTE *buff, /* Data buffer to store read data */
- DWORD sector, /* Sector address (LBA) */
- UINT count /* Number of sectors to read (1..128) */
- )
- {
- u8 res=0;
- if (!count)return RES_PARERR;//count不能等于0,否则返回参数错误
- switch(pdrv)
- {
- case SD://SD卡
- res=SD_ReadDisk(buff,sector,count);
- while(res)//读出错
- {
- SD_Init(); //重新初始化SD卡
- res=SD_ReadDisk(buff,sector,count);
- //printf("sd rd error:%d\r\n",res);
- }
- break;
- case W25Qxx://外部flash
- break;
- default:
- res=1;
- }
- //处理返回值,将SPI_SD_driver.c的返回值转成ff.c的返回值
- if(res==0x00)return RES_OK;
- else return RES_ERROR;
- }
最后,这是《sdio_sdcard.c》代码的全部(代码略长,这里建议用ctrl+F,例如搜寻SD_Init)
- #include "sdio_sdcard.h"
- #include "string.h"
- #include "sys.h"
- #include "usart.h"
- /*用于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()
- {
- 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;
- u8 clkdiv=0;
- 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;//100M
- GPIO_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,AF12
- GPIO_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;//抢占优先级3
- NVIC_InitStructure.NVIC_IRQChannelSubPriority =0; //子优先级3
- NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
- NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器
- errorstatus=SD_PowerON(); //SD卡上电,设置频率不超过400KHz,做一系列的判断,检测卡的类型等等,最后返回响应结果。现阶段最后有可能的命令是CMD41(SD卡)或是CND1(MMC卡)
- if(errorstatus==SD_OK)errorstatus=SD_InitializeCards(); //初始化SD卡(发送CMD2、CMD3、CMD9,CMD9之后,进入数据传输模式)
- if(errorstatus==SD_OK)errorstatus=SD_GetCardInfo(&SDCardInfo); //获取卡信息(解析SD卡,例如容量)
- if(errorstatus==SD_OK)errorstatus=SD_SelectDeselect((u32)(SDCardInfo.RCA<<16));//选中SD卡
- if(errorstatus==SD_OK)errorstatus=SD_EnableWideBusOperation(SDIO_BusWide_4b); //设置4位数据宽度,MMC卡则需用8位
- if((errorstatus==SD_OK)||(SDIO_MULTIMEDIA_CARD==CardType)) {
- // 判断SD卡版本,来设置卡的时钟
- if(SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1||SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0)
- {
- clkdiv=SDIO_TRANSFER_CLK_DIV+2; //V1.1/V2.0卡,设置最高48/4=12Mhz
- }
- else clkdiv=SDIO_TRANSFER_CLK_DIV; //SDHC等其他卡,设置最高48/2=24Mhz
- SDIO_Clock_Set(clkdiv); //设置时钟频率,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_CK
- SDIO_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使能
- /* --------------------------------- 执行CMD0 ------------------------------------ */
- for(i=0;i<74;i++)
- {
- SDIO_CmdInitStructure.SDIO_Argument = 0x0;//发送CMD0进入IDLE STAGE模式命令.
- SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_GO_IDLE_STATE; //cmd0
- SDIO_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;//返回错误状态
- /* --------------------------------- 执行CMD8 ------------------------------------ */
- SDIO_CmdInitStructure.SDIO_Argument = SD_CHECK_PATTERN; //发送CMD8,短响应,检查SD卡接口特性
- SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_IF_COND; //cmd8
- SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r7
- SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No; //关闭等待中断
- SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
- SDIO_SendCommand(&SDIO_CmdInitStructure);
- errorstatus=CmdResp7Error(); //等待R7响应
- /* --------------------------------- 执行CMD55 ------------------------------------ */
- 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))
- {
- // 这里有个疑问,上面已经发送过CMD55了,为什么这里还要再发一次,我知道CMD55是复合指令,发送CMD41之前需要发送的
- // 但下面又再发送一次,正点原子完全不解释,非常顺其自然的带过,野火也怀疑了一下,但是也不清楚为什么这么做
- SDIO_CmdInitStructure.SDIO_Argument = 0x00;//发送CMD55,短响应
- 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); //发送CMD55,短响应
- errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应
- if(errorstatus!=SD_OK)return errorstatus; //响应错误
- //acmd41,命令参数由支持的电压范围及HCS位组成,HCS位置一来区分卡是SDSc还是sdhc
- SDIO_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; //r3
- SDIO_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; //r3
- SDIO_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; //cmd3
- SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6
- SDIO_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; //cmd3
- SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6
- SDIO_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; //数据读时间1
- tmp=(u8)((CSD_Tab[0]&0x0000FF00)>>8); //第2个字节
- cardinfo->SD_csd.NSAC=tmp; //数据读时间2
- tmp=(u8)(CSD_Tab[0]&0x000000FF); //第3个字节
- cardinfo->SD_csd.MaxBusClkFrec=tmp; //传输速度
- tmp=(u8)((CSD_Tab[1]&0xFF000000)>>24); //第4个字节
- cardinfo->SD_csd.CardComdClasses=tmp<<4; //卡指令类高四位
- tmp=(u8)((CSD_Tab[1]&0x00FF0000)>>16); //第5个字节
- cardinfo->SD_csd.CardComdClasses|=(tmp&0xF0)>>4;//卡指令类低四位
- cardinfo->SD_csd.RdBlockLen=tmp&0x0F; //最大读取数据长度
- tmp=(u8)((CSD_Tab[1]&0x0000FF00)>>8); //第6个字节
- cardinfo->SD_csd.PartBlockRead=(tmp&0x80)>>7; //允许分块读
- cardinfo->SD_csd.WrBlockMisalign=(tmp&0x40)>>6; //写块错位
- cardinfo->SD_csd.RdBlockMisalign=(tmp&0x20)>>5; //读块错位
- cardinfo->SD_csd.DSRImpl=(tmp&0x10)>>4;
- cardinfo->SD_csd.Reserved2=0; //保留
- 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_MULT
- tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8); //第10个字节
- cardinfo->SD_csd.DeviceSizeMul|=(tmp&0x80)>>7;
- cardinfo->CardCapacity=(cardinfo->SD_csd.DeviceSize+1);//计算卡容量
- cardinfo->CardCapacity*=(1<<(cardinfo->SD_csd.DeviceSizeMul+2));
- cardinfo->CardBlockSize=1<<(cardinfo->SD_csd.RdBlockLen);//块大小
- cardinfo->CardCapacity*=cardinfo->CardBlockSize;
- }else if(CardType==SDIO_HIGH_CAPACITY_SD_CARD) //高容量卡
- {
- tmp=(u8)(CSD_Tab[1]&0x000000FF); //第7个字节
- cardinfo->SD_csd.DeviceSize=(tmp&0x3F)<<16;//C_SIZE
- tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24); //第8个字节
- cardinfo->SD_csd.DeviceSize|=(tmp<<8);
- tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16); //第9个字节
- cardinfo->SD_csd.DeviceSize|=(tmp);
- tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8); //第10个字节
- cardinfo->CardCapacity=(long long)(cardinfo->SD_csd.DeviceSize+1)*512*1024;//计算卡容量
- cardinfo->CardBlockSize=512; //块大小固定为512字节
- }
- cardinfo->SD_csd.EraseGrSize=(tmp&0x40)>>6;
- cardinfo->SD_csd.EraseGrMul=(tmp&0x3F)<<1;
- tmp=(u8)(CSD_Tab[2]&0x000000FF); //第11个字节
- cardinfo->SD_csd.EraseGrMul|=(tmp&0x80)>>7;
- cardinfo->SD_csd.WrProtectGrSize=(tmp&0x7F);
- tmp=(u8)((CSD_Tab[3]&0xFF000000)>>24); //第12个字节
- cardinfo->SD_csd.WrProtectGrEnable=(tmp&0x80)>>7;
- cardinfo->SD_csd.ManDeflECC=(tmp&0x60)>>5;
- cardinfo->SD_csd.WrSpeedFact=(tmp&0x1C)>>2;
- cardinfo->SD_csd.MaxWrBlockLen=(tmp&0x03)<<2;
- tmp=(u8)((CSD_Tab[3]&0x00FF0000)>>16); //第13个字节
- cardinfo->SD_csd.MaxWrBlockLen|=(tmp&0xC0)>>6;
- cardinfo->SD_csd.WriteBlockPaPartial=(tmp&0x20)>>5;
- cardinfo->SD_csd.Reserved3=0;
- cardinfo->SD_csd.ContentProtectAppli=(tmp&0x01);
- tmp=(u8)((CSD_Tab[3]&0x0000FF00)>>8); //第14个字节
- cardinfo->SD_csd.FileFormatGrouop=(tmp&0x80)>>7;
- cardinfo->SD_csd.CopyFlag=(tmp&0x40)>>6;
- cardinfo->SD_csd.PermWrProtect=(tmp&0x20)>>5;
- cardinfo->SD_csd.TempWrProtect=(tmp&0x10)>>4;
- cardinfo->SD_csd.FileFormat=(tmp&0x0C)>>2;
- cardinfo->SD_csd.ECC=(tmp&0x03);
- tmp=(u8)(CSD_Tab[3]&0x000000FF); //第15个字节
- cardinfo->SD_csd.CSD_CRC=(tmp&0xFE)>>1;
- cardinfo->SD_csd.Reserved4=1;
- tmp=(u8)((CID_Tab[0]&0xFF000000)>>24); //第0个字节
- cardinfo->SD_cid.ManufacturerID=tmp;
- tmp=(u8)((CID_Tab[0]&0x00FF0000)>>16); //第1个字节
- cardinfo->SD_cid.OEM_AppliID=tmp<<8;
- tmp=(u8)((CID_Tab[0]&0x000000FF00)>>8); //第2个字节
- cardinfo->SD_cid.OEM_AppliID|=tmp;
- tmp=(u8)(CID_Tab[0]&0x000000FF); //第3个字节
- cardinfo->SD_cid.ProdName1=tmp<<24;
- tmp=(u8)((CID_Tab[1]&0xFF000000)>>24); //第4个字节
- cardinfo->SD_cid.ProdName1|=tmp<<16;
- tmp=(u8)((CID_Tab[1]&0x00FF0000)>>16); //第5个字节
- cardinfo->SD_cid.ProdName1|=tmp<<8;
- tmp=(u8)((CID_Tab[1]&0x0000FF00)>>8); //第6个字节
- cardinfo->SD_cid.ProdName1|=tmp;
- tmp=(u8)(CID_Tab[1]&0x000000FF); //第7个字节
- cardinfo->SD_cid.ProdName2=tmp;
- tmp=(u8)((CID_Tab[2]&0xFF000000)>>24); //第8个字节
- cardinfo->SD_cid.ProdRev=tmp;
- tmp=(u8)((CID_Tab[2]&0x00FF0000)>>16); //第9个字节
- cardinfo->SD_cid.ProdSN=tmp<<24;
- tmp=(u8)((CID_Tab[2]&0x0000FF00)>>8); //第10个字节
- cardinfo->SD_cid.ProdSN|=tmp<<16;
- tmp=(u8)(CID_Tab[2]&0x000000FF); //第11个字节
- cardinfo->SD_cid.ProdSN|=tmp<<8;
- tmp=(u8)((CID_Tab[3]&0xFF000000)>>24); //第12个字节
- cardinfo->SD_cid.ProdSN|=tmp;
- tmp=(u8)((CID_Tab[3]&0x00FF0000)>>16); //第13个字节
- cardinfo->SD_cid.Reserved1|=(tmp&0xF0)>>4;
- cardinfo->SD_cid.ManufactDate=(tmp&0x0F)<<8;
- tmp=(u8)((CID_Tab[3]&0x0000FF00)>>8); //第14个字节
- cardinfo->SD_cid.ManufactDate|=tmp;
- tmp=(u8)(CID_Tab[3]&0x000000FF); //第15个字节
- cardinfo->SD_cid.CID_CRC=(tmp&0xFE)>>1;
- cardinfo->SD_cid.Reserved2=1;
- return errorstatus;
- }
- //设置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; //传输结束标置位,在中断服务置1
- SDIO->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; //传输结束标置位,在中断服务置1
- SDIO->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; //传输结束标置位,在中断服务置1
- SDIO->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; //传输结束标置位,在中断服务置1
- SDIO->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位得到,rca
- return errorstatus;
- }
- if(rspr1&SD_R6_GENERAL_UNKNOWN_ERROR)return SD_GENERAL_UNKNOWN_ERROR;
- if(rspr1&SD_R6_ILLEGAL_CMD)return SD_ILLEGAL_CMD;
- if(rspr1&SD_R6_COM_CRC_FAILED)return SD_COM_CRC_FAILED;
- return errorstatus;
- }
- //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; // cmd16
- SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r1
- SDIO_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; //r1
- SDIO_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;//全FIFO
- DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_INC4;//外设突发4次传输
- DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_INC4;//存储器突发4次传输
- DMA_Init(DMA2_Stream3, &DMA_InitStructure);//初始化DMA Stream
- DMA_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;
- 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;
- 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;
- }
这是头文件《sdio_sdcard.h》
- #ifndef __SDIO_SDCARD_H
- #define __SDIO_SDCARD_H
- #include "stm32f4xx.h"
- //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 write
- block 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 the
- continuous 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 the
- continuous 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
【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(七)-准备移植FatFs的更多相关文章
- 【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(终)-配合内存管理来遍历SD卡
[STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 [STM3 ...
- 【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(八)-认识内存管理
[STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 [STM3 ...
- 【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(六)-FatFs使用的思路介绍
[STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 [STM3 ...
- 【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(五)-文件管理初步介绍
其他链接 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 ...
- 【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡
由于一张SD卡要能读写,涉及到的技术有些多,我打算分以下几篇博客 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含 ...
- 【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍
其他链接 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 ...
- 【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(三)-SD卡的操作流程
其他链接 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 ...
- 【STM32】使用SDIO进行SD卡读写,包含文件管理FatFs(四)-介绍库函数,获取一些SD卡的信息
其他链接 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 ...
- 第36章 SDIO—SD卡读写测试
第36章 SDIO—SD卡读写测试 全套200集视频教程和1000页PDF教程请到秉火论坛下载:www.firebbs.cn 野火视频教程优酷观看网址:http://i.youku.com/f ...
随机推荐
- vue路由监听和参数监听
1.路由携带数据跳转 routerAction(hideDisplays, data) { switch (hideDisplays) { case "pubAccountMenu" ...
- springcloud优雅停止上下线与熔断
SpringCloud 服务优雅上下线 Spring Boot 框架使用"约定大于配置"的特性,优雅流畅的开发过程,应用部署启动方式也很优雅.但是我们通常使用的停止应用的方式是 k ...
- Qt5 C++ GUI界面 开发环境配置 详细教程
本博客已暂停更新,需要请转新博客http://www.whbwiki.com/333.html Qt 下载 Qt 体积很大,有 1GB~3GB,官方下载通道非常慢,相信很多读者会崩溃,所以建议大家使用 ...
- robot_framewok自动化测试--(4)常用关键字介绍
常用关键字介绍 在学习一门编程语言的时候,大多教材都是从打印"hello world"开始.我们可以像编程语言一样来学习 Robot Framework.虽然通过 RIDE 提供& ...
- Part 61 to 63 Talking about partial class and partial method in C#
部分类和部分方法 部分类是用partial声明的类,它允许我们把一个类分割成两个或多个类,当应用程序编译的完成的时候,多个部分类会结合成一个类,同时partial关键字也可以用于声明结构和接口. 那么 ...
- JAVA学习(六)
今天先是把内存知识总结归纳地又学习了一遍,现在可以很清楚地描述JVM的内存是如何操作的了. 静态变量储存在方法区内存中,这个之前没有注意到,温故知新了. 如果一个引用是空的(就是指向null),那它在 ...
- Git项目迁移(把当前git项目迁移到新的git地址)
使用 git clone --bare 命令clone当前git git clone --bare http://gitlab.xxx/demo.git 推到新的git地址 cd demo.git g ...
- Kubernetes 中的 gRPC 负载均衡
安装环境依赖 docker-desktop >= 4.1.1 kubernetes >= 1.21.5 go >= 1.17 protobuf >= 3.17.3 istioc ...
- Ultraedit和写字板修改Tomcat 6.0的server.xml不生效
转:http://blog.csdn.net/greencacti/article/details/6615321 本人在修改Tomcat 6.0的server.xml的时候,发现写字板修改完保存的时 ...
- Java的脚本机制、编译器API
学习 xxl-job 定时任务时了解到基于 JVM 的 Grovvy 脚本语言.搭建 Jenkins 时知道了编译API 1. Java 脚本机制 Java 的脚本 API 可以让我们调用 JavaS ...