【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

还有是否要支持长文件名，是否支持格式化...等等

  1. /*---------------------------------------------------------------------------/
  2. /  FatFs - FAT file system module configuration file  R0.11a (C)ChaN, 2015
  3. /---------------------------------------------------------------------------*/
  4.  
  5. #define _FFCONF 64180	/* Revision ID */
  6.  
  7. /*---------------------------------------------------------------------------/
  8. / Function Configurations
  9. /---------------------------------------------------------------------------*/
  10.  
  11. #define _FS_READONLY	0 // 是否只读
  12. /* This option switches read-only configuration. (0:Read/Write or 1:Read-only)
  13. /  Read-only configuration removes writing API functions, f_write(), f_sync(),
  14. /  f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()
  15. /  and optional writing functions as well. */
  16.  
  17. #define _FS_MINIMIZE	0 // 是否使用裁剪文件
  18. /* This option defines minimization level to remove some basic API functions.
  19. /
  20. /   0: All basic functions are enabled.
  21. /   1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_chmod(), f_utime(),
  22. /      f_truncate() and f_rename() function are removed.
  23. /   2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
  24. /   3: f_lseek() function is removed in addition to 2. */
  25.  
  26. #define	_USE_STRFUNC	0 // 是否允许字符串操作
  27. /* This option switches string functions, f_gets(), f_putc(), f_puts() and
  28. /  f_printf().
  29. /
  30. /  0: Disable string functions.
  31. /  1: Enable without LF-CRLF conversion.
  32. /  2: Enable with LF-CRLF conversion. */
  33.  
  34. #define _USE_FIND		0 // 切换过滤目录读取功能和相关功能
  35. /* This option switches filtered directory read feature and related functions,
  36. /  f_findfirst() and f_findnext(). (0:Disable or 1:Enable) */
  37.  
  38. #define	_USE_MKFS		0 // 是否开启格式化功能
  39. /* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
  40.  
  41. #define	_USE_FASTSEEK	0 // 是否开启快速索引
  42. /* This option switches fast seek feature. (0:Disable or 1:Enable) */
  43.  
  44. #define _USE_LABEL		0 // 是否开启切换卷标功能
  45. /* This option switches volume label functions, f_getlabel() and f_setlabel().
  46. /  (0:Disable or 1:Enable) */
  47.  
  48. #define	_USE_FORWARD	0 // 是否允许f_forward函数
  49. /* This option switches f_forward() function. (0:Disable or 1:Enable)
  50. /  To enable it, also _FS_TINY need to be set to 1. */
  51.  
  52. /*---------------------------------------------------------------------------/
  53. / Locale and Namespace Configurations
  54. /---------------------------------------------------------------------------*/
  55. // 编码【932为日文】【936为简体中文】【949为韩文】【950为繁体中文】
  56. #define _CODE_PAGE	1
  57. /* This option specifies the OEM code page to be used on the target system.
  58. /  Incorrect setting of the code page can cause a file open failure.
  59. /
  60. /   1   - ASCII (No extended character. Non-LFN cfg. only)
  61. /   437 - U.S.
  62. /   720 - Arabic
  63. /   737 - Greek
  64. /   771 - KBL
  65. /   775 - Baltic
  66. /   850 - Latin 1
  67. /   852 - Latin 2
  68. /   855 - Cyrillic
  69. /   857 - Turkish
  70. /   860 - Portuguese
  71. /   861 - Icelandic
  72. /   862 - Hebrew
  73. /   863 - Canadian French
  74. /   864 - Arabic
  75. /   865 - Nordic
  76. /   866 - Russian
  77. /   869 - Greek 2
  78. /   932 - Japanese (DBCS)
  79. /   936 - Simplified Chinese (DBCS)
  80. /   949 - Korean (DBCS)
  81. /   950 - Traditional Chinese (DBCS)
  82. */
  83.  
  84. #define	_USE_LFN	0 // 是否支持长文件名
  85. #define	_MAX_LFN	255
  86. /* The _USE_LFN option switches the LFN feature.
  87. /
  88. /   0: Disable LFN feature. _MAX_LFN has no effect.
  89. /   1: Enable LFN with static working buffer on the BSS. Always NOT thread-safe.
  90. /   2: Enable LFN with dynamic working buffer on the STACK.
  91. /   3: Enable LFN with dynamic working buffer on the HEAP.
  92. /
  93. /  When enable the LFN feature, Unicode handling functions (option/unicode.c) must
  94. /  be added to the project. The LFN working buffer occupies (_MAX_LFN + 1) * 2 bytes.
  95. /  When use stack for the working buffer, take care on stack overflow. When use heap
  96. /  memory for the working buffer, memory management functions, ff_memalloc() and
  97. /  ff_memfree(), must be added to the project. */
  98.  
  99. #define	_LFN_UNICODE	0 // 切换字符编码
  100. /* This option switches character encoding on the API. (0:ANSI/OEM or 1:Unicode)
  101. /  To use Unicode string for the path name, enable LFN feature and set _LFN_UNICODE
  102. /  to 1. This option also affects behavior of string I/O functions. */
  103.  
  104. #define _STRF_ENCODE	3 // 编码相关
  105. /* When _LFN_UNICODE is 1, this option selects the character encoding on the file to
  106. /  be read/written via string I/O functions, f_gets(), f_putc(), f_puts and f_printf().
  107. /
  108. /  0: ANSI/OEM
  109. /  1: UTF-16LE
  110. /  2: UTF-16BE
  111. /  3: UTF-8
  112. /
  113. /  When _LFN_UNICODE is 0, this option has no effect. */
  114.  
  115. #define _FS_RPATH	0 // 是否允许相对路径
  116. /* This option configures relative path feature.
  117. /
  118. /   0: Disable relative path feature and remove related functions.
  119. /   1: Enable relative path feature. f_chdir() and f_chdrive() are available.
  120. /   2: f_getcwd() function is available in addition to 1.
  121. /
  122. /  Note that directory items read via f_readdir() are affected by this option. */
  123.  
  124. /*---------------------------------------------------------------------------/
  125. / Drive/Volume Configurations
  126. /---------------------------------------------------------------------------*/
  127.  
  128. #define _VOLUMES	1 // 磁盘逻辑卷数
  129. /* Number of volumes (logical drives) to be used. */
  130.  
  131. #define _STR_VOLUME_ID	0
  132. #define _VOLUME_STRS	"RAM","NAND","CF","SD1","SD2","USB1","USB2","USB3"
  133. /* _STR_VOLUME_ID option switches string volume ID feature.
  134. /  When _STR_VOLUME_ID is set to 1, also pre-defined strings can be used as drive
  135. /  number in the path name. _VOLUME_STRS defines the drive ID strings for each
  136. /  logical drives. Number of items must be equal to _VOLUMES. Valid characters for
  137. /  the drive ID strings are: A-Z and 0-9. */
  138.  
  139. #define	_MULTI_PARTITION	0 // 分区选项，默认为0，即一个分区，若想要多分区可自行设置
  140. /* This option switches multi-partition feature. By default (0), each logical drive
  141. /  number is bound to the same physical drive number and only an FAT volume found on
  142. /  the physical drive will be mounted. When multi-partition feature is enabled (1),
  143. /  each logical drive number is bound to arbitrary physical drive and partition
  144. /  listed in the VolToPart[]. Also f_fdisk() funciton will be available. */
  145.  
  146. #define	_MIN_SS		512 // 扇区缓冲最小值
  147. #define	_MAX_SS		512 // 扇区缓冲最大值
  148. /* These options configure the range of sector size to be supported. (512, 1024,
  149. /  2048 or 4096) Always set both 512 for most systems, all type of memory cards and
  150. /  harddisk. But a larger value may be required for on-board flash memory and some
  151. /  type of optical media. When _MAX_SS is larger than _MIN_SS, FatFs is configured
  152. /  to variable sector size and GET_SECTOR_SIZE command must be implemented to the
  153. /  disk_ioctl() function. */
  154.  
  155. #define	_USE_TRIM	0
  156. /* This option switches ATA-TRIM feature. (0:Disable or 1:Enable)
  157. /  To enable Trim feature, also CTRL_TRIM command should be implemented to the
  158. /  disk_ioctl() function. */
  159.  
  160. #define _FS_NOFSINFO	0
  161. /* If you need to know correct free space on the FAT32 volume, set bit 0 of this
  162. /  option, and f_getfree() function at first time after volume mount will force
  163. /  a full FAT scan. Bit 1 controls the use of last allocated cluster number.
  164. /
  165. /  bit0=0: Use free cluster count in the FSINFO if available.
  166. /  bit0=1: Do not trust free cluster count in the FSINFO.
  167. /  bit1=0: Use last allocated cluster number in the FSINFO if available.
  168. /  bit1=1: Do not trust last allocated cluster number in the FSINFO.
  169. */
  170.  
  171. /*---------------------------------------------------------------------------/
  172. / System Configurations
  173. /---------------------------------------------------------------------------*/
  174.  
  175. #define	_FS_TINY	0 // 文件系统为标准的还是微型的
  176. /* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
  177. /  At the tiny configuration, size of the file object (FIL) is reduced _MAX_SS
  178. /  bytes. Instead of private sector buffer eliminated from the file object,
  179. /  common sector buffer in the file system object (FATFS) is used for the file
  180. /  data transfer. */
  181.  
  182. #define _FS_NORTC	0
  183. #define _NORTC_MON	1
  184. #define _NORTC_MDAY	1
  185. #define _NORTC_YEAR	2015
  186. /* The _FS_NORTC option switches timestamp feature. If the system does not have
  187. /  an RTC function or valid timestamp is not needed, set _FS_NORTC to 1 to disable
  188. /  the timestamp feature. All objects modified by FatFs will have a fixed timestamp
  189. /  defined by _NORTC_MON, _NORTC_MDAY and _NORTC_YEAR.
  190. /  When timestamp feature is enabled (_FS_NORTC == 0), get_fattime() function need
  191. /  to be added to the project to read current time form RTC. _NORTC_MON,
  192. /  _NORTC_MDAY and _NORTC_YEAR have no effect.
  193. /  These options have no effect at read-only configuration (_FS_READONLY == 1). */
  194.  
  195. #define	_FS_LOCK	0
  196. /* The _FS_LOCK option switches file lock feature to control duplicated file open
  197. /  and illegal operation to open objects. This option must be 0 when _FS_READONLY
  198. /  is 1.
  199. /
  200. /  0:  Disable file lock feature. To avoid volume corruption, application program
  201. /      should avoid illegal open, remove and rename to the open objects.
  202. /  >0: Enable file lock feature. The value defines how many files/sub-directories
  203. /      can be opened simultaneously under file lock control. Note that the file
  204. /      lock feature is independent of re-entrancy. */
  205.  
  206. #define _FS_REENTRANT	0
  207. #define _FS_TIMEOUT		1000
  208. #define	_SYNC_t			HANDLE
  209. /* The _FS_REENTRANT option switches the re-entrancy (thread safe) of the FatFs
  210. /  module itself. Note that regardless of this option, file access to different
  211. /  volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
  212. /  and f_fdisk() function, are always not re-entrant. Only file/directory access
  213. /  to the same volume is under control of this feature.
  214. /
  215. /   0: Disable re-entrancy. _FS_TIMEOUT and _SYNC_t have no effect.
  216. /   1: Enable re-entrancy. Also user provided synchronization handlers,
  217. /      ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()
  218. /      function, must be added to the project. Samples are available in
  219. /      option/syscall.c.
  220. /
  221. /  The _FS_TIMEOUT defines timeout period in unit of time tick.
  222. /  The _SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,
  223. /  SemaphoreHandle_t and etc.. A header file for O/S definitions needs to be
  224. /  included somewhere in the scope of ff.c. */
  225.  
  226. #define _WORD_ACCESS	0 // 数据递进格式
  227. /* The _WORD_ACCESS option is an only platform dependent option. It defines
  228. /  which access method is used to the word data on the FAT volume.
  229. /
  230. /   0: Byte-by-byte access. Always compatible with all platforms.
  231. /   1: Word access. Do not choose this unless under both the following conditions.
  232. /
  233. /  * Address misaligned memory access is always allowed to ALL instructions.
  234. /  * Byte order on the memory is little-endian.
  235. /
  236. /  If it is the case, _WORD_ACCESS can also be set to 1 to reduce code size.
  237. /  Following table shows allowable settings of some type of processors.
  238. /
  239. /  ARM7TDMI   0   *2          ColdFire   0    *1         V850E      0    *2
  240. /  Cortex-M3  0   *3          Z80        0/1             V850ES     0/1
  241. /  Cortex-M0  0   *2          x86        0/1             TLCS-870   0/1
  242. /  AVR        0/1             RX600(LE)  0/1             TLCS-900   0/1
  243. /  AVR32      0   *1          RL78       0    *2         R32C       0    *2
  244. /  PIC18      0/1             SH-2       0    *1         M16C       0/1
  245. /  PIC24      0   *2          H8S        0    *1         MSP430     0    *2
  246. /  PIC32      0   *1          H8/300H    0    *1         8051       0/1
  247. /
  248. /  *1:Big-endian.
  249. /  *2:Unaligned memory access is not supported.
  250. /  *3:Some compilers generate LDM/STM for mem_cpy function.
  251. */

　　

对应上面部分宏定义，我整理了一个表格，可以一目了然的认识宏定义是做什么事情

《2021.01.16修改：不用自己的表格了，官方有做出一个表格》

　　

接着来看《diskio.c》编译的错误基本都在这了

首先是把几个头文件注释了，这几个头文件是其他范例有的，我们这里要用自己的头文件

下面的三个宏定义《ATA》《MMC》《USB》，可以改成自己想要的名称，例如我的板子上有SD、Flash，干脆就定0和1

  1. #include "sdio_sdcard.h"
  2.  
  3. #define SD 0
  4. #define FLASH 1

　　

然后把函数《disk_status》《disk_initialize》《disk_read》《disk_write》里面执行的代码注释了，或者删除也可以，未来要添加自己的代码（这里先不添加，先找出所有错误）

对了，由于我上面改了宏定义，这里switch-case也要做一些修改（图片原来的ATA、MMC、USB，要修改成SD和FLASH）

  1. DSTATUS disk_status (
  2. 	BYTE pdrv		/* Physical drive nmuber to identify the drive */
  3. )
  4. {
  5. 	DSTATUS stat;
  6. 	int result;
  7.  
  8. 	switch (pdrv) {
  9. 	　　case SD :
  10. 		return stat;
  11. 	　　case FLASH :
  12. 		return stat;
  13. 	}
  14. 	return STA_NOINIT;
  15. }

再次编译，发现错误

解决这个错误有两个方法，但是这两个方法，要用哪个，需要取决于你应用的设计

get_fattime是获取当前时间

如果不需要，在《ffconf.h》里面，找到宏定义《#define _FS_NORTC》，改为1，即可关闭

如果需要这个功能，需要在《diskio.c》里面，实现get_fattime函数，代码如下

  1. DWORD get_fattime(void) {
  2. 	/* 返回当前时间戳 */
  3. 	return	  ((DWORD)(2015 - 1980) << 25)	/* Year 2015 */
  4. 			| ((DWORD)1 << 21)				/* Month 1 */
  5. 			| ((DWORD)1 << 16)				/* Mday 1 */
  6. 			| ((DWORD)0 << 11)				/* Hour 0 */
  7. 			| ((DWORD)0 << 5)				  /* Min 0 */
  8. 			| ((DWORD)0 >> 1);				/* Sec 0 */
  9. } 

我不需要这个功能，我直接设定宏定义为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步骤不是初始化该做的事），我是拆分开来，一部分一部分代码来讲解的，而本篇文章末了的代码，是整合过的，就这一点不同而已

  1. SD_Error SD_Init(void)
  2. {
  3.       ...
  4.       ...
  5. }

　　

FatFs文件管理的宗旨，你不要自己去调用SD的初始化

由文件管理自己去调用，但你还是要给出命令的，例如接口《f_mount》

SD_Init会返回一个状态SD_Error，这个状态会通知文件管理系统，然后《f_mount》也有一个返回值，最终我们就会得知初始化的结果

  1. DSTATUS disk_initialize (
  2. 	BYTE pdrv				/* Physical drive nmuber to identify the drive */
  3. )
  4. {
  5. 	DSTATUS stat;
  6. 	int result = 0;
  7.  
  8. 	switch (pdrv) {
  9. 		case SD :
  10. 			result = SD_Init(); // SD卡初始化
  11. 			break;
  12. 		case W25Qxx :
  13. 			break;
  14. 	}
  15.  
  16. 	if(result)return  STA_NOINIT;
  17. 	else return 0; //初始化成功
  18. }

完成了设备接口的配置，我们回到自己的应用层，尝试执行《f_mount》，参数2：path，这里给的逻辑编号，是你在《diskio.c》里面的宏定义，SD我定义为0，这里就给 "0："

最终函数会返回一个状态《FRESULT》，如果返回是0，代表正常

《2021.01.14新增的内容：f_mount就是挂起，挂起后你才可以使用一些功能，例如读取f_open，或是打开文件夹f_opendir，写入数据f_write。。。等等》

  1. #include "stm32f4xx.h"
  2.  
  3. #include "delay.h"
  4.  
  5. // 外设
  6. #include "sdio_sdcard.h"
  7. #include "usart.h"
  8.  
  9. // FatFS
  10. #include "diskio.h"
  11. #include "ff.h"
  12.  
  13. FATFS *fs[_VOLUMES];              // FatFs文件系统对象
  14. FRESULT res_sd;               	// 文件操作结果
  15.  
  16. int main(void)
  17. {
  18. 	delay_init(180); 
  19.  
  20. 	/* 串口初始化 */
  21. 	uart1_init(9600);
  22.  
  23. 	/* 文件管理系统初始化 */
  24. 	res_sd = f_mount(fs[0],"0:",1);
  25. 	USART_SendData(USART1, res_sd); // 打印处理结果
  26.  
  27.         while(1);
  28. }

　　

执行效果如下，记得要用HEX显示

  1. /* File function return code (FRESULT) */
  2.  
  3. typedef enum {
  4. 	FR_OK = 0,				/* (0) Succeeded */
  5. 	FR_DISK_ERR,			/* (1) A hard error occurred in the low level disk I/O layer */
  6. 	FR_INT_ERR,				/* (2) Assertion failed */
  7. 	FR_NOT_READY,			/* (3) The physical drive cannot work */
  8. 	FR_NO_FILE,				/* (4) Could not find the file */
  9. 	FR_NO_PATH,				/* (5) Could not find the path */
  10. 	FR_INVALID_NAME,		/* (6) The path name format is invalid */
  11. 	FR_DENIED,				/* (7) Access denied due to prohibited access or directory full */
  12. 	FR_EXIST,				/* (8) Access denied due to prohibited access */
  13. 	FR_INVALID_OBJECT,		/* (9) The file/directory object is invalid */
  14. 	FR_WRITE_PROTECTED,		/* (10) The physical drive is write protected */
  15. 	FR_INVALID_DRIVE,		/* (11) The logical drive number is invalid */
  16. 	FR_NOT_ENABLED,			/* (12) The volume has no work area */
  17. 	FR_NO_FILESYSTEM,		/* (13) There is no valid FAT volume */
  18. 	FR_MKFS_ABORTED,		/* (14) The f_mkfs() aborted due to any parameter error */
  19. 	FR_TIMEOUT,				/* (15) Could not get a grant to access the volume within defined period */
  20. 	FR_LOCKED,				/* (16) The operation is rejected according to the file sharing policy */
  21. 	FR_NOT_ENOUGH_CORE,		/* (17) LFN working buffer could not be allocated */
  22. 	FR_TOO_MANY_OPEN_FILES,	/* (18) Number of open files > _FS_LOCK */
  23. 	FR_INVALID_PARAMETER	/* (19) Given parameter is invalid */
  24. } FRESULT;

　　

至此，移植FatFs初步算是成功了（因为执行f_mount返回的是00，代表成功）

下一篇，先来研究内存管理，因为FatFs文件管理需要使用到

等内存管理结束后，会回头处理读取SD卡的事情

《2021.01.14新增的内容：这里测试了路径，我把测试结果贴上来，共两张图，以及代码块》

《第一张图是我SD卡的内容，包含几个文件夹，和几张图片，以及文件夹的嵌套关系》

《第二张图就是测试结果了，我把结果都写在注释里面，当前代码的行数，要对照上一行的注释》

《代码块：因为涉及到读取，所以必须修改diskio.c》

  1. DRESULT disk_read (
  2. 	BYTE pdrv,		/* Physical drive nmuber (0..) */
  3. 	BYTE *buff,		/* Data buffer to store read data */
  4. 	DWORD sector,	/* Sector address (LBA) */
  5. 	UINT count		/* Number of sectors to read (1..128) */
  6. )
  7. {
  8. 	u8 res=0;
  9.     if (!count)return RES_PARERR;//count不能等于0，否则返回参数错误
  10. 	switch(pdrv)
  11. 	{
  12. 		case SD://SD卡
  13. 			res=SD_ReadDisk(buff,sector,count);
  14. 			while(res)//读出错
  15. 			{
  16. 				SD_Init();	//重新初始化SD卡
  17. 				res=SD_ReadDisk(buff,sector,count);
  18. 				//printf("sd rd error:%d\r\n",res);
  19. 			}
  20. 			break;
  21. 		case W25Qxx://外部flash
  22. 			break;
  23. 		default:
  24. 			res=1;
  25. 	}
  26.    //处理返回值，将SPI_SD_driver.c的返回值转成ff.c的返回值
  27.     if(res==0x00)return RES_OK;
  28.     else return RES_ERROR;
  29. }

　　

最后，这是《sdio_sdcard.c》代码的全部（代码略长，这里建议用ctrl+F，例如搜寻SD_Init）

  1. #include "sdio_sdcard.h"
  2. #include "string.h"
  3. #include "sys.h"
  4. #include "usart.h"	 	 
  5.  
  6. /*用于sdio初始化的结构体*/
  7. SDIO_InitTypeDef SDIO_InitStructure;
  8. SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
  9. SDIO_DataInitTypeDef SDIO_DataInitStructure;   
  10.  
  11. SD_Error CmdError(void);
  12. SD_Error CmdResp7Error(void);
  13. SD_Error CmdResp1Error(u8 cmd);
  14. SD_Error CmdResp3Error(void);
  15. SD_Error CmdResp2Error(void);
  16. SD_Error CmdResp6Error(u8 cmd,u16*prca);
  17. SD_Error SDEnWideBus(u8 enx);
  18. SD_Error IsCardProgramming(u8 *pstatus);
  19. SD_Error FindSCR(u16 rca,u32 *pscr);
  20. u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes); 
  21.  
  22. static u8 CardType=SDIO_STD_CAPACITY_SD_CARD_V1_1;		//SD卡类型（默认为1.x卡）
  23. static u32 CSD_Tab[4],CID_Tab[4],RCA=0;					//SD卡CSD,CID以及相对地址(RCA)数据
  24. static u8 DeviceMode=SD_DMA_MODE;		   				//工作模式,注意,工作模式必须通过SD_SetDeviceMode,后才算数.这里只是定义一个默认的模式(SD_DMA_MODE)
  25. static u8 StopCondition=0; 								//是否发送停止传输标志位,DMA多块读写的时候用到
  26. volatile SD_Error TransferError=SD_OK;					//数据传输错误标志,DMA读写时使用
  27. volatile u8 TransferEnd=0;								//传输结束标志,DMA读写时使用
  28. SD_CardInfo SDCardInfo;									//SD卡信息
  29.  
  30. //SD_ReadDisk/SD_WriteDisk函数专用buf,当这两个函数的数据缓存区地址不是4字节对齐的时候,
  31. //需要用到该数组,确保数据缓存区地址是4字节对齐的.
  32. __align(4) u8 SDIO_DATA_BUFFER[512];						  
  33.  
  34. void SDIO_Register_Deinit()
  35. {
  36. 	SDIO->POWER=0x00000000;
  37. 	SDIO->CLKCR=0x00000000;
  38. 	SDIO->ARG=0x00000000;
  39. 	SDIO->CMD=0x00000000;
  40. 	SDIO->DTIMER=0x00000000;
  41. 	SDIO->DLEN=0x00000000;
  42. 	SDIO->DCTRL=0x00000000;
  43. 	SDIO->ICR=0x00C007FF;
  44. 	SDIO->MASK=0x00000000;
  45. }
  46.  
  47. //初始化SD卡
  48. //返回值:错误代码;(0,无错误)
  49. SD_Error SD_Init(void)
  50. {
  51.  	GPIO_InitTypeDef  GPIO_InitStructure;
  52. 	NVIC_InitTypeDef NVIC_InitStructure;
  53.  
  54. 	SD_Error errorstatus=SD_OK;
  55. 	u8 clkdiv=0;
  56.  
  57. 	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOD|RCC_AHB1Periph_DMA2, ENABLE);//使能GPIOC,GPIOD DMA2时钟
  58.  
  59. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SDIO, ENABLE);//SDIO时钟使能
  60.  
  61. 	RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, ENABLE);//SDIO复位
  62.  
  63. 	GPIO_InitStructure.GPIO_Pin =GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12; 	//PC8,9,10,11,12复用功能输出
  64. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
  65. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//100M
  66. 	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  67. 	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
  68. 	GPIO_Init(GPIOC, &GPIO_InitStructure);// PC8,9,10,11,12复用功能输出
  69.  
  70. 	GPIO_InitStructure.GPIO_Pin =GPIO_Pin_2;
  71. 	GPIO_Init(GPIOD, &GPIO_InitStructure);//PD2复用功能输出
  72.  
  73. 	 //引脚复用映射设置
  74. 	GPIO_PinAFConfig(GPIOC,GPIO_PinSource8,GPIO_AF_SDIO); //PC8,AF12
  75. 	GPIO_PinAFConfig(GPIOC,GPIO_PinSource9,GPIO_AF_SDIO);
  76. 	GPIO_PinAFConfig(GPIOC,GPIO_PinSource10,GPIO_AF_SDIO);
  77. 	GPIO_PinAFConfig(GPIOC,GPIO_PinSource11,GPIO_AF_SDIO);
  78. 	GPIO_PinAFConfig(GPIOC,GPIO_PinSource12,GPIO_AF_SDIO);
  79. 	GPIO_PinAFConfig(GPIOD,GPIO_PinSource2,GPIO_AF_SDIO);	
  80.  
  81. 	RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, DISABLE);//SDIO结束复位
  82.  
  83.  	//SDIO外设寄存器设置为默认值
  84. 	SDIO_Register_Deinit();
  85.  
  86. 	NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;
  87. 	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;//抢占优先级3
  88. 	NVIC_InitStructure.NVIC_IRQChannelSubPriority =0;		//子优先级3
  89. 	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能
  90. 	NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器
  91.  
  92. 	errorstatus=SD_PowerON();			//SD卡上电，设置频率不超过400KHz，做一系列的判断，检测卡的类型等等，最后返回响应结果。现阶段最后有可能的命令是CMD41（SD卡）或是CND1（MMC卡）
  93.  
  94. 	if(errorstatus==SD_OK)errorstatus=SD_InitializeCards();			//初始化SD卡（发送CMD2、CMD3、CMD9，CMD9之后，进入数据传输模式）
  95.  
  96. 	if(errorstatus==SD_OK)errorstatus=SD_GetCardInfo(&SDCardInfo);	//获取卡信息（解析SD卡，例如容量）
  97.  
  98. 	if(errorstatus==SD_OK)errorstatus=SD_SelectDeselect((u32)(SDCardInfo.RCA<<16));//选中SD卡   
  99.  
  100. 	if(errorstatus==SD_OK)errorstatus=SD_EnableWideBusOperation(SDIO_BusWide_4b);	//设置4位数据宽度,MMC卡则需用8位
  101.  
  102. 	if((errorstatus==SD_OK)||(SDIO_MULTIMEDIA_CARD==CardType)) {
  103. 		// 判断SD卡版本，来设置卡的时钟
  104. 		if(SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1||SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0)
  105. 		{
  106. 			clkdiv=SDIO_TRANSFER_CLK_DIV+2;	//V1.1/V2.0卡，设置最高48/4=12Mhz
  107. 		}
  108. 		else clkdiv=SDIO_TRANSFER_CLK_DIV;	//SDHC等其他卡，设置最高48/2=24Mhz
  109. 		SDIO_Clock_Set(clkdiv);	//设置时钟频率,SDIO时钟计算公式:SDIO_CK时钟=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定为48Mhz
  110. 		//errorstatus=SD_SetDeviceMode(SD_DMA_MODE);	//设置为DMA模式
  111. 		errorstatus=SD_SetDeviceMode(SD_POLLING_MODE);//设置为查询模式
  112.  	}
  113. 	return errorstatus;
  114. }
  115. //SDIO时钟初始化设置
  116. //clkdiv:时钟分频系数
  117. //CK时钟=SDIOCLK/[clkdiv+2];(SDIOCLK时钟固定为48Mhz)
  118. void SDIO_Clock_Set(u8 clkdiv)
  119. {
  120. 	u32 tmpreg=SDIO->CLKCR;
  121.   	tmpreg&=0XFFFFFF00;
  122.  	tmpreg|=clkdiv;
  123. 	SDIO->CLKCR=tmpreg;
  124. } 
  125.  
  126. //卡上电
  127. //查询所有SDIO接口上的卡设备,并查询其电压和配置时钟
  128. //返回值:错误代码;(0,无错误)
  129. SD_Error SD_PowerON(void)
  130. {
  131.  	u8 i=0;
  132. 	SD_Error errorstatus=SD_OK;
  133. 	u32 response=0,count=0,validvoltage=0;
  134. 	u32 SDType=SD_STD_CAPACITY;
  135.  
  136. 	 /*初始化时的时钟不能大于400KHz*/
  137.   SDIO_InitStructure.SDIO_ClockDiv = SDIO_INIT_CLK_DIV;	/* HCLK = 72MHz, SDIOCLK = 72MHz, SDIO_CK = HCLK/(178 + 2) = 400 KHz */
  138.   SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
  139.   SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;  //不使用bypass模式，直接用HCLK进行分频得到SDIO_CK
  140.   SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;	// 空闲时不关闭时钟电源
  141.   SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;	 				//1位数据线
  142.   SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;//硬件流
  143.   SDIO_Init(&SDIO_InitStructure);
  144.  
  145. 	SDIO_SetPowerState(SDIO_PowerState_ON);	//上电状态,开启卡时钟
  146.   SDIO->CLKCR|=1<<8;			//SDIOCK使能  
  147.  
  148. 	/* --------------------------------- 执行CMD0 ------------------------------------ */
  149.  	for(i=0;i<74;i++)
  150. 	{
  151. 		SDIO_CmdInitStructure.SDIO_Argument = 0x0;//发送CMD0进入IDLE STAGE模式命令.
  152.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_GO_IDLE_STATE; //cmd0
  153.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_No;  //无响应
  154.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  155.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;  //则CPSM在开始发送命令之前等待数据传输结束。
  156.     SDIO_SendCommand(&SDIO_CmdInitStructure);	  		//写命令进命令寄存器
  157.  
  158. 		errorstatus=CmdError();
  159.  
  160. 		if(errorstatus==SD_OK)break;
  161.  	}
  162.  	if(errorstatus)return errorstatus;//返回错误状态
  163.  
  164. 	/* --------------------------------- 执行CMD8 ------------------------------------ */
  165.   SDIO_CmdInitStructure.SDIO_Argument = SD_CHECK_PATTERN;	//发送CMD8,短响应,检查SD卡接口特性
  166.   SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_IF_COND;	//cmd8
  167.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;	 //r7
  168.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;			 //关闭等待中断
  169.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  170.   SDIO_SendCommand(&SDIO_CmdInitStructure);
  171.  
  172.   errorstatus=CmdResp7Error();						//等待R7响应
  173.  
  174. 	/* --------------------------------- 执行CMD55 ------------------------------------ */
  175.  	if(errorstatus==SD_OK) 								//R7响应正常
  176. 	{
  177. 		CardType=SDIO_STD_CAPACITY_SD_CARD_V2_0;		//SD 2.0卡
  178. 		SDType=SD_HIGH_CAPACITY;			   			//高容量卡
  179. 	}
  180.  
  181. 	SDIO_CmdInitStructure.SDIO_Argument = 0x00;//发送CMD55,短响应
  182. 	SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
  183. 	SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  184. 	SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  185. 	SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  186. 	SDIO_SendCommand(&SDIO_CmdInitStructure);		//发送CMD55,短响应	 
  187.  
  188.   errorstatus=CmdResp1Error(SD_CMD_APP_CMD); 		 	//等待R1响应   
  189.  
  190. 	if(errorstatus==SD_OK)//SD2.0/SD 1.1,否则为MMC卡
  191. 	{
  192. 		//SD卡,发送ACMD41 SD_APP_OP_COND,参数为:0x80100000
  193. 		while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
  194. 		{
  195. 			// 这里有个疑问，上面已经发送过CMD55了，为什么这里还要再发一次，我知道CMD55是复合指令，发送CMD41之前需要发送的
  196. 			// 但下面又再发送一次，正点原子完全不解释，非常顺其自然的带过，野火也怀疑了一下，但是也不清楚为什么这么做
  197. 		  SDIO_CmdInitStructure.SDIO_Argument = 0x00;//发送CMD55,短响应
  198.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;	  //CMD55
  199.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  200.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  201.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  202.       SDIO_SendCommand(&SDIO_CmdInitStructure);			//发送CMD55,短响应	 
  203.  
  204. 			errorstatus=CmdResp1Error(SD_CMD_APP_CMD); 	 	//等待R1响应  
  205.  
  206.  			if(errorstatus!=SD_OK)return errorstatus;   	//响应错误
  207.  
  208.       //acmd41，命令参数由支持的电压范围及HCS位组成，HCS位置一来区分卡是SDSc还是sdhc
  209.       SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_SD | SDType;	//发送ACMD41,短响应
  210.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_OP_COND;
  211.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;  //r3
  212.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  213.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  214.       SDIO_SendCommand(&SDIO_CmdInitStructure);
  215.  
  216. 			errorstatus=CmdResp3Error(); 					//等待R3响应   
  217.  
  218.  			if(errorstatus!=SD_OK)return errorstatus;   	//响应错误
  219. 			response=SDIO->RESP1;;			   				//得到响应
  220. 			validvoltage=(((response>>31)==1)?1:0);			//判断SD卡上电是否完成
  221. 			count++;
  222. 		}
  223. 		if(count>=SD_MAX_VOLT_TRIAL)
  224. 		{
  225. 			errorstatus=SD_INVALID_VOLTRANGE;
  226. 			return errorstatus;
  227. 		}
  228. 		if(response&=SD_HIGH_CAPACITY)
  229. 		{
  230. 			CardType=SDIO_HIGH_CAPACITY_SD_CARD;
  231. 		}
  232.  	}
  233. 	else//MMC卡
  234. 	{
  235. 		//MMC卡,发送CMD1 SDIO_SEND_OP_COND,参数为:0x80FF8000
  236. 		while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
  237. 		{
  238. 			SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_MMC;//发送CMD1,短响应
  239.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_OP_COND;
  240.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;  //r3
  241.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  242.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  243.       SDIO_SendCommand(&SDIO_CmdInitStructure);
  244.  
  245. 			errorstatus=CmdResp3Error(); 					//等待R3响应   
  246.  
  247.  			if(errorstatus!=SD_OK)return errorstatus;   	//响应错误
  248. 			response=SDIO->RESP1;;			   				//得到响应
  249. 			validvoltage=(((response>>31)==1)?1:0);
  250. 			count++;
  251. 		}
  252. 		if(count>=SD_MAX_VOLT_TRIAL)
  253. 		{
  254. 			errorstatus=SD_INVALID_VOLTRANGE;
  255. 			return errorstatus;
  256. 		}
  257. 		CardType=SDIO_MULTIMEDIA_CARD;
  258.   }  
  259.  
  260. 	return(errorstatus);
  261. }
  262. //SD卡 Power OFF
  263. //返回值:错误代码;(0,无错误)
  264. SD_Error SD_PowerOFF(void)
  265. {
  266.  
  267.   SDIO_SetPowerState(SDIO_PowerState_OFF);//SDIO电源关闭,时钟停止	
  268.  
  269.   return SD_OK;
  270. }
  271. //初始化所有的卡,并让卡进入就绪状态
  272. //返回值:错误代码
  273. SD_Error SD_InitializeCards(void)
  274. {
  275.  	SD_Error errorstatus=SD_OK;
  276. 	u16 rca = 0x01;
  277.  
  278.   if (SDIO_GetPowerState() == SDIO_PowerState_OFF)	//检查电源状态,确保为上电状态
  279.   {
  280.     errorstatus = SD_REQUEST_NOT_APPLICABLE;
  281.     return(errorstatus);
  282.   }
  283.  
  284.  	if(SDIO_SECURE_DIGITAL_IO_CARD!=CardType)			//非SECURE_DIGITAL_IO_CARD
  285. 	{
  286. 		SDIO_CmdInitStructure.SDIO_Argument = 0x0;//发送CMD2,取得CID,长响应
  287.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_ALL_SEND_CID;
  288.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
  289.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  290.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  291.     SDIO_SendCommand(&SDIO_CmdInitStructure);//发送CMD2,取得CID,长响应	
  292.  
  293. 		errorstatus=CmdResp2Error(); 					//等待R2响应 
  294.  
  295. 		if(errorstatus!=SD_OK)return errorstatus;   	//响应错误		 
  296.  
  297.  		CID_Tab[0]=SDIO->RESP1;
  298. 		CID_Tab[1]=SDIO->RESP2;
  299. 		CID_Tab[2]=SDIO->RESP3;
  300. 		CID_Tab[3]=SDIO->RESP4;
  301. 	}
  302. 	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))//判断卡类型
  303. 	{
  304. 		SDIO_CmdInitStructure.SDIO_Argument = 0x00;//发送CMD3,短响应
  305.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR;	//cmd3
  306.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6
  307.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  308.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  309.     SDIO_SendCommand(&SDIO_CmdInitStructure);	//发送CMD3,短响应 
  310.  
  311. 		errorstatus=CmdResp6Error(SD_CMD_SET_REL_ADDR,&rca);//等待R6响应 
  312.  
  313. 		if(errorstatus!=SD_OK)return errorstatus;   	//响应错误
  314. 	}
  315.     if (SDIO_MULTIMEDIA_CARD==CardType)
  316.     {
  317.  
  318. 		  SDIO_CmdInitStructure.SDIO_Argument = (u32)(rca<<16);//发送CMD3,短响应
  319.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR;	//cmd3
  320.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6
  321.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  322.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  323.       SDIO_SendCommand(&SDIO_CmdInitStructure);	//发送CMD3,短响应 	
  324.  
  325.       errorstatus=CmdResp2Error(); 					//等待R2响应   
  326.  
  327. 		  if(errorstatus!=SD_OK)return errorstatus;   	//响应错误
  328.     }
  329. 	if (SDIO_SECURE_DIGITAL_IO_CARD!=CardType)			//非SECURE_DIGITAL_IO_CARD
  330. 	{
  331. 		RCA = rca;
  332.  
  333.     SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)(rca << 16);//发送CMD9+卡RCA,取得CSD,长响应
  334.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_CSD;
  335.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
  336.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  337.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  338.     SDIO_SendCommand(&SDIO_CmdInitStructure);
  339.  
  340. 		errorstatus=CmdResp2Error(); 					//等待R2响应
  341. 		if(errorstatus!=SD_OK)return errorstatus;   	//响应错误		    
  342.  
  343. 		CSD_Tab[0]=SDIO->RESP1;
  344. 	  CSD_Tab[1]=SDIO->RESP2;
  345. 		CSD_Tab[2]=SDIO->RESP3;
  346. 		CSD_Tab[3]=SDIO->RESP4;
  347. 	}
  348. 	return SD_OK;//卡初始化成功
  349. }
  350. //得到卡信息
  351. //cardinfo:卡信息存储区
  352. //返回值:错误状态
  353. SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo)
  354. {
  355.  	SD_Error errorstatus=SD_OK;
  356. 	u8 tmp=0;
  357. 	cardinfo->CardType=(u8)CardType; 				//卡类型
  358. 	cardinfo->RCA=(u16)RCA;							//卡RCA值
  359. 	tmp=(u8)((CSD_Tab[0]&0xFF000000)>>24);
  360. 	cardinfo->SD_csd.CSDStruct=(tmp&0xC0)>>6;		//CSD结构
  361. 	cardinfo->SD_csd.SysSpecVersion=(tmp&0x3C)>>2;	//2.0协议还没定义这部分(为保留),应该是后续协议定义的
  362. 	cardinfo->SD_csd.Reserved1=tmp&0x03;			//2个保留位
  363. 	tmp=(u8)((CSD_Tab[0]&0x00FF0000)>>16);			//第1个字节
  364. 	cardinfo->SD_csd.TAAC=tmp;				   		//数据读时间1
  365. 	tmp=(u8)((CSD_Tab[0]&0x0000FF00)>>8);	  		//第2个字节
  366. 	cardinfo->SD_csd.NSAC=tmp;		  				//数据读时间2
  367. 	tmp=(u8)(CSD_Tab[0]&0x000000FF);				//第3个字节
  368. 	cardinfo->SD_csd.MaxBusClkFrec=tmp;		  		//传输速度
  369. 	tmp=(u8)((CSD_Tab[1]&0xFF000000)>>24);			//第4个字节
  370. 	cardinfo->SD_csd.CardComdClasses=tmp<<4;    	//卡指令类高四位
  371. 	tmp=(u8)((CSD_Tab[1]&0x00FF0000)>>16);	 		//第5个字节
  372. 	cardinfo->SD_csd.CardComdClasses|=(tmp&0xF0)>>4;//卡指令类低四位
  373. 	cardinfo->SD_csd.RdBlockLen=tmp&0x0F;	    	//最大读取数据长度
  374. 	tmp=(u8)((CSD_Tab[1]&0x0000FF00)>>8);			//第6个字节
  375. 	cardinfo->SD_csd.PartBlockRead=(tmp&0x80)>>7;	//允许分块读
  376. 	cardinfo->SD_csd.WrBlockMisalign=(tmp&0x40)>>6;	//写块错位
  377. 	cardinfo->SD_csd.RdBlockMisalign=(tmp&0x20)>>5;	//读块错位
  378. 	cardinfo->SD_csd.DSRImpl=(tmp&0x10)>>4;
  379. 	cardinfo->SD_csd.Reserved2=0; 					//保留
  380.  	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卡
  381. 	{
  382. 		cardinfo->SD_csd.DeviceSize=(tmp&0x03)<<10;	//C_SIZE(12位)
  383. 	 	tmp=(u8)(CSD_Tab[1]&0x000000FF); 			//第7个字节
  384. 		cardinfo->SD_csd.DeviceSize|=(tmp)<<2;
  385.  		tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24);		//第8个字节
  386. 		cardinfo->SD_csd.DeviceSize|=(tmp&0xC0)>>6;
  387.  		cardinfo->SD_csd.MaxRdCurrentVDDMin=(tmp&0x38)>>3;
  388. 		cardinfo->SD_csd.MaxRdCurrentVDDMax=(tmp&0x07);
  389.  		tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16);		//第9个字节
  390. 		cardinfo->SD_csd.MaxWrCurrentVDDMin=(tmp&0xE0)>>5;
  391. 		cardinfo->SD_csd.MaxWrCurrentVDDMax=(tmp&0x1C)>>2;
  392. 		cardinfo->SD_csd.DeviceSizeMul=(tmp&0x03)<<1;//C_SIZE_MULT
  393.  		tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8);	  	//第10个字节
  394. 		cardinfo->SD_csd.DeviceSizeMul|=(tmp&0x80)>>7;
  395.  		cardinfo->CardCapacity=(cardinfo->SD_csd.DeviceSize+1);//计算卡容量
  396. 		cardinfo->CardCapacity*=(1<<(cardinfo->SD_csd.DeviceSizeMul+2));
  397. 		cardinfo->CardBlockSize=1<<(cardinfo->SD_csd.RdBlockLen);//块大小
  398. 		cardinfo->CardCapacity*=cardinfo->CardBlockSize;
  399. 	}else if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)	//高容量卡
  400. 	{
  401.  		tmp=(u8)(CSD_Tab[1]&0x000000FF); 		//第7个字节
  402. 		cardinfo->SD_csd.DeviceSize=(tmp&0x3F)<<16;//C_SIZE
  403.  		tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24); 	//第8个字节
  404.  		cardinfo->SD_csd.DeviceSize|=(tmp<<8);
  405.  		tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16);	//第9个字节
  406.  		cardinfo->SD_csd.DeviceSize|=(tmp);
  407.  		tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8); 	//第10个字节
  408.  		cardinfo->CardCapacity=(long long)(cardinfo->SD_csd.DeviceSize+1)*512*1024;//计算卡容量
  409. 		cardinfo->CardBlockSize=512; 			//块大小固定为512字节
  410. 	}
  411. 	cardinfo->SD_csd.EraseGrSize=(tmp&0x40)>>6;
  412. 	cardinfo->SD_csd.EraseGrMul=(tmp&0x3F)<<1;
  413. 	tmp=(u8)(CSD_Tab[2]&0x000000FF);			//第11个字节
  414. 	cardinfo->SD_csd.EraseGrMul|=(tmp&0x80)>>7;
  415. 	cardinfo->SD_csd.WrProtectGrSize=(tmp&0x7F);
  416.  	tmp=(u8)((CSD_Tab[3]&0xFF000000)>>24);		//第12个字节
  417. 	cardinfo->SD_csd.WrProtectGrEnable=(tmp&0x80)>>7;
  418. 	cardinfo->SD_csd.ManDeflECC=(tmp&0x60)>>5;
  419. 	cardinfo->SD_csd.WrSpeedFact=(tmp&0x1C)>>2;
  420. 	cardinfo->SD_csd.MaxWrBlockLen=(tmp&0x03)<<2;
  421. 	tmp=(u8)((CSD_Tab[3]&0x00FF0000)>>16);		//第13个字节
  422. 	cardinfo->SD_csd.MaxWrBlockLen|=(tmp&0xC0)>>6;
  423. 	cardinfo->SD_csd.WriteBlockPaPartial=(tmp&0x20)>>5;
  424. 	cardinfo->SD_csd.Reserved3=0;
  425. 	cardinfo->SD_csd.ContentProtectAppli=(tmp&0x01);
  426. 	tmp=(u8)((CSD_Tab[3]&0x0000FF00)>>8);		//第14个字节
  427. 	cardinfo->SD_csd.FileFormatGrouop=(tmp&0x80)>>7;
  428. 	cardinfo->SD_csd.CopyFlag=(tmp&0x40)>>6;
  429. 	cardinfo->SD_csd.PermWrProtect=(tmp&0x20)>>5;
  430. 	cardinfo->SD_csd.TempWrProtect=(tmp&0x10)>>4;
  431. 	cardinfo->SD_csd.FileFormat=(tmp&0x0C)>>2;
  432. 	cardinfo->SD_csd.ECC=(tmp&0x03);
  433. 	tmp=(u8)(CSD_Tab[3]&0x000000FF);			//第15个字节
  434. 	cardinfo->SD_csd.CSD_CRC=(tmp&0xFE)>>1;
  435. 	cardinfo->SD_csd.Reserved4=1;
  436. 	tmp=(u8)((CID_Tab[0]&0xFF000000)>>24);		//第0个字节
  437. 	cardinfo->SD_cid.ManufacturerID=tmp;
  438. 	tmp=(u8)((CID_Tab[0]&0x00FF0000)>>16);		//第1个字节
  439. 	cardinfo->SD_cid.OEM_AppliID=tmp<<8;
  440. 	tmp=(u8)((CID_Tab[0]&0x000000FF00)>>8);		//第2个字节
  441. 	cardinfo->SD_cid.OEM_AppliID|=tmp;
  442. 	tmp=(u8)(CID_Tab[0]&0x000000FF);			//第3个字节
  443. 	cardinfo->SD_cid.ProdName1=tmp<<24;
  444. 	tmp=(u8)((CID_Tab[1]&0xFF000000)>>24); 		//第4个字节
  445. 	cardinfo->SD_cid.ProdName1|=tmp<<16;
  446. 	tmp=(u8)((CID_Tab[1]&0x00FF0000)>>16);	   	//第5个字节
  447. 	cardinfo->SD_cid.ProdName1|=tmp<<8;
  448. 	tmp=(u8)((CID_Tab[1]&0x0000FF00)>>8);		//第6个字节
  449. 	cardinfo->SD_cid.ProdName1|=tmp;
  450. 	tmp=(u8)(CID_Tab[1]&0x000000FF);	  		//第7个字节
  451. 	cardinfo->SD_cid.ProdName2=tmp;
  452. 	tmp=(u8)((CID_Tab[2]&0xFF000000)>>24); 		//第8个字节
  453. 	cardinfo->SD_cid.ProdRev=tmp;
  454. 	tmp=(u8)((CID_Tab[2]&0x00FF0000)>>16);		//第9个字节
  455. 	cardinfo->SD_cid.ProdSN=tmp<<24;
  456. 	tmp=(u8)((CID_Tab[2]&0x0000FF00)>>8); 		//第10个字节
  457. 	cardinfo->SD_cid.ProdSN|=tmp<<16;
  458. 	tmp=(u8)(CID_Tab[2]&0x000000FF);   			//第11个字节
  459. 	cardinfo->SD_cid.ProdSN|=tmp<<8;
  460. 	tmp=(u8)((CID_Tab[3]&0xFF000000)>>24); 		//第12个字节
  461. 	cardinfo->SD_cid.ProdSN|=tmp;
  462. 	tmp=(u8)((CID_Tab[3]&0x00FF0000)>>16);	 	//第13个字节
  463. 	cardinfo->SD_cid.Reserved1|=(tmp&0xF0)>>4;
  464. 	cardinfo->SD_cid.ManufactDate=(tmp&0x0F)<<8;
  465. 	tmp=(u8)((CID_Tab[3]&0x0000FF00)>>8);		//第14个字节
  466. 	cardinfo->SD_cid.ManufactDate|=tmp;
  467. 	tmp=(u8)(CID_Tab[3]&0x000000FF);			//第15个字节
  468. 	cardinfo->SD_cid.CID_CRC=(tmp&0xFE)>>1;
  469. 	cardinfo->SD_cid.Reserved2=1;
  470. 	return errorstatus;
  471. }
  472. //设置SDIO总线宽度(MMC卡不支持4bit模式)
  473. //wmode:位宽模式.0,1位数据宽度;1,4位数据宽度;2,8位数据宽度
  474. //返回值:SD卡错误状态
  475.  
  476. //设置SDIO总线宽度(MMC卡不支持4bit模式)
  477. //   @arg SDIO_BusWide_8b: 8-bit data transfer (Only for MMC)
  478. //   @arg SDIO_BusWide_4b: 4-bit data transfer
  479. //   @arg SDIO_BusWide_1b: 1-bit data transfer (默认)
  480. //返回值:SD卡错误状态
  481.  
  482. SD_Error SD_EnableWideBusOperation(u32 WideMode)
  483. {
  484.   	SD_Error errorstatus=SD_OK;
  485.   if (SDIO_MULTIMEDIA_CARD == CardType)
  486.   {
  487.     errorstatus = SD_UNSUPPORTED_FEATURE;
  488.     return(errorstatus);
  489.   }
  490.  
  491.  	else if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
  492. 	{
  493. 		 if (SDIO_BusWide_8b == WideMode)   //2.0 sd不支持8bits
  494.     {
  495.       errorstatus = SD_UNSUPPORTED_FEATURE;
  496.       return(errorstatus);
  497.     }
  498.  		else
  499. 		{
  500. 			errorstatus=SDEnWideBus(WideMode);
  501.  			if(SD_OK==errorstatus)
  502. 			{
  503. 				SDIO->CLKCR&=~(3<<11);		//清除之前的位宽设置
  504. 				SDIO->CLKCR|=WideMode;//1位/4位总线宽度
  505. 				SDIO->CLKCR|=0<<14;			//不开启硬件流控制
  506. 			}
  507. 		}
  508. 	}
  509. 	return errorstatus;
  510. }
  511. //设置SD卡工作模式
  512. //Mode:
  513. //返回值:错误状态
  514. SD_Error SD_SetDeviceMode(u32 Mode)
  515. {
  516. 	SD_Error errorstatus = SD_OK;
  517.  	if((Mode==SD_DMA_MODE)||(Mode==SD_POLLING_MODE))DeviceMode=Mode;
  518. 	else errorstatus=SD_INVALID_PARAMETER;
  519. 	return errorstatus;
  520. }
  521. //选卡
  522. //发送CMD7,选择相对地址(rca)为addr的卡,取消其他卡.如果为0,则都不选择.
  523. //addr:卡的RCA地址
  524. SD_Error SD_SelectDeselect(u32 addr)
  525. {
  526.  
  527.   SDIO_CmdInitStructure.SDIO_Argument =  addr;//发送CMD7,选择卡,短响应
  528.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEL_DESEL_CARD;
  529.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  530.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  531.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  532.   SDIO_SendCommand(&SDIO_CmdInitStructure);//发送CMD7,选择卡,短响应
  533.  
  534.  	return CmdResp1Error(SD_CMD_SEL_DESEL_CARD);
  535. }
  536. //SD卡读取一个块
  537. //buf:读数据缓存区(必须4字节对齐!!)
  538. //addr:读取地址
  539. //blksize:块大小
  540. SD_Error SD_ReadBlock(u8 *buf,long long addr,u16 blksize)
  541. {
  542. 	SD_Error errorstatus=SD_OK;
  543. 	u8 power;
  544.   u32 count=0,*tempbuff=(u32*)buf;//转换为u32指针
  545. 	u32 timeout=SDIO_DATATIMEOUT;
  546.   if(NULL==buf)
  547. 		return SD_INVALID_PARAMETER;
  548.   SDIO->DCTRL=0x0;	//数据控制寄存器清零(关DMA) 
  549.  
  550. 	if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
  551. 	{
  552. 		blksize=512;
  553. 		addr>>=9;
  554. 	}
  555.   	SDIO_DataInitStructure.SDIO_DataBlockSize= SDIO_DataBlockSize_1b ;//清除DPSM状态机配置
  556. 	  SDIO_DataInitStructure.SDIO_DataLength= 0 ;
  557. 	  SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  558. 	  SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  559. 	  SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  560. 	  SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  561.     SDIO_DataConfig(&SDIO_DataInitStructure);
  562.  
  563. 	if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡锁了
  564. 	if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
  565. 	{
  566. 		power=convert_from_bytes_to_power_of_two(blksize);	
  567.  
  568. 		SDIO_CmdInitStructure.SDIO_Argument =  blksize;
  569.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
  570.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  571.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  572.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  573.     SDIO_SendCommand(&SDIO_CmdInitStructure);//发送CMD16+设置数据长度为blksize,短响应
  574.  
  575. 		errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN);	//等待R1响应 
  576.  
  577. 		if(errorstatus!=SD_OK)return errorstatus;   	//响应错误	
  578.  
  579. 	}else return SD_INVALID_PARAMETER;	  	 
  580.  
  581. 	  SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4 ;//清除DPSM状态机配置
  582. 	  SDIO_DataInitStructure.SDIO_DataLength= blksize ;
  583. 	  SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  584. 	  SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  585. 	  SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO;
  586. 	  SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  587.     SDIO_DataConfig(&SDIO_DataInitStructure);
  588.  
  589. 	  SDIO_CmdInitStructure.SDIO_Argument =  addr;
  590.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
  591.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  592.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  593.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  594.     SDIO_SendCommand(&SDIO_CmdInitStructure);//发送CMD17+从addr地址出读取数据,短响应 
  595.  
  596. 	errorstatus=CmdResp1Error(SD_CMD_READ_SINGLE_BLOCK);//等待R1响应
  597. 	if(errorstatus!=SD_OK)return errorstatus;   		//响应错误
  598.  	if(DeviceMode==SD_POLLING_MODE)						//查询模式,轮询数据
  599. 	{
  600.  		INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)
  601. 		while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<10)|(1<<9))))//无上溢/CRC/超时/完成(标志)/起始位错误
  602. 		{
  603. 			if(SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET)						//接收区半满,表示至少存了8个字
  604. 			{
  605. 				for(count=0;count<8;count++)			//循环读取数据
  606. 				{
  607. 					*(tempbuff+count)=SDIO->FIFO;
  608. 				}
  609. 				tempbuff+=8;
  610. 				timeout=0X7FFFFF; 	//读数据溢出时间
  611. 			}else 	//处理超时
  612. 			{
  613. 				if(timeout==0)return SD_DATA_TIMEOUT;
  614. 				timeout--;
  615. 			}
  616. 		}
  617. 		if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)		//数据超时错误
  618. 		{
  619. 	 		SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); 	//清错误标志
  620. 			return SD_DATA_TIMEOUT;
  621. 	 	}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)	//数据块CRC错误
  622. 		{
  623. 	 		SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);  		//清错误标志
  624. 			return SD_DATA_CRC_FAIL;
  625. 		}else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) 	//接收fifo上溢错误
  626. 		{
  627. 	 		SDIO_ClearFlag(SDIO_FLAG_RXOVERR);		//清错误标志
  628. 			return SD_RX_OVERRUN;
  629. 		}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) 	//接收起始位错误
  630. 		{
  631. 	 		SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志
  632. 			return SD_START_BIT_ERR;
  633. 		}
  634. 		while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)	//FIFO里面,还存在可用数据
  635. 		{
  636. 			*tempbuff=SDIO->FIFO;	//循环读取数据
  637. 			tempbuff++;
  638. 		}
  639. 		INTX_ENABLE();//开启总中断
  640. 		SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  641.  
  642. 	}else if(DeviceMode==SD_DMA_MODE)
  643. 	{
  644.  		TransferError=SD_OK;
  645. 		StopCondition=0;			//单块读,不需要发送停止传输指令
  646. 		TransferEnd=0;				//传输结束标置位，在中断服务置1
  647. 		SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9);	//配置需要的中断
  648. 	 	SDIO->DCTRL|=1<<3;		 	//SDIO DMA使能
  649.  	    SD_DMA_Config((u32*)buf,blksize,DMA_DIR_PeripheralToMemory);
  650.  		while(((DMA2->LISR&(1<<27))==RESET)&&(TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;//等待传输完成
  651. 		if(timeout==0)return SD_DATA_TIMEOUT;//超时
  652. 		if(TransferError!=SD_OK)errorstatus=TransferError;
  653.     }
  654.  	return errorstatus;
  655. }
  656. //SD卡读取多个块
  657. //buf:读数据缓存区
  658. //addr:读取地址
  659. //blksize:块大小
  660. //nblks:要读取的块数
  661. //返回值:错误状态
  662. __align(4) u32 *tempbuff;
  663. SD_Error SD_ReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
  664. {
  665.   SD_Error errorstatus=SD_OK;
  666. 	u8 power;
  667.   u32 count=0;
  668. 	u32 timeout=SDIO_DATATIMEOUT;
  669. 	tempbuff=(u32*)buf;//转换为u32指针
  670.  
  671.   SDIO->DCTRL=0x0;		//数据控制寄存器清零(关DMA)
  672. 	if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
  673. 	{
  674. 		blksize=512;
  675. 		addr>>=9;
  676. 	}  
  677.  
  678. 	  SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM状态机配置
  679. 	  SDIO_DataInitStructure.SDIO_DataLength= 0 ;
  680. 	  SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  681. 	  SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  682. 	  SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  683. 	  SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  684.     SDIO_DataConfig(&SDIO_DataInitStructure);
  685.  
  686. 	if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡锁了
  687. 	if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
  688. 	{
  689. 		power=convert_from_bytes_to_power_of_two(blksize);	    
  690.  
  691. 	  SDIO_CmdInitStructure.SDIO_Argument =  blksize;//发送CMD16+设置数据长度为blksize,短响应
  692. 		SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
  693. 		SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  694. 		SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  695. 		SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  696. 		SDIO_SendCommand(&SDIO_CmdInitStructure);
  697.  
  698. 		errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN);	//等待R1响应  
  699.  
  700. 		if(errorstatus!=SD_OK)return errorstatus;   	//响应错误	 
  701.  
  702. 	}else return SD_INVALID_PARAMETER;	  
  703.  
  704. 	if(nblks>1)											//多块读
  705. 	{
  706.  	  	if(nblks*blksize>SD_MAX_DATA_LENGTH)return SD_INVALID_PARAMETER;//判断是否超过最大接收长度 
  707.  
  708. 		   SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ;//nblks*blksize,512块大小,卡到控制器
  709. 			 SDIO_DataInitStructure.SDIO_DataLength= nblks*blksize ;
  710. 			 SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  711. 			 SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  712. 			 SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO;
  713. 			 SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  714. 			 SDIO_DataConfig(&SDIO_DataInitStructure);
  715.  
  716.        SDIO_CmdInitStructure.SDIO_Argument =  addr;//发送CMD18+从addr地址出读取数据,短响应
  717. 	     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_MULT_BLOCK;
  718. 		   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  719. 		   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  720. 		   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  721. 		   SDIO_SendCommand(&SDIO_CmdInitStructure);	
  722.  
  723. 		errorstatus=CmdResp1Error(SD_CMD_READ_MULT_BLOCK);//等待R1响应 
  724.  
  725. 		if(errorstatus!=SD_OK)return errorstatus;   	//响应错误	 
  726.  
  727.  		if(DeviceMode==SD_POLLING_MODE)
  728. 		{
  729. 			INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)
  730. 			while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<8)|(1<<9))))//无上溢/CRC/超时/完成(标志)/起始位错误
  731. 			{
  732. 				if(SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET)						//接收区半满,表示至少存了8个字
  733. 				{
  734. 					for(count=0;count<8;count++)			//循环读取数据
  735. 					{
  736. 						*(tempbuff+count)=SDIO->FIFO;
  737. 					}
  738. 					tempbuff+=8;
  739. 					timeout=0X7FFFFF; 	//读数据溢出时间
  740. 				}else 	//处理超时
  741. 				{
  742. 					if(timeout==0)return SD_DATA_TIMEOUT;
  743. 					timeout--;
  744. 				}
  745. 			}
  746. 		if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)		//数据超时错误
  747. 		{
  748. 	 		SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); 	//清错误标志
  749. 			return SD_DATA_TIMEOUT;
  750. 	 	}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)	//数据块CRC错误
  751. 		{
  752. 	 		SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);  		//清错误标志
  753. 			return SD_DATA_CRC_FAIL;
  754. 		}else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) 	//接收fifo上溢错误
  755. 		{
  756. 	 		SDIO_ClearFlag(SDIO_FLAG_RXOVERR);		//清错误标志
  757. 			return SD_RX_OVERRUN;
  758. 		}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) 	//接收起始位错误
  759. 		{
  760. 	 		SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志
  761. 			return SD_START_BIT_ERR;
  762. 		}   
  763.  
  764. 		while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)	//FIFO里面,还存在可用数据
  765. 		{
  766. 			*tempbuff=SDIO->FIFO;	//循环读取数据
  767. 			tempbuff++;
  768. 		}
  769. 	 		if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)		//接收结束
  770. 			{
  771. 				if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
  772. 				{
  773. 					SDIO_CmdInitStructure.SDIO_Argument =  0;//发送CMD12+结束传输
  774. 				  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
  775. 					SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  776. 					SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  777. 					SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  778. 					SDIO_SendCommand(&SDIO_CmdInitStructure);	
  779.  
  780. 					errorstatus=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1响应   
  781.  
  782. 					if(errorstatus!=SD_OK)return errorstatus;
  783. 				}
  784.  			}
  785. 			INTX_ENABLE();//开启总中断
  786. 	 		SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  787.  		}else if(DeviceMode==SD_DMA_MODE)
  788. 		{
  789. 	   		TransferError=SD_OK;
  790. 			StopCondition=1;			//多块读,需要发送停止传输指令
  791. 			TransferEnd=0;				//传输结束标置位，在中断服务置1
  792. 			SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9);	//配置需要的中断
  793. 		 	SDIO->DCTRL|=1<<3;		 						//SDIO DMA使能
  794. 	 	    SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_PeripheralToMemory);
  795. 	 		while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待传输完成
  796. 			if(timeout==0)return SD_DATA_TIMEOUT;//超时
  797. 			while((TransferEnd==0)&&(TransferError==SD_OK));
  798. 			if(TransferError!=SD_OK)errorstatus=TransferError;
  799. 		}
  800.   	}
  801. 	return errorstatus;
  802. }
  803. //SD卡写1个块
  804. //buf:数据缓存区
  805. //addr:写地址
  806. //blksize:块大小
  807. //返回值:错误状态
  808. SD_Error SD_WriteBlock(u8 *buf,long long addr,  u16 blksize)
  809. {
  810. 	SD_Error errorstatus = SD_OK;
  811.  
  812. 	u8  power=0,cardstate=0;
  813.  
  814. 	u32 timeout=0,bytestransferred=0;
  815.  
  816. 	u32 cardstatus=0,count=0,restwords=0;
  817.  
  818. 	u32	tlen=blksize;						//总长度(字节)
  819.  
  820. 	u32*tempbuff=(u32*)buf;					
  821.  
  822.  	if(buf==NULL)return SD_INVALID_PARAMETER;//参数错误  
  823.  
  824.   SDIO->DCTRL=0x0;							//数据控制寄存器清零(关DMA)
  825.  
  826. 	SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM状态机配置
  827. 	SDIO_DataInitStructure.SDIO_DataLength= 0 ;
  828. 	SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  829. 	SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  830. 	SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  831. 	SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  832.   SDIO_DataConfig(&SDIO_DataInitStructure);
  833.  
  834. 	if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡锁了
  835.  	if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)	//大容量卡
  836. 	{
  837. 		blksize=512;
  838. 		addr>>=9;
  839. 	}
  840. 	if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
  841. 	{
  842. 		power=convert_from_bytes_to_power_of_two(blksize);	
  843.  
  844. 		SDIO_CmdInitStructure.SDIO_Argument = blksize;//发送CMD16+设置数据长度为blksize,短响应
  845. 		SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
  846. 		SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  847. 		SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  848. 		SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  849. 		SDIO_SendCommand(&SDIO_CmdInitStructure);	
  850.  
  851. 		errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN);	//等待R1响应  
  852.  
  853. 		if(errorstatus!=SD_OK)return errorstatus;   	//响应错误	 
  854.  
  855. 	}else return SD_INVALID_PARAMETER;	
  856.  
  857. 			SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;//发送CMD13,查询卡的状态,短响应
  858. 		  SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
  859. 			SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  860. 			SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  861. 			SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  862. 			SDIO_SendCommand(&SDIO_CmdInitStructure);	
  863.  
  864. 	  errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS);		//等待R1响应  
  865.  
  866. 	if(errorstatus!=SD_OK)return errorstatus;
  867. 	cardstatus=SDIO->RESP1;
  868. 	timeout=SD_DATATIMEOUT;
  869.    	while(((cardstatus&0x00000100)==0)&&(timeout>0)) 	//检查READY_FOR_DATA位是否置位
  870. 	{
  871. 		timeout--;  
  872.  
  873. 		SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;//发送CMD13,查询卡的状态,短响应
  874. 		SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
  875. 		SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  876. 		SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  877. 		SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  878. 		SDIO_SendCommand(&SDIO_CmdInitStructure);	
  879.  
  880. 		errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS);	//等待R1响应   
  881.  
  882. 		if(errorstatus!=SD_OK)return errorstatus;		
  883.  
  884. 		cardstatus=SDIO->RESP1;
  885. 	}
  886. 	if(timeout==0)return SD_ERROR;
  887.  
  888. 			SDIO_CmdInitStructure.SDIO_Argument = addr;//发送CMD24,写单块指令,短响应
  889. 			SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
  890. 			SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  891. 			SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  892. 			SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  893. 			SDIO_SendCommand(&SDIO_CmdInitStructure);	
  894.  
  895. 	errorstatus=CmdResp1Error(SD_CMD_WRITE_SINGLE_BLOCK);//等待R1响应  
  896.  
  897. 	if(errorstatus!=SD_OK)return errorstatus;   	 
  898.  
  899. 	StopCondition=0;									//单块写,不需要发送停止传输指令 
  900.  
  901. 	SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ;	//blksize, 控制器到卡
  902. 	SDIO_DataInitStructure.SDIO_DataLength= blksize ;
  903. 	SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  904. 	SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  905. 	SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  906. 	SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  907.   SDIO_DataConfig(&SDIO_DataInitStructure);
  908.  
  909. 	timeout=SDIO_DATATIMEOUT;
  910.  
  911. 	if (DeviceMode == SD_POLLING_MODE)
  912. 	{
  913. 		INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)
  914. 		while(!(SDIO->STA&((1<<10)|(1<<4)|(1<<1)|(1<<3)|(1<<9))))//数据块发送成功/下溢/CRC/超时/起始位错误
  915. 		{
  916. 			if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET)							//发送区半空,表示至少存了8个字
  917. 			{
  918. 				if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不够32字节了
  919. 				{
  920. 					restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);
  921.  
  922. 					for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4)
  923. 					{
  924. 						SDIO->FIFO=*tempbuff;
  925. 					}
  926. 				}else
  927. 				{
  928. 					for(count=0;count<8;count++)
  929. 					{
  930. 						SDIO->FIFO=*(tempbuff+count);
  931. 					}
  932. 					tempbuff+=8;
  933. 					bytestransferred+=32;
  934. 				}
  935. 				timeout=0X3FFFFFFF;	//写数据溢出时间
  936. 			}else
  937. 			{
  938. 				if(timeout==0)return SD_DATA_TIMEOUT;
  939. 				timeout--;
  940. 			}
  941. 		}
  942. 		if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)		//数据超时错误
  943. 		{
  944. 	 		SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); 	//清错误标志
  945. 			return SD_DATA_TIMEOUT;
  946. 	 	}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)	//数据块CRC错误
  947. 		{
  948. 	 		SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);  		//清错误标志
  949. 			return SD_DATA_CRC_FAIL;
  950. 		}else if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET) 	//接收fifo下溢错误
  951. 		{
  952. 	 		SDIO_ClearFlag(SDIO_FLAG_TXUNDERR);		//清错误标志
  953. 			return SD_TX_UNDERRUN;
  954. 		}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) 	//接收起始位错误
  955. 		{
  956. 	 		SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志
  957. 			return SD_START_BIT_ERR;
  958. 		}   
  959.  
  960. 		INTX_ENABLE();//开启总中断
  961. 		SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  962. 	}else if(DeviceMode==SD_DMA_MODE)
  963. 	{
  964.    		TransferError=SD_OK;
  965. 		StopCondition=0;			//单块写,不需要发送停止传输指令
  966. 		TransferEnd=0;				//传输结束标置位，在中断服务置1
  967. 		SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9);	//配置产生数据接收完成中断
  968. 		SD_DMA_Config((u32*)buf,blksize,DMA_DIR_MemoryToPeripheral);				//SDIO DMA配置
  969.  	 	SDIO->DCTRL|=1<<3;								//SDIO DMA使能.
  970.  		while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待传输完成
  971. 		if(timeout==0)
  972. 		{
  973.   			SD_Init();	 					//重新初始化SD卡,可以解决写入死机的问题
  974. 			return SD_DATA_TIMEOUT;			//超时
  975.  		}
  976. 		timeout=SDIO_DATATIMEOUT;
  977. 		while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;
  978.  		if(timeout==0)return SD_DATA_TIMEOUT;			//超时
  979.   		if(TransferError!=SD_OK)return TransferError;
  980.  	}
  981.  	SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  982.  	errorstatus=IsCardProgramming(&cardstate);
  983.  	while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING)))
  984. 	{
  985. 		errorstatus=IsCardProgramming(&cardstate);
  986. 	}
  987. 	return errorstatus;
  988. }
  989. //SD卡写多个块
  990. //buf:数据缓存区
  991. //addr:写地址
  992. //blksize:块大小
  993. //nblks:要写入的块数
  994. //返回值:错误状态
  995. SD_Error SD_WriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
  996. {
  997. 	SD_Error errorstatus = SD_OK;
  998. 	u8  power = 0, cardstate = 0;
  999. 	u32 timeout=0,bytestransferred=0;
  1000. 	u32 count = 0, restwords = 0;
  1001. 	u32 tlen=nblks*blksize;				//总长度(字节)
  1002. 	u32 *tempbuff = (u32*)buf;
  1003.   if(buf==NULL)return SD_INVALID_PARAMETER; //参数错误
  1004.   SDIO->DCTRL=0x0;							//数据控制寄存器清零(关DMA)   
  1005.  
  1006. 	SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;	//清除DPSM状态机配置
  1007. 	SDIO_DataInitStructure.SDIO_DataLength= 0 ;
  1008. 	SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  1009. 	SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  1010. 	SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  1011. 	SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  1012.   SDIO_DataConfig(&SDIO_DataInitStructure);
  1013.  
  1014. 	if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡锁了
  1015.  	if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
  1016. 	{
  1017. 		blksize=512;
  1018. 		addr>>=9;
  1019. 	}
  1020. 	if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
  1021. 	{
  1022. 		power=convert_from_bytes_to_power_of_two(blksize);
  1023.  
  1024. 		SDIO_CmdInitStructure.SDIO_Argument = blksize;	//发送CMD16+设置数据长度为blksize,短响应
  1025. 		SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
  1026. 		SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1027. 		SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1028. 		SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1029. 		SDIO_SendCommand(&SDIO_CmdInitStructure);	
  1030.  
  1031. 		errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN);	//等待R1响应  
  1032.  
  1033. 		if(errorstatus!=SD_OK)return errorstatus;   	//响应错误	 
  1034.  
  1035. 	}else return SD_INVALID_PARAMETER;
  1036. 	if(nblks>1)
  1037. 	{
  1038. 		if(nblks*blksize>SD_MAX_DATA_LENGTH)return SD_INVALID_PARAMETER;
  1039.      	if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
  1040.     	{
  1041. 			//提高性能
  1042. 				SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;		//发送ACMD55,短响应
  1043. 				SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
  1044. 				SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1045. 				SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1046. 				SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1047. 				SDIO_SendCommand(&SDIO_CmdInitStructure);	
  1048.  
  1049. 			errorstatus=CmdResp1Error(SD_CMD_APP_CMD);		//等待R1响应 
  1050.  
  1051. 			if(errorstatus!=SD_OK)return errorstatus;				 
  1052.  
  1053. 				SDIO_CmdInitStructure.SDIO_Argument =nblks;		//发送CMD23,设置块数量,短响应
  1054. 				SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCK_COUNT;
  1055. 				SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1056. 				SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1057. 				SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1058. 				SDIO_SendCommand(&SDIO_CmdInitStructure);
  1059.  
  1060. 				errorstatus=CmdResp1Error(SD_CMD_SET_BLOCK_COUNT);//等待R1响应 
  1061.  
  1062. 			if(errorstatus!=SD_OK)return errorstatus;		
  1063.  
  1064. 		} 
  1065.  
  1066. 				SDIO_CmdInitStructure.SDIO_Argument =addr;	//发送CMD25,多块写指令,短响应
  1067. 				SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
  1068. 				SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1069. 				SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1070. 				SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1071. 				SDIO_SendCommand(&SDIO_CmdInitStructure);	
  1072.  
  1073.  		errorstatus=CmdResp1Error(SD_CMD_WRITE_MULT_BLOCK);	//等待R1响应   		   
  1074.  
  1075. 		if(errorstatus!=SD_OK)return errorstatus;
  1076.  
  1077.         SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ;	//blksize, 控制器到卡
  1078. 				SDIO_DataInitStructure.SDIO_DataLength= nblks*blksize ;
  1079. 				SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  1080. 				SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  1081. 				SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  1082. 				SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  1083. 				SDIO_DataConfig(&SDIO_DataInitStructure);
  1084.  
  1085. 		if(DeviceMode==SD_POLLING_MODE)
  1086. 	    {
  1087. 			timeout=SDIO_DATATIMEOUT;
  1088. 			INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!)
  1089. 			while(!(SDIO->STA&((1<<4)|(1<<1)|(1<<8)|(1<<3)|(1<<9))))//下溢/CRC/数据结束/超时/起始位错误
  1090. 			{
  1091. 				if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET)							//发送区半空,表示至少存了8字(32字节)
  1092. 				{
  1093. 					if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不够32字节了
  1094. 					{
  1095. 						restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);
  1096. 						for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4)
  1097. 						{
  1098. 							SDIO->FIFO=*tempbuff;
  1099. 						}
  1100. 					}else 										//发送区半空,可以发送至少8字(32字节)数据
  1101. 					{
  1102. 						for(count=0;count<SD_HALFFIFO;count++)
  1103. 						{
  1104. 							SDIO->FIFO=*(tempbuff+count);
  1105. 						}
  1106. 						tempbuff+=SD_HALFFIFO;
  1107. 						bytestransferred+=SD_HALFFIFOBYTES;
  1108. 					}
  1109. 					timeout=0X3FFFFFFF;	//写数据溢出时间
  1110. 				}else
  1111. 				{
  1112. 					if(timeout==0)return SD_DATA_TIMEOUT;
  1113. 					timeout--;
  1114. 				}
  1115. 			}
  1116. 		if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)		//数据超时错误
  1117. 		{
  1118. 	 		SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); 	//清错误标志
  1119. 			return SD_DATA_TIMEOUT;
  1120. 	 	}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)	//数据块CRC错误
  1121. 		{
  1122. 	 		SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);  		//清错误标志
  1123. 			return SD_DATA_CRC_FAIL;
  1124. 		}else if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET) 	//接收fifo下溢错误
  1125. 		{
  1126. 	 		SDIO_ClearFlag(SDIO_FLAG_TXUNDERR);		//清错误标志
  1127. 			return SD_TX_UNDERRUN;
  1128. 		}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) 	//接收起始位错误
  1129. 		{
  1130. 	 		SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志
  1131. 			return SD_START_BIT_ERR;
  1132. 		}   
  1133.  
  1134. 			if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)		//发送结束
  1135. 			{
  1136. 				if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
  1137. 				{
  1138. 					SDIO_CmdInitStructure.SDIO_Argument =0;//发送CMD12+结束传输
  1139. 					SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
  1140. 					SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1141. 					SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1142. 					SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1143. 					SDIO_SendCommand(&SDIO_CmdInitStructure);	
  1144.  
  1145. 					errorstatus=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1响应
  1146. 					if(errorstatus!=SD_OK)return errorstatus;
  1147. 				}
  1148. 			}
  1149. 			INTX_ENABLE();//开启总中断
  1150. 	 		SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  1151. 	    }else if(DeviceMode==SD_DMA_MODE)
  1152. 		{
  1153. 	   	TransferError=SD_OK;
  1154. 			StopCondition=1;			//多块写,需要发送停止传输指令
  1155. 			TransferEnd=0;				//传输结束标置位，在中断服务置1
  1156. 			SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9);	//配置产生数据接收完成中断
  1157. 			SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_MemoryToPeripheral);		//SDIO DMA配置
  1158. 	 	 	SDIO->DCTRL|=1<<3;								//SDIO DMA使能.
  1159. 			timeout=SDIO_DATATIMEOUT;
  1160. 	 		while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待传输完成
  1161. 			if(timeout==0)	 								//超时
  1162. 			{
  1163.   				SD_Init();	 					//重新初始化SD卡,可以解决写入死机的问题
  1164. 	 			return SD_DATA_TIMEOUT;			//超时
  1165. 	 		}
  1166. 			timeout=SDIO_DATATIMEOUT;
  1167. 			while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;
  1168. 	 		if(timeout==0)return SD_DATA_TIMEOUT;			//超时
  1169. 	 		if(TransferError!=SD_OK)return TransferError;
  1170. 		}
  1171.   	}
  1172.  	SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  1173.  	errorstatus=IsCardProgramming(&cardstate);
  1174.  	while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING)))
  1175. 	{
  1176. 		errorstatus=IsCardProgramming(&cardstate);
  1177. 	}
  1178. 	return errorstatus;
  1179. }
  1180. //SDIO中断服务函数
  1181. void SDIO_IRQHandler(void)
  1182. {
  1183.  	SD_ProcessIRQSrc();//处理所有SDIO相关中断
  1184. }
  1185. //SDIO中断处理函数
  1186. //处理SDIO传输过程中的各种中断事务
  1187. //返回值:错误代码
  1188. SD_Error SD_ProcessIRQSrc(void)
  1189. {
  1190. 	if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)//接收完成中断
  1191. 	{
  1192. 		if (StopCondition==1)
  1193. 		{
  1194. 				SDIO_CmdInitStructure.SDIO_Argument =0;//发送CMD12+结束传输
  1195. 				SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
  1196. 				SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1197. 				SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1198. 				SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1199. 				SDIO_SendCommand(&SDIO_CmdInitStructure);	
  1200.  
  1201. 			TransferError=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);
  1202. 		}else TransferError = SD_OK;
  1203.  		SDIO->ICR|=1<<8;//清除完成中断标记
  1204. 		SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断
  1205.  		TransferEnd = 1;
  1206. 		return(TransferError);
  1207. 	}
  1208.  	if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)//数据CRC错误
  1209. 	{
  1210. 		SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);  		//清错误标志
  1211. 		SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断
  1212. 	    TransferError = SD_DATA_CRC_FAIL;
  1213. 	    return(SD_DATA_CRC_FAIL);
  1214. 	}
  1215.  	if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)//数据超时错误
  1216. 	{
  1217. 		SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);  			//清中断标志
  1218. 		SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断
  1219. 	    TransferError = SD_DATA_TIMEOUT;
  1220. 	    return(SD_DATA_TIMEOUT);
  1221. 	}
  1222.   	if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)//FIFO上溢错误
  1223. 	{
  1224. 		SDIO_ClearFlag(SDIO_FLAG_RXOVERR);  			//清中断标志
  1225. 		SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断
  1226. 	    TransferError = SD_RX_OVERRUN;
  1227. 	    return(SD_RX_OVERRUN);
  1228. 	}
  1229.    	if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET)//FIFO下溢错误
  1230. 	{
  1231. 		SDIO_ClearFlag(SDIO_FLAG_TXUNDERR);  			//清中断标志
  1232. 		SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断
  1233. 	    TransferError = SD_TX_UNDERRUN;
  1234. 	    return(SD_TX_UNDERRUN);
  1235. 	}
  1236. 	if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)//起始位错误
  1237. 	{
  1238. 		SDIO_ClearFlag(SDIO_FLAG_STBITERR);  		//清中断标志
  1239. 		SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断
  1240. 	    TransferError = SD_START_BIT_ERR;
  1241. 	    return(SD_START_BIT_ERR);
  1242. 	}
  1243. 	return(SD_OK);
  1244. }
  1245.  
  1246. //检查CMD0的执行状态
  1247. //返回值:sd卡错误码
  1248. SD_Error CmdError(void)
  1249. {
  1250. 	SD_Error errorstatus = SD_OK;
  1251. 	u32 timeout=SDIO_CMD0TIMEOUT;
  1252. 	while(timeout--)
  1253. 	{
  1254. 		if(SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT) != RESET)break;	//命令已发送(无需响应)
  1255. 	}
  1256. 	if(timeout==0)return SD_CMD_RSP_TIMEOUT;
  1257. 	SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  1258. 	return errorstatus;
  1259. }
  1260. //检查R7响应的错误状态
  1261. //返回值:sd卡错误码
  1262. SD_Error CmdResp7Error(void)
  1263. {
  1264. 	SD_Error errorstatus=SD_OK;
  1265. 	u32 status;
  1266. 	u32 timeout=SDIO_CMD0TIMEOUT;
  1267.  	while(timeout--)
  1268. 	{
  1269. 		status=SDIO->STA;
  1270. 		if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功)
  1271. 	}
  1272.  	if((timeout==0)||(status&(1<<2)))	//响应超时
  1273. 	{
  1274. 		errorstatus=SD_CMD_RSP_TIMEOUT;	//当前卡不是2.0兼容卡,或者不支持设定的电压范围
  1275. 		SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); 			//清除命令响应超时标志
  1276. 		return errorstatus;
  1277. 	}
  1278. 	if(status&1<<6)						//成功接收到响应
  1279. 	{
  1280. 		errorstatus=SD_OK;
  1281. 		SDIO_ClearFlag(SDIO_FLAG_CMDREND); 				//清除响应标志
  1282.  	}
  1283. 	return errorstatus;
  1284. }
  1285. //检查R1响应的错误状态
  1286. //cmd:当前命令
  1287. //返回值:sd卡错误码
  1288. SD_Error CmdResp1Error(u8 cmd)
  1289. {
  1290.    	u32 status;
  1291. 	while(1)
  1292. 	{
  1293. 		status=SDIO->STA;
  1294. 		if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功)
  1295. 	}
  1296. 	if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET)					//响应超时
  1297. 	{
  1298.  		SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); 				//清除命令响应超时标志
  1299. 		return SD_CMD_RSP_TIMEOUT;
  1300. 	}
  1301.  	if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET)					//CRC错误
  1302. 	{
  1303.  		SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); 				//清除标志
  1304. 		return SD_CMD_CRC_FAIL;
  1305. 	}
  1306. 	if(SDIO->RESPCMD!=cmd)return SD_ILLEGAL_CMD;//命令不匹配
  1307.   SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  1308. 	return (SD_Error)(SDIO->RESP1&SD_OCR_ERRORBITS);//返回卡响应
  1309. }
  1310. //检查R3响应的错误状态
  1311. //返回值:错误状态
  1312. SD_Error CmdResp3Error(void)
  1313. {
  1314. 	u32 status;
  1315.  	while(1)
  1316. 	{
  1317. 		status=SDIO->STA;
  1318. 		if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功)
  1319. 	}
  1320.  	if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET)					//响应超时
  1321. 	{
  1322. 		SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);			//清除命令响应超时标志
  1323. 		return SD_CMD_RSP_TIMEOUT;
  1324. 	}
  1325.    SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  1326.  	return SD_OK;
  1327. }
  1328. //检查R2响应的错误状态
  1329. //返回值:错误状态
  1330. SD_Error CmdResp2Error(void)
  1331. {
  1332. 	SD_Error errorstatus=SD_OK;
  1333. 	u32 status;
  1334. 	u32 timeout=SDIO_CMD0TIMEOUT;
  1335.  	while(timeout--)
  1336. 	{
  1337. 		status=SDIO->STA;
  1338. 		if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功)
  1339. 	}
  1340.   	if((timeout==0)||(status&(1<<2)))	//响应超时
  1341. 	{
  1342. 		errorstatus=SD_CMD_RSP_TIMEOUT;
  1343. 		SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); 		//清除命令响应超时标志
  1344. 		return errorstatus;
  1345. 	}
  1346. 	if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET)						//CRC错误
  1347. 	{
  1348. 		errorstatus=SD_CMD_CRC_FAIL;
  1349. 		SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);		//清除响应标志
  1350.  	}
  1351. 	SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  1352.  	return errorstatus;
  1353. }
  1354. //检查R6响应的错误状态
  1355. //cmd:之前发送的命令
  1356. //prca:卡返回的RCA地址
  1357. //返回值:错误状态
  1358. SD_Error CmdResp6Error(u8 cmd,u16*prca)
  1359. {
  1360. 	SD_Error errorstatus=SD_OK;
  1361. 	u32 status;
  1362. 	u32 rspr1;
  1363.  	while(1)
  1364. 	{
  1365. 		status=SDIO->STA;
  1366. 		if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功)
  1367. 	}
  1368. 	if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET)					//响应超时
  1369. 	{
  1370.  		SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);			//清除命令响应超时标志
  1371. 		return SD_CMD_RSP_TIMEOUT;
  1372. 	}
  1373. 	if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET)						//CRC错误
  1374. 	{
  1375. 		SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);					//清除响应标志
  1376.  		return SD_CMD_CRC_FAIL;
  1377. 	}
  1378. 	if(SDIO->RESPCMD!=cmd)				//判断是否响应cmd命令
  1379. 	{
  1380.  		return SD_ILLEGAL_CMD;
  1381. 	}
  1382. 	SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  1383. 	rspr1=SDIO->RESP1;					//得到响应
  1384. 	if(SD_ALLZERO==(rspr1&(SD_R6_GENERAL_UNKNOWN_ERROR|SD_R6_ILLEGAL_CMD|SD_R6_COM_CRC_FAILED)))
  1385. 	{
  1386. 		*prca=(u16)(rspr1>>16);			//右移16位得到,rca
  1387. 		return errorstatus;
  1388. 	}
  1389.    	if(rspr1&SD_R6_GENERAL_UNKNOWN_ERROR)return SD_GENERAL_UNKNOWN_ERROR;
  1390.    	if(rspr1&SD_R6_ILLEGAL_CMD)return SD_ILLEGAL_CMD;
  1391.    	if(rspr1&SD_R6_COM_CRC_FAILED)return SD_COM_CRC_FAILED;
  1392. 	return errorstatus;
  1393. }
  1394.  
  1395. //SDIO使能宽总线模式
  1396. //enx:0,不使能;1,使能;
  1397. //返回值:错误状态
  1398. SD_Error SDEnWideBus(u8 enx)
  1399. {
  1400. 	SD_Error errorstatus = SD_OK;
  1401.  	u32 scr[2]={0,0};
  1402. 	u8 arg=0X00;
  1403. 	if(enx)arg=0X02;
  1404. 	else arg=0X00;
  1405.  	if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//SD卡处于LOCKED状态
  1406.  	errorstatus=FindSCR(RCA,scr);						//得到SCR寄存器数据
  1407.  	if(errorstatus!=SD_OK)return errorstatus;
  1408. 	if((scr[1]&SD_WIDE_BUS_SUPPORT)!=SD_ALLZERO)		//支持宽总线
  1409. 	{
  1410. 		  SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;//发送CMD55+RCA,短响应
  1411.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
  1412.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1413.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1414.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1415.       SDIO_SendCommand(&SDIO_CmdInitStructure);
  1416.  
  1417. 	 	errorstatus=CmdResp1Error(SD_CMD_APP_CMD);
  1418.  
  1419. 	 	if(errorstatus!=SD_OK)return errorstatus; 
  1420.  
  1421. 		  SDIO_CmdInitStructure.SDIO_Argument = arg;//发送ACMD6,短响应,参数:10,4位;00,1位.
  1422.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
  1423.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1424.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1425.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1426.       SDIO_SendCommand(&SDIO_CmdInitStructure);
  1427.  
  1428.      errorstatus=CmdResp1Error(SD_CMD_APP_SD_SET_BUSWIDTH);
  1429.  
  1430. 		return errorstatus;
  1431. 	}else return SD_REQUEST_NOT_APPLICABLE;				//不支持宽总线设置
  1432. }
  1433. //检查卡是否正在执行写操作
  1434. //pstatus:当前状态.
  1435. //返回值:错误代码
  1436. SD_Error IsCardProgramming(u8 *pstatus)
  1437. {
  1438.  	vu32 respR1 = 0, status = 0;  
  1439.  
  1440.   SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16; //卡相对地址参数
  1441.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;//发送CMD13
  1442.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1443.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1444.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1445.   SDIO_SendCommand(&SDIO_CmdInitStructure);	
  1446.  
  1447. 	status=SDIO->STA;
  1448.  
  1449. 	while(!(status&((1<<0)|(1<<6)|(1<<2))))status=SDIO->STA;//等待操作完成
  1450.    	if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET)			//CRC检测失败
  1451. 	{
  1452. 	  SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);	//清除错误标记
  1453. 		return SD_CMD_CRC_FAIL;
  1454. 	}
  1455.    	if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET)			//命令超时
  1456. 	{
  1457. 		SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);			//清除错误标记
  1458. 		return SD_CMD_RSP_TIMEOUT;
  1459. 	}
  1460.  	if(SDIO->RESPCMD!=SD_CMD_SEND_STATUS)return SD_ILLEGAL_CMD;
  1461. 	SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  1462. 	respR1=SDIO->RESP1;
  1463. 	*pstatus=(u8)((respR1>>9)&0x0000000F);
  1464. 	return SD_OK;
  1465. }
  1466. //读取当前卡状态
  1467. //pcardstatus:卡状态
  1468. //返回值:错误代码
  1469. SD_Error SD_SendStatus(uint32_t *pcardstatus)
  1470. {
  1471. 	SD_Error errorstatus = SD_OK;
  1472. 	if(pcardstatus==NULL)
  1473. 	{
  1474. 		errorstatus=SD_INVALID_PARAMETER;
  1475. 		return errorstatus;
  1476. 	}
  1477.  
  1478. 	SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;//发送CMD13,短响应
  1479.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
  1480.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1481.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1482.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1483.   SDIO_SendCommand(&SDIO_CmdInitStructure);	
  1484.  
  1485. 	errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS);	//查询响应状态
  1486. 	if(errorstatus!=SD_OK)return errorstatus;
  1487. 	*pcardstatus=SDIO->RESP1;//读取响应值
  1488. 	return errorstatus;
  1489. }
  1490. //返回SD卡的状态
  1491. //返回值:SD卡状态
  1492. SDCardState SD_GetState(void)
  1493. {
  1494. 	u32 resp1=0;
  1495. 	if(SD_SendStatus(&resp1)!=SD_OK)return SD_CARD_ERROR;
  1496. 	else return (SDCardState)((resp1>>9) & 0x0F);
  1497. }
  1498. //查找SD卡的SCR寄存器值
  1499. //rca:卡相对地址
  1500. //pscr:数据缓存区(存储SCR内容)
  1501. //返回值:错误状态
  1502. SD_Error FindSCR(u16 rca,u32 *pscr)
  1503. {
  1504. 	u32 index = 0;
  1505. 	SD_Error errorstatus = SD_OK;
  1506. 	u32 tempscr[2]={0,0};  
  1507.  
  1508. 	SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)8;	 //发送CMD16,短响应,设置Block Size为8字节
  1509.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN; //	 cmd16
  1510.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;  //r1
  1511.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1512.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1513.   SDIO_SendCommand(&SDIO_CmdInitStructure);
  1514.  
  1515.  	errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN);
  1516.  
  1517.  	if(errorstatus!=SD_OK)return errorstatus;	 
  1518.  
  1519.   SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
  1520.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;//发送CMD55,短响应
  1521.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1522.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1523.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1524.   SDIO_SendCommand(&SDIO_CmdInitStructure);
  1525.  
  1526.  	errorstatus=CmdResp1Error(SD_CMD_APP_CMD);
  1527.  	if(errorstatus!=SD_OK)return errorstatus;
  1528.  
  1529.   SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  1530.   SDIO_DataInitStructure.SDIO_DataLength = 8;  //8个字节长度,block为8字节,SD卡到SDIO.
  1531.   SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_8b  ;  //块大小8byte
  1532.   SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
  1533.   SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  1534.   SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
  1535.   SDIO_DataConfig(&SDIO_DataInitStructure);		
  1536.  
  1537.   SDIO_CmdInitStructure.SDIO_Argument = 0x0;
  1538.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_SEND_SCR;	//发送ACMD51,短响应,参数为0
  1539.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;  //r1
  1540.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1541.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1542.   SDIO_SendCommand(&SDIO_CmdInitStructure);
  1543.  
  1544.  	errorstatus=CmdResp1Error(SD_CMD_SD_APP_SEND_SCR);
  1545.  	if(errorstatus!=SD_OK)return errorstatus;
  1546.  	while(!(SDIO->STA&(SDIO_FLAG_RXOVERR|SDIO_FLAG_DCRCFAIL|SDIO_FLAG_DTIMEOUT|SDIO_FLAG_DBCKEND|SDIO_FLAG_STBITERR)))
  1547. 	{
  1548. 		if(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)//接收FIFO数据可用
  1549. 		{
  1550. 			*(tempscr+index)=SDIO->FIFO;	//读取FIFO内容
  1551. 			index++;
  1552. 			if(index>=2)break;
  1553. 		}
  1554. 	}
  1555. 		if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)		//数据超时错误
  1556. 		{
  1557. 	 		SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); 	//清错误标志
  1558. 			return SD_DATA_TIMEOUT;
  1559. 	 	}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)	//数据块CRC错误
  1560. 		{
  1561. 	 		SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);  		//清错误标志
  1562. 			return SD_DATA_CRC_FAIL;
  1563. 		}else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) 	//接收fifo上溢错误
  1564. 		{
  1565. 	 		SDIO_ClearFlag(SDIO_FLAG_RXOVERR);		//清错误标志
  1566. 			return SD_RX_OVERRUN;
  1567. 		}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) 	//接收起始位错误
  1568. 		{
  1569. 	 		SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志
  1570. 			return SD_START_BIT_ERR;
  1571. 		}
  1572.    SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  1573. 	//把数据顺序按8位为单位倒过来.
  1574. 	*(pscr+1)=((tempscr[0]&SD_0TO7BITS)<<24)|((tempscr[0]&SD_8TO15BITS)<<8)|((tempscr[0]&SD_16TO23BITS)>>8)|((tempscr[0]&SD_24TO31BITS)>>24);
  1575. 	*(pscr)=((tempscr[1]&SD_0TO7BITS)<<24)|((tempscr[1]&SD_8TO15BITS)<<8)|((tempscr[1]&SD_16TO23BITS)>>8)|((tempscr[1]&SD_24TO31BITS)>>24);
  1576.  	return errorstatus;
  1577. }
  1578. //得到NumberOfBytes以2为底的指数.
  1579. //NumberOfBytes:字节数.
  1580. //返回值:以2为底的指数值
  1581. u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes)
  1582. {
  1583. 	u8 count=0;
  1584. 	while(NumberOfBytes!=1)
  1585. 	{
  1586. 		NumberOfBytes>>=1;
  1587. 		count++;
  1588. 	}
  1589. 	return count;
  1590. } 	 
  1591.  
  1592. //配置SDIO DMA
  1593. //mbuf:存储器地址
  1594. //bufsize:传输数据量
  1595. //dir:方向;DMA_DIR_MemoryToPeripheral  存储器-->SDIO(写数据);DMA_DIR_PeripheralToMemory SDIO-->存储器(读数据);
  1596. void SD_DMA_Config(u32*mbuf,u32 bufsize,u32 dir)
  1597. {		 
  1598.  
  1599.   DMA_InitTypeDef  DMA_InitStructure;
  1600.  
  1601. 	while (DMA_GetCmdStatus(DMA2_Stream3) != DISABLE){}//等待DMA可配置 
  1602.  
  1603.   DMA_DeInit(DMA2_Stream3);//清空之前该stream3上的所有中断标志
  1604.  
  1605.   DMA_InitStructure.DMA_Channel = DMA_Channel_4;  //通道选择
  1606.   DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&SDIO->FIFO;//DMA外设地址
  1607.   DMA_InitStructure.DMA_Memory0BaseAddr = (u32)mbuf;//DMA 存储器0地址
  1608.   DMA_InitStructure.DMA_DIR = dir;//存储器到外设模式
  1609.   DMA_InitStructure.DMA_BufferSize = 0;//数据传输量
  1610.   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//外设非增量模式
  1611.   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;//存储器增量模式
  1612.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;//外设数据长度:32位
  1613.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;//存储器数据长度:32位
  1614.   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;// 使用普通模式
  1615.   DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;//最高优先级
  1616.   DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;   //FIFO使能
  1617.   DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;//全FIFO
  1618.   DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_INC4;//外设突发4次传输
  1619.   DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_INC4;//存储器突发4次传输
  1620.   DMA_Init(DMA2_Stream3, &DMA_InitStructure);//初始化DMA Stream
  1621.  
  1622. 	DMA_FlowControllerConfig(DMA2_Stream3,DMA_FlowCtrl_Peripheral);//外设流控制 
  1623.  
  1624.   DMA_Cmd(DMA2_Stream3 ,ENABLE);//开启DMA传输	 
  1625.  
  1626. }   
  1627.  
  1628. //读SD卡
  1629. //buf:读数据缓存区
  1630. //sector:扇区地址
  1631. //cnt:扇区个数
  1632. //返回值:错误状态;0,正常;其他,错误代码;
  1633. u8 SD_ReadDisk(u8*buf,u32 sector,u8 cnt)
  1634. {
  1635. 	u8 sta=SD_OK;
  1636. 	long long lsector=sector;
  1637. 	u8 n;
  1638. 	lsector<<=9;
  1639. 	if((u32)buf%4!=0)
  1640. 	{
  1641. 	 	for(n=0;n<cnt;n++)
  1642. 		{
  1643. 		 	sta=SD_ReadBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//单个sector的读操作
  1644. 			memcpy(buf,SDIO_DATA_BUFFER,512);
  1645. 			buf+=512;
  1646. 		}
  1647. 	}else
  1648. 	{
  1649. 		if(cnt==1)sta=SD_ReadBlock(buf,lsector,512);    	//单个sector的读操作
  1650. 		else sta=SD_ReadMultiBlocks(buf,lsector,512,cnt);//多个sector
  1651. 	}
  1652. 	return sta;
  1653. }
  1654. //写SD卡
  1655. //buf:写数据缓存区
  1656. //sector:扇区地址
  1657. //cnt:扇区个数
  1658. //返回值:错误状态;0,正常;其他,错误代码;
  1659. u8 SD_WriteDisk(u8*buf,u32 sector,u8 cnt)
  1660. {
  1661. 	u8 sta=SD_OK;
  1662. 	u8 n;
  1663. 	long long lsector=sector;
  1664. 	lsector<<=9;
  1665. 	if((u32)buf%4!=0)
  1666. 	{
  1667. 	 	for(n=0;n<cnt;n++)
  1668. 		{
  1669. 			memcpy(SDIO_DATA_BUFFER,buf,512);
  1670. 		 	sta=SD_WriteBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//单个sector的写操作
  1671. 			buf+=512;
  1672. 		}
  1673. 	}else
  1674. 	{
  1675. 		if(cnt==1)sta=SD_WriteBlock(buf,lsector,512);    	//单个sector的写操作
  1676. 		else sta=SD_WriteMultiBlocks(buf,lsector,512,cnt);	//多个sector
  1677. 	}
  1678. 	return sta;
  1679. }

　　

这是头文件《sdio_sdcard.h》

  1. #ifndef __SDIO_SDCARD_H
  2. #define __SDIO_SDCARD_H
  3. #include "stm32f4xx.h" 													   
  4.  
  5. //SDIO相关标志位,拷贝自:stm32f4xx_sdio.h
  6. #define SDIO_FLAG_CCRCFAIL                  ((uint32_t)0x00000001)
  7. #define SDIO_FLAG_DCRCFAIL                  ((uint32_t)0x00000002)
  8. #define SDIO_FLAG_CTIMEOUT                  ((uint32_t)0x00000004)
  9. #define SDIO_FLAG_DTIMEOUT                  ((uint32_t)0x00000008)
  10. #define SDIO_FLAG_TXUNDERR                  ((uint32_t)0x00000010)
  11. #define SDIO_FLAG_RXOVERR                   ((uint32_t)0x00000020)
  12. #define SDIO_FLAG_CMDREND                   ((uint32_t)0x00000040)
  13. #define SDIO_FLAG_CMDSENT                   ((uint32_t)0x00000080)
  14. #define SDIO_FLAG_DATAEND                   ((uint32_t)0x00000100)
  15. #define SDIO_FLAG_STBITERR                  ((uint32_t)0x00000200)
  16. #define SDIO_FLAG_DBCKEND                   ((uint32_t)0x00000400)
  17. #define SDIO_FLAG_CMDACT                    ((uint32_t)0x00000800)
  18. #define SDIO_FLAG_TXACT                     ((uint32_t)0x00001000)
  19. #define SDIO_FLAG_RXACT                     ((uint32_t)0x00002000)
  20. #define SDIO_FLAG_TXFIFOHE                  ((uint32_t)0x00004000)
  21. #define SDIO_FLAG_RXFIFOHF                  ((uint32_t)0x00008000)
  22. #define SDIO_FLAG_TXFIFOF                   ((uint32_t)0x00010000)
  23. #define SDIO_FLAG_RXFIFOF                   ((uint32_t)0x00020000)
  24. #define SDIO_FLAG_TXFIFOE                   ((uint32_t)0x00040000)
  25. #define SDIO_FLAG_RXFIFOE                   ((uint32_t)0x00080000)
  26. #define SDIO_FLAG_TXDAVL                    ((uint32_t)0x00100000)
  27. #define SDIO_FLAG_RXDAVL                    ((uint32_t)0x00200000)
  28. #define SDIO_FLAG_SDIOIT                    ((uint32_t)0x00400000)
  29. #define SDIO_FLAG_CEATAEND                  ((uint32_t)0x00800000)
  30.  
  31. //用户配置区
  32. //SDIO时钟计算公式:SDIO_CK时钟=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定为48Mhz
  33. //使用DMA模式的时候,传输速率可以到48Mhz(bypass on时),不过如果你的卡不是高速
  34. //卡,可能也会出错,出错就请降低时钟
  35. #define SDIO_INIT_CLK_DIV        0x76 		//SDIO初始化频率，最大400Kh
  36. #define SDIO_TRANSFER_CLK_DIV    0x00		//SDIO传输频率,该值太小可能会导致读写文件出错 
  37.  
  38. ////////////////////////////////////////////////////////////////////////////////////////////////////
  39. //SDIO工作模式定义,通过SD_SetDeviceMode函数设置.
  40. #define SD_POLLING_MODE    	0  	//查询模式,该模式下,如果读写有问题,建议增大SDIO_TRANSFER_CLK_DIV的设置.
  41. #define SD_DMA_MODE    		1	//DMA模式,该模式下,如果读写有问题,建议增大SDIO_TRANSFER_CLK_DIV的设置.   
  42.  
  43. //SDIO 各种错误枚举定义
  44. typedef enum
  45. {
  46. 	//特殊错误定义
  47. 	SD_CMD_CRC_FAIL                    = (1), /*!< Command response received (but CRC check failed) */
  48. 	SD_DATA_CRC_FAIL                   = (2), /*!< Data bock sent/received (CRC check Failed) */
  49. 	SD_CMD_RSP_TIMEOUT                 = (3), /*!< Command response timeout */
  50. 	SD_DATA_TIMEOUT                    = (4), /*!< Data time out */
  51. 	SD_TX_UNDERRUN                     = (5), /*!< Transmit FIFO under-run */
  52. 	SD_RX_OVERRUN                      = (6), /*!< Receive FIFO over-run */
  53. 	SD_START_BIT_ERR                   = (7), /*!< Start bit not detected on all data signals in widE bus mode */
  54. 	SD_CMD_OUT_OF_RANGE                = (8), /*!< CMD's argument was out of range.*/
  55. 	SD_ADDR_MISALIGNED                 = (9), /*!< Misaligned address */
  56. 	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 */
  57. 	SD_ERASE_SEQ_ERR                   = (11), /*!< An error in the sequence of erase command occurs.*/
  58. 	SD_BAD_ERASE_PARAM                 = (12), /*!< An Invalid selection for erase groups */
  59. 	SD_WRITE_PROT_VIOLATION            = (13), /*!< Attempt to program a write protect block */
  60. 	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 */
  61. 	SD_COM_CRC_FAILED                  = (15), /*!< CRC check of the previous command failed */
  62. 	SD_ILLEGAL_CMD                     = (16), /*!< Command is not legal for the card state */
  63. 	SD_CARD_ECC_FAILED                 = (17), /*!< Card internal ECC was applied but failed to correct the data */
  64. 	SD_CC_ERROR                        = (18), /*!< Internal card controller error */
  65. 	SD_GENERAL_UNKNOWN_ERROR           = (19), /*!< General or Unknown error */
  66. 	SD_STREAM_READ_UNDERRUN            = (20), /*!< The card could not sustain data transfer in stream read operation. */
  67. 	SD_STREAM_WRITE_OVERRUN            = (21), /*!< The card could not sustain data programming in stream mode */
  68. 	SD_CID_CSD_OVERWRITE               = (22), /*!< CID/CSD overwrite error */
  69. 	SD_WP_ERASE_SKIP                   = (23), /*!< only partial address space was erased */
  70. 	SD_CARD_ECC_DISABLED               = (24), /*!< Command has been executed without using internal ECC */
  71. 	SD_ERASE_RESET                     = (25), /*!< Erase sequence was cleared before executing because an out of erase sequence command was received */
  72. 	SD_AKE_SEQ_ERROR                   = (26), /*!< Error in sequence of authentication. */
  73. 	SD_INVALID_VOLTRANGE               = (27),
  74. 	SD_ADDR_OUT_OF_RANGE               = (28),
  75. 	SD_SWITCH_ERROR                    = (29),
  76. 	SD_SDIO_DISABLED                   = (30),
  77. 	SD_SDIO_FUNCTION_BUSY              = (31),
  78. 	SD_SDIO_FUNCTION_FAILED            = (32),
  79. 	SD_SDIO_UNKNOWN_FUNCTION           = (33),
  80. 	//标准错误定义
  81. 	SD_INTERNAL_ERROR,
  82. 	SD_NOT_CONFIGURED,
  83. 	SD_REQUEST_PENDING,
  84. 	SD_REQUEST_NOT_APPLICABLE,
  85. 	SD_INVALID_PARAMETER,
  86. 	SD_UNSUPPORTED_FEATURE,
  87. 	SD_UNSUPPORTED_HW,
  88. 	SD_ERROR,
  89. 	SD_OK = 0
  90. } SD_Error;		  
  91.  
  92. //SD卡CSD寄存器数据
  93. typedef struct
  94. {
  95. 	u8  CSDStruct;            /*!< CSD structure */
  96. 	u8  SysSpecVersion;       /*!< System specification version */
  97. 	u8  Reserved1;            /*!< Reserved */
  98. 	u8  TAAC;                 /*!< Data read access-time 1 */
  99. 	u8  NSAC;                 /*!< Data read access-time 2 in CLK cycles */
  100. 	u8  MaxBusClkFrec;        /*!< Max. bus clock frequency */
  101. 	u16 CardComdClasses;      /*!< Card command classes */
  102. 	u8  RdBlockLen;           /*!< Max. read data block length */
  103. 	u8  PartBlockRead;        /*!< Partial blocks for read allowed */
  104. 	u8  WrBlockMisalign;      /*!< Write block misalignment */
  105. 	u8  RdBlockMisalign;      /*!< Read block misalignment */
  106. 	u8  DSRImpl;              /*!< DSR implemented */
  107. 	u8  Reserved2;            /*!< Reserved */
  108. 	u32 DeviceSize;           /*!< Device Size */
  109. 	u8  MaxRdCurrentVDDMin;   /*!< Max. read current @ VDD min */
  110. 	u8  MaxRdCurrentVDDMax;   /*!< Max. read current @ VDD max */
  111. 	u8  MaxWrCurrentVDDMin;   /*!< Max. write current @ VDD min */
  112. 	u8  MaxWrCurrentVDDMax;   /*!< Max. write current @ VDD max */
  113. 	u8  DeviceSizeMul;        /*!< Device size multiplier */
  114. 	u8  EraseGrSize;          /*!< Erase group size */
  115. 	u8  EraseGrMul;           /*!< Erase group size multiplier */
  116. 	u8  WrProtectGrSize;      /*!< Write protect group size */
  117. 	u8  WrProtectGrEnable;    /*!< Write protect group enable */
  118. 	u8  ManDeflECC;           /*!< Manufacturer default ECC */
  119. 	u8  WrSpeedFact;          /*!< Write speed factor */
  120. 	u8  MaxWrBlockLen;        /*!< Max. write data block length */
  121. 	u8  WriteBlockPaPartial;  /*!< Partial blocks for write allowed */
  122. 	u8  Reserved3;            /*!< Reserded */
  123. 	u8  ContentProtectAppli;  /*!< Content protection application */
  124. 	u8  FileFormatGrouop;     /*!< File format group */
  125. 	u8  CopyFlag;             /*!< Copy flag (OTP) */
  126. 	u8  PermWrProtect;        /*!< Permanent write protection */
  127. 	u8  TempWrProtect;        /*!< Temporary write protection */
  128. 	u8  FileFormat;           /*!< File Format */
  129. 	u8  ECC;                  /*!< ECC code */
  130. 	u8  CSD_CRC;              /*!< CSD CRC */
  131. 	u8  Reserved4;            /*!< always 1*/
  132. } SD_CSD;   
  133.  
  134. //SD卡CID寄存器数据
  135. typedef struct
  136. {
  137. 	u8  ManufacturerID;       /*!< ManufacturerID */
  138. 	u16 OEM_AppliID;          /*!< OEM/Application ID */
  139. 	u32 ProdName1;            /*!< Product Name part1 */
  140. 	u8  ProdName2;            /*!< Product Name part2*/
  141. 	u8  ProdRev;              /*!< Product Revision */
  142. 	u32 ProdSN;               /*!< Product Serial Number */
  143. 	u8  Reserved1;            /*!< Reserved1 */
  144. 	u16 ManufactDate;         /*!< Manufacturing Date */
  145. 	u8  CID_CRC;              /*!< CID CRC */
  146. 	u8  Reserved2;            /*!< always 1 */
  147. } SD_CID;
  148. //SD卡状态
  149. typedef enum
  150. {
  151. 	SD_CARD_READY                  = ((uint32_t)0x00000001),
  152. 	SD_CARD_IDENTIFICATION         = ((uint32_t)0x00000002),
  153. 	SD_CARD_STANDBY                = ((uint32_t)0x00000003),
  154. 	SD_CARD_TRANSFER               = ((uint32_t)0x00000004),
  155. 	SD_CARD_SENDING                = ((uint32_t)0x00000005),
  156. 	SD_CARD_RECEIVING              = ((uint32_t)0x00000006),
  157. 	SD_CARD_PROGRAMMING            = ((uint32_t)0x00000007),
  158. 	SD_CARD_DISCONNECTED           = ((uint32_t)0x00000008),
  159. 	SD_CARD_ERROR                  = ((uint32_t)0x000000FF)
  160. }SDCardState;
  161.  
  162. //SD卡信息,包括CSD,CID等数据
  163. typedef struct
  164. {
  165.   SD_CSD SD_csd;
  166.   SD_CID SD_cid;
  167.   long long CardCapacity;  	//SD卡容量,单位:字节,最大支持2^64字节大小的卡.
  168.   u32 CardBlockSize; 		//SD卡块大小
  169.   u16 RCA;					//卡相对地址
  170.   u8 CardType;				//卡类型
  171. } SD_CardInfo;
  172. extern SD_CardInfo SDCardInfo;//SD卡信息
  173. ////////////////////////////////////////////////////////////////////////////////////////////////////
  174. //SDIO 指令集
  175. #define SD_CMD_GO_IDLE_STATE                       ((u8)0)
  176. #define SD_CMD_SEND_OP_COND                        ((u8)1)
  177. #define SD_CMD_ALL_SEND_CID                        ((u8)2)
  178. #define SD_CMD_SET_REL_ADDR                        ((u8)3) /*!< SDIO_SEND_REL_ADDR for SD Card */
  179. #define SD_CMD_SET_DSR                             ((u8)4)
  180. #define SD_CMD_SDIO_SEN_OP_COND                    ((u8)5)
  181. #define SD_CMD_HS_SWITCH                           ((u8)6)
  182. #define SD_CMD_SEL_DESEL_CARD                      ((u8)7)
  183. #define SD_CMD_HS_SEND_EXT_CSD                     ((u8)8)
  184. #define SD_CMD_SEND_CSD                            ((u8)9)
  185. #define SD_CMD_SEND_CID                            ((u8)10)
  186. #define SD_CMD_READ_DAT_UNTIL_STOP                 ((u8)11) /*!< SD Card doesn't support it */
  187. #define SD_CMD_STOP_TRANSMISSION                   ((u8)12)
  188. #define SD_CMD_SEND_STATUS                         ((u8)13)
  189. #define SD_CMD_HS_BUSTEST_READ                     ((u8)14)
  190. #define SD_CMD_GO_INACTIVE_STATE                   ((u8)15)
  191. #define SD_CMD_SET_BLOCKLEN                        ((u8)16)
  192. #define SD_CMD_READ_SINGLE_BLOCK                   ((u8)17)
  193. #define SD_CMD_READ_MULT_BLOCK                     ((u8)18)
  194. #define SD_CMD_HS_BUSTEST_WRITE                    ((u8)19)
  195. #define SD_CMD_WRITE_DAT_UNTIL_STOP                ((u8)20)
  196. #define SD_CMD_SET_BLOCK_COUNT                     ((u8)23)
  197. #define SD_CMD_WRITE_SINGLE_BLOCK                  ((u8)24)
  198. #define SD_CMD_WRITE_MULT_BLOCK                    ((u8)25)
  199. #define SD_CMD_PROG_CID                            ((u8)26)
  200. #define SD_CMD_PROG_CSD                            ((u8)27)
  201. #define SD_CMD_SET_WRITE_PROT                      ((u8)28)
  202. #define SD_CMD_CLR_WRITE_PROT                      ((u8)29)
  203. #define SD_CMD_SEND_WRITE_PROT                     ((u8)30)
  204. #define SD_CMD_SD_ERASE_GRP_START                  ((u8)32) /*!< To set the address of the first write
  205.                                                                   block to be erased. (For SD card only) */
  206. #define SD_CMD_SD_ERASE_GRP_END                    ((u8)33) /*!< To set the address of the last write block of the
  207.                                                                   continuous range to be erased. (For SD card only) */
  208. #define SD_CMD_ERASE_GRP_START                     ((u8)35) /*!< To set the address of the first write block to be erased.
  209.                                                                   (For MMC card only spec 3.31) */
  210.  
  211. #define SD_CMD_ERASE_GRP_END                       ((u8)36) /*!< To set the address of the last write block of the
  212.                                                                   continuous range to be erased. (For MMC card only spec 3.31) */
  213.  
  214. #define SD_CMD_ERASE                               ((u8)38)
  215. #define SD_CMD_FAST_IO                             ((u8)39) /*!< SD Card doesn't support it */
  216. #define SD_CMD_GO_IRQ_STATE                        ((u8)40) /*!< SD Card doesn't support it */
  217. #define SD_CMD_LOCK_UNLOCK                         ((u8)42)
  218. #define SD_CMD_APP_CMD                             ((u8)55)
  219. #define SD_CMD_GEN_CMD                             ((u8)56)
  220. #define SD_CMD_NO_CMD                              ((u8)64)
  221.  
  222. /**
  223.   * @brief Following commands are SD Card Specific commands.
  224.   *        SDIO_APP_CMD ：CMD55 should be sent before sending these commands.
  225.   */
  226. #define SD_CMD_APP_SD_SET_BUSWIDTH                 ((u8)6)  /*!< For SD Card only */
  227. #define SD_CMD_SD_APP_STAUS                        ((u8)13) /*!< For SD Card only */
  228. #define SD_CMD_SD_APP_SEND_NUM_WRITE_BLOCKS        ((u8)22) /*!< For SD Card only */
  229. #define SD_CMD_SD_APP_OP_COND                      ((u8)41) /*!< For SD Card only */
  230. #define SD_CMD_SD_APP_SET_CLR_CARD_DETECT          ((u8)42) /*!< For SD Card only */
  231. #define SD_CMD_SD_APP_SEND_SCR                     ((u8)51) /*!< For SD Card only */
  232. #define SD_CMD_SDIO_RW_DIRECT                      ((u8)52) /*!< For SD I/O Card only */
  233. #define SD_CMD_SDIO_RW_EXTENDED                    ((u8)53) /*!< For SD I/O Card only */
  234.  
  235. /**
  236.   * @brief Following commands are SD Card Specific security commands.
  237.   *        SDIO_APP_CMD should be sent before sending these commands.
  238.   */
  239. #define SD_CMD_SD_APP_GET_MKB                      ((u8)43) /*!< For SD Card only */
  240. #define SD_CMD_SD_APP_GET_MID                      ((u8)44) /*!< For SD Card only */
  241. #define SD_CMD_SD_APP_SET_CER_RN1                  ((u8)45) /*!< For SD Card only */
  242. #define SD_CMD_SD_APP_GET_CER_RN2                  ((u8)46) /*!< For SD Card only */
  243. #define SD_CMD_SD_APP_SET_CER_RES2                 ((u8)47) /*!< For SD Card only */
  244. #define SD_CMD_SD_APP_GET_CER_RES1                 ((u8)48) /*!< For SD Card only */
  245. #define SD_CMD_SD_APP_SECURE_READ_MULTIPLE_BLOCK   ((u8)18) /*!< For SD Card only */
  246. #define SD_CMD_SD_APP_SECURE_WRITE_MULTIPLE_BLOCK  ((u8)25) /*!< For SD Card only */
  247. #define SD_CMD_SD_APP_SECURE_ERASE                 ((u8)38) /*!< For SD Card only */
  248. #define SD_CMD_SD_APP_CHANGE_SECURE_AREA           ((u8)49) /*!< For SD Card only */
  249. #define SD_CMD_SD_APP_SECURE_WRITE_MKB             ((u8)48) /*!< For SD Card only */
  250.  
  251. //支持的SD卡定义
  252. #define SDIO_STD_CAPACITY_SD_CARD_V1_1             ((u32)0x00000000)
  253. #define SDIO_STD_CAPACITY_SD_CARD_V2_0             ((u32)0x00000001)
  254. #define SDIO_HIGH_CAPACITY_SD_CARD                 ((u32)0x00000002)
  255. #define SDIO_MULTIMEDIA_CARD                       ((u32)0x00000003)
  256. #define SDIO_SECURE_DIGITAL_IO_CARD                ((u32)0x00000004)
  257. #define SDIO_HIGH_SPEED_MULTIMEDIA_CARD            ((u32)0x00000005)
  258. #define SDIO_SECURE_DIGITAL_IO_COMBO_CARD          ((u32)0x00000006)
  259. #define SDIO_HIGH_CAPACITY_MMC_CARD                ((u32)0x00000007)
  260.  
  261. //SDIO相关参数定义
  262. #define NULL 0
  263. #define SDIO_STATIC_FLAGS               ((u32)0x000005FF)
  264. #define SDIO_CMD0TIMEOUT                ((u32)0x00010000)
  265. #define SDIO_DATATIMEOUT                ((u32)0xFFFFFFFF)
  266. #define SDIO_FIFO_Address               ((u32)0x40018080)
  267.  
  268. //Mask for errors Card Status R1 (OCR Register)
  269. #define SD_OCR_ADDR_OUT_OF_RANGE        ((u32)0x80000000)
  270. #define SD_OCR_ADDR_MISALIGNED          ((u32)0x40000000)
  271. #define SD_OCR_BLOCK_LEN_ERR            ((u32)0x20000000)
  272. #define SD_OCR_ERASE_SEQ_ERR            ((u32)0x10000000)
  273. #define SD_OCR_BAD_ERASE_PARAM          ((u32)0x08000000)
  274. #define SD_OCR_WRITE_PROT_VIOLATION     ((u32)0x04000000)
  275. #define SD_OCR_LOCK_UNLOCK_FAILED       ((u32)0x01000000)
  276. #define SD_OCR_COM_CRC_FAILED           ((u32)0x00800000)
  277. #define SD_OCR_ILLEGAL_CMD              ((u32)0x00400000)
  278. #define SD_OCR_CARD_ECC_FAILED          ((u32)0x00200000)
  279. #define SD_OCR_CC_ERROR                 ((u32)0x00100000)
  280. #define SD_OCR_GENERAL_UNKNOWN_ERROR    ((u32)0x00080000)
  281. #define SD_OCR_STREAM_READ_UNDERRUN     ((u32)0x00040000)
  282. #define SD_OCR_STREAM_WRITE_OVERRUN     ((u32)0x00020000)
  283. #define SD_OCR_CID_CSD_OVERWRIETE       ((u32)0x00010000)
  284. #define SD_OCR_WP_ERASE_SKIP            ((u32)0x00008000)
  285. #define SD_OCR_CARD_ECC_DISABLED        ((u32)0x00004000)
  286. #define SD_OCR_ERASE_RESET              ((u32)0x00002000)
  287. #define SD_OCR_AKE_SEQ_ERROR            ((u32)0x00000008)
  288. #define SD_OCR_ERRORBITS                ((u32)0xFDFFE008)
  289.  
  290. //Masks for R6 Response
  291. #define SD_R6_GENERAL_UNKNOWN_ERROR     ((u32)0x00002000)
  292. #define SD_R6_ILLEGAL_CMD               ((u32)0x00004000)
  293. #define SD_R6_COM_CRC_FAILED            ((u32)0x00008000)
  294.  
  295. #define SD_VOLTAGE_WINDOW_SD            ((u32)0x80100000)
  296. #define SD_HIGH_CAPACITY                ((u32)0x40000000)
  297. #define SD_STD_CAPACITY                 ((u32)0x00000000)
  298. #define SD_CHECK_PATTERN                ((u32)0x000001AA)
  299. #define SD_VOLTAGE_WINDOW_MMC           ((u32)0x80FF8000)
  300.  
  301. #define SD_MAX_VOLT_TRIAL               ((u32)0x0000FFFF)
  302. #define SD_ALLZERO                      ((u32)0x00000000)
  303.  
  304. #define SD_WIDE_BUS_SUPPORT             ((u32)0x00040000)
  305. #define SD_SINGLE_BUS_SUPPORT           ((u32)0x00010000)
  306. #define SD_CARD_LOCKED                  ((u32)0x02000000)
  307. #define SD_CARD_PROGRAMMING             ((u32)0x00000007)
  308. #define SD_CARD_RECEIVING               ((u32)0x00000006)
  309. #define SD_DATATIMEOUT                  ((u32)0xFFFFFFFF)
  310. #define SD_0TO7BITS                     ((u32)0x000000FF)
  311. #define SD_8TO15BITS                    ((u32)0x0000FF00)
  312. #define SD_16TO23BITS                   ((u32)0x00FF0000)
  313. #define SD_24TO31BITS                   ((u32)0xFF000000)
  314. #define SD_MAX_DATA_LENGTH              ((u32)0x01FFFFFF)
  315.  
  316. #define SD_HALFFIFO                     ((u32)0x00000008)
  317. #define SD_HALFFIFOBYTES                ((u32)0x00000020)
  318.  
  319. //Command Class Supported
  320. #define SD_CCCC_LOCK_UNLOCK             ((u32)0x00000080)
  321. #define SD_CCCC_WRITE_PROT              ((u32)0x00000040)
  322. #define SD_CCCC_ERASE                   ((u32)0x00000020)
  323.  
  324. //CMD8指令
  325. #define SDIO_SEND_IF_COND               ((u32)0x00000008)
  326. ////////////////////////////////////////////////////////////////////////////////////////////////////
  327. //相关函数定义
  328. SD_Error SD_Init(void);
  329. void SDIO_Clock_Set(u8 clkdiv);
  330.  
  331. SD_Error SD_PowerON(void);
  332. SD_Error SD_PowerOFF(void);
  333. SD_Error SD_InitializeCards(void);
  334. SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo);
  335. SD_Error SD_EnableWideBusOperation(u32 wmode);
  336. SD_Error SD_SetDeviceMode(u32 mode);
  337. SD_Error SD_SelectDeselect(u32 addr);
  338. SD_Error SD_SendStatus(uint32_t *pcardstatus);
  339. SDCardState SD_GetState(void);
  340. SD_Error SD_ReadBlock(u8 *buf,long long addr,u16 blksize);
  341. SD_Error SD_ReadMultiBlocks(u8 *buf,long long  addr,u16 blksize,u32 nblks);
  342. SD_Error SD_WriteBlock(u8 *buf,long long addr,  u16 blksize);
  343. SD_Error SD_WriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks);
  344. SD_Error SD_ProcessIRQSrc(void);
  345.  
  346. void SD_DMA_Config(u32*mbuf,u32 bufsize,u32 dir);
  347. //void SD_DMA_Config(u32*mbuf,u32 bufsize,u8 dir); 
  348.  
  349. u8 SD_ReadDisk(u8*buf,u32 sector,u8 cnt); 	//读SD卡,fatfs/usb调用
  350. u8 SD_WriteDisk(u8*buf,u32 sector,u8 cnt);	//写SD卡,fatfs/usb调用
  351.  
  352. #endif

　　

　　

【STM32】使用SDIO进行SD卡读写，包含文件管理FatFs（七）-准备移植FatFs的更多相关文章

  1. 【STM32】使用SDIO进行SD卡读写，包含文件管理FatFs（终）-配合内存管理来遍历SD卡

    [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 [STM3 ...

  2. 【STM32】使用SDIO进行SD卡读写，包含文件管理FatFs（八）-认识内存管理

    [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 [STM3 ...

  3. 【STM32】使用SDIO进行SD卡读写，包含文件管理FatFs（六）-FatFs使用的思路介绍

    [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 [STM3 ...

  4. 【STM32】使用SDIO进行SD卡读写，包含文件管理FatFs（五）-文件管理初步介绍

    其他链接 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 ...

  5. 【STM32】使用SDIO进行SD卡读写，包含文件管理FatFs（一）-初步认识SD卡

    由于一张SD卡要能读写,涉及到的技术有些多,我打算分以下几篇博客 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含 ...

  6. 【STM32】使用SDIO进行SD卡读写，包含文件管理FatFs（二）-了解SD总线，命令的相关介绍

    其他链接 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 ...

  7. 【STM32】使用SDIO进行SD卡读写，包含文件管理FatFs（三）-SD卡的操作流程

    其他链接 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 ...

  8. 【STM32】使用SDIO进行SD卡读写，包含文件管理FatFs（四）-介绍库函数，获取一些SD卡的信息

    其他链接 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(一)-初步认识SD卡 [STM32]使用SDIO进行SD卡读写,包含文件管理FatFs(二)-了解SD总线,命令的相关介绍 ...

  9. 第36章 SDIO—SD卡读写测试

    第36章     SDIO—SD卡读写测试 全套200集视频教程和1000页PDF教程请到秉火论坛下载:www.firebbs.cn 野火视频教程优酷观看网址:http://i.youku.com/f ...

随机推荐

  1. vue路由监听和参数监听

    1.路由携带数据跳转 routerAction(hideDisplays, data) { switch (hideDisplays) { case "pubAccountMenu" ...

  2. springcloud优雅停止上下线与熔断

    SpringCloud 服务优雅上下线 Spring Boot 框架使用"约定大于配置"的特性,优雅流畅的开发过程,应用部署启动方式也很优雅.但是我们通常使用的停止应用的方式是 k ...

  3. Qt5 C++ GUI界面 开发环境配置 详细教程

    本博客已暂停更新,需要请转新博客http://www.whbwiki.com/333.html Qt 下载 Qt 体积很大,有 1GB~3GB,官方下载通道非常慢,相信很多读者会崩溃,所以建议大家使用 ...

  4. robot_framewok自动化测试--（4）常用关键字介绍

    常用关键字介绍 在学习一门编程语言的时候,大多教材都是从打印"hello world"开始.我们可以像编程语言一样来学习 Robot Framework.虽然通过 RIDE 提供& ...

  5. Part 61 to 63 Talking about partial class and partial method in C#

    部分类和部分方法 部分类是用partial声明的类,它允许我们把一个类分割成两个或多个类,当应用程序编译的完成的时候,多个部分类会结合成一个类,同时partial关键字也可以用于声明结构和接口. 那么 ...

  6. JAVA学习（六）

    今天先是把内存知识总结归纳地又学习了一遍,现在可以很清楚地描述JVM的内存是如何操作的了. 静态变量储存在方法区内存中,这个之前没有注意到,温故知新了. 如果一个引用是空的(就是指向null),那它在 ...

  7. Git项目迁移（把当前git项目迁移到新的git地址）

    使用 git clone --bare 命令clone当前git git clone --bare http://gitlab.xxx/demo.git 推到新的git地址 cd demo.git g ...

  8. Kubernetes 中的 gRPC 负载均衡

    安装环境依赖 docker-desktop >= 4.1.1 kubernetes >= 1.21.5 go >= 1.17 protobuf >= 3.17.3 istioc ...

  9. Ultraedit和写字板修改Tomcat 6.0的server.xml不生效

    转:http://blog.csdn.net/greencacti/article/details/6615321 本人在修改Tomcat 6.0的server.xml的时候,发现写字板修改完保存的时 ...

  10. Java的脚本机制、编译器API

    学习 xxl-job 定时任务时了解到基于 JVM 的 Grovvy 脚本语言.搭建 Jenkins 时知道了编译API 1. Java 脚本机制 Java 的脚本 API 可以让我们调用 JavaS ...